/* Generated code, see midgard.xml and gen_pack_header.py * * Packets, enums and structures for Panfrost. * * This file has been generated, do not hand edit. */ #ifndef PAN_PACK_H #define PAN_PACK_H #include #include #include #include #include #include #include "util/macros.h" #include "util/u_math.h" #define __gen_unpack_float(x, y, z) uif(__gen_unpack_uint(x, y, z)) static inline uint64_t __gen_uint(uint64_t v, uint32_t start, uint32_t end) { #ifndef NDEBUG const int width = end - start + 1; if (width < 64) { const uint64_t max = (1ull << width) - 1; assert(v <= max); } #endif return v << start; } static inline uint32_t __gen_sint(int32_t v, uint32_t start, uint32_t end) { #ifndef NDEBUG const int width = end - start + 1; if (width < 64) { const int64_t max = (1ll << (width - 1)) - 1; const int64_t min = -(1ll << (width - 1)); assert(min <= v && v <= max); } #endif return (((uint32_t) v) << start) & ((2ll << end) - 1); } static inline uint32_t __gen_padded(uint32_t v, uint32_t start, uint32_t end) { unsigned shift = __builtin_ctz(v); unsigned odd = v >> (shift + 1); #ifndef NDEBUG assert((v >> shift) & 1); assert(shift <= 31); assert(odd <= 7); assert((end - start + 1) == 8); #endif return __gen_uint(shift | (odd << 5), start, end); } static inline uint64_t __gen_unpack_uint(const uint8_t *restrict cl, uint32_t start, uint32_t end) { uint64_t val = 0; const int width = end - start + 1; const uint64_t mask = (width == 64 ? ~0 : (1ull << width) - 1 ); for (uint32_t byte = start / 8; byte <= end / 8; byte++) { val |= ((uint64_t) cl[byte]) << ((byte - start / 8) * 8); } return (val >> (start % 8)) & mask; } static inline uint64_t __gen_unpack_sint(const uint8_t *restrict cl, uint32_t start, uint32_t end) { int size = end - start + 1; int64_t val = __gen_unpack_uint(cl, start, end); /* Get the sign bit extended. */ return (val << (64 - size)) >> (64 - size); } static inline uint64_t __gen_unpack_padded(const uint8_t *restrict cl, uint32_t start, uint32_t end) { unsigned val = __gen_unpack_uint(cl, start, end); unsigned shift = val & 0b11111; unsigned odd = val >> 5; return (2*odd + 1) << shift; } #define PREFIX1(A) MALI_ ## A #define PREFIX2(A, B) MALI_ ## A ## _ ## B #define PREFIX4(A, B, C, D) MALI_ ## A ## _ ## B ## _ ## C ## _ ## D #define pan_prepare(dst, T) \ *(dst) = (struct PREFIX1(T)){ PREFIX2(T, header) } #define pan_pack(dst, T, name) \ for (struct PREFIX1(T) name = { PREFIX2(T, header) }, \ *_loop_terminate = (void *) (dst); \ __builtin_expect(_loop_terminate != NULL, 1); \ ({ PREFIX2(T, pack)((uint32_t *) (dst), &name); \ _loop_terminate = NULL; })) #define pan_unpack(src, T, name) \ struct PREFIX1(T) name; \ PREFIX2(T, unpack)((uint8_t *)(src), &name) #define pan_print(fp, T, var, indent) \ PREFIX2(T, print)(fp, &(var), indent) #define pan_size(T) PREFIX2(T, LENGTH) #define pan_alignment(T) PREFIX2(T, ALIGN) #define pan_section_offset(A, S) \ PREFIX4(A, SECTION, S, OFFSET) #define pan_section_ptr(base, A, S) \ ((void *)((uint8_t *)(base) + pan_section_offset(A, S))) #define pan_section_pack(dst, A, S, name) \ for (PREFIX4(A, SECTION, S, TYPE) name = { PREFIX4(A, SECTION, S, header) }, \ *_loop_terminate = (void *) (dst); \ __builtin_expect(_loop_terminate != NULL, 1); \ ({ PREFIX4(A, SECTION, S, pack) (pan_section_ptr(dst, A, S), &name); \ _loop_terminate = NULL; })) #define pan_section_unpack(src, A, S, name) \ PREFIX4(A, SECTION, S, TYPE) name; \ PREFIX4(A, SECTION, S, unpack)(pan_section_ptr(src, A, S), &name) #define pan_section_print(fp, A, S, var, indent) \ PREFIX4(A, SECTION, S, print)(fp, &(var), indent) #define pan_merge(packed1, packed2, type) do { for (unsigned i = 0; i < (PREFIX2(type, LENGTH) / 4); ++i) (packed1).opaque[i] |= (packed2).opaque[i]; } while(0) /* From presentations, 16x16 tiles externally. Use shift for fast computation * of tile numbers. */ #define MALI_TILE_SHIFT 4 #define MALI_TILE_LENGTH (1 << MALI_TILE_SHIFT) #define mali_pixel_format_print(fp, format) \ fprintf(fp, "%*sFormat (v6): %s%s%s %s%s%s%s\n", indent, "", \ mali_format_as_str((enum mali_format)((format >> 12) & 0xFF)), \ (format & (1 << 20)) ? " sRGB" : "", \ (format & (1 << 21)) ? " big-endian" : "", \ mali_channel_as_str((enum mali_channel)((format >> 0) & 0x7)), \ mali_channel_as_str((enum mali_channel)((format >> 3) & 0x7)), \ mali_channel_as_str((enum mali_channel)((format >> 6) & 0x7)), \ mali_channel_as_str((enum mali_channel)((format >> 9) & 0x7))); enum mali_attribute_type { MALI_ATTRIBUTE_TYPE_1D = 1, MALI_ATTRIBUTE_TYPE_1D_POT_DIVISOR = 2, MALI_ATTRIBUTE_TYPE_1D_MODULUS = 3, MALI_ATTRIBUTE_TYPE_1D_NPOT_DIVISOR = 4, MALI_ATTRIBUTE_TYPE_3D_LINEAR = 5, MALI_ATTRIBUTE_TYPE_3D_INTERLEAVED = 6, MALI_ATTRIBUTE_TYPE_1D_PRIMITIVE_INDEX_BUFFER = 7, MALI_ATTRIBUTE_TYPE_1D_POT_DIVISOR_WRITE_REDUCTION = 10, MALI_ATTRIBUTE_TYPE_1D_MODULUS_WRITE_REDUCTION = 11, MALI_ATTRIBUTE_TYPE_1D_NPOT_DIVISOR_WRITE_REDUCTION = 12, MALI_ATTRIBUTE_TYPE_CONTINUATION = 32, }; static inline const char * mali_attribute_type_as_str(enum mali_attribute_type imm) { switch (imm) { case MALI_ATTRIBUTE_TYPE_1D: return "1D"; case MALI_ATTRIBUTE_TYPE_1D_POT_DIVISOR: return "1D POT Divisor"; case MALI_ATTRIBUTE_TYPE_1D_MODULUS: return "1D Modulus"; case MALI_ATTRIBUTE_TYPE_1D_NPOT_DIVISOR: return "1D NPOT Divisor"; case MALI_ATTRIBUTE_TYPE_3D_LINEAR: return "3D Linear"; case MALI_ATTRIBUTE_TYPE_3D_INTERLEAVED: return "3D Interleaved"; case MALI_ATTRIBUTE_TYPE_1D_PRIMITIVE_INDEX_BUFFER: return "1D Primitive Index Buffer"; case MALI_ATTRIBUTE_TYPE_1D_POT_DIVISOR_WRITE_REDUCTION: return "1D POT Divisor Write Reduction"; case MALI_ATTRIBUTE_TYPE_1D_MODULUS_WRITE_REDUCTION: return "1D Modulus Write Reduction"; case MALI_ATTRIBUTE_TYPE_1D_NPOT_DIVISOR_WRITE_REDUCTION: return "1D NPOT Divisor Write Reduction"; case MALI_ATTRIBUTE_TYPE_CONTINUATION: return "Continuation"; default: return "XXX: INVALID"; } } enum mali_channel { MALI_CHANNEL_R = 0, MALI_CHANNEL_G = 1, MALI_CHANNEL_B = 2, MALI_CHANNEL_A = 3, MALI_CHANNEL_0 = 4, MALI_CHANNEL_1 = 5, }; static inline const char * mali_channel_as_str(enum mali_channel imm) { switch (imm) { case MALI_CHANNEL_R: return "R"; case MALI_CHANNEL_G: return "G"; case MALI_CHANNEL_B: return "B"; case MALI_CHANNEL_A: return "A"; case MALI_CHANNEL_0: return "0"; case MALI_CHANNEL_1: return "1"; default: return "XXX: INVALID"; } } enum mali_depth_source { MALI_DEPTH_SOURCE_MINIMUM = 0, MALI_DEPTH_SOURCE_MAXIMUM = 1, MALI_DEPTH_SOURCE_FIXED_FUNCTION = 2, MALI_DEPTH_SOURCE_SHADER = 3, }; static inline const char * mali_depth_source_as_str(enum mali_depth_source imm) { switch (imm) { case MALI_DEPTH_SOURCE_MINIMUM: return "Minimum"; case MALI_DEPTH_SOURCE_MAXIMUM: return "Maximum"; case MALI_DEPTH_SOURCE_FIXED_FUNCTION: return "Fixed function"; case MALI_DEPTH_SOURCE_SHADER: return "Shader"; default: return "XXX: INVALID"; } } enum mali_job_type { MALI_JOB_TYPE_NOT_STARTED = 0, MALI_JOB_TYPE_NULL = 1, MALI_JOB_TYPE_WRITE_VALUE = 2, MALI_JOB_TYPE_CACHE_FLUSH = 3, MALI_JOB_TYPE_COMPUTE = 4, MALI_JOB_TYPE_VERTEX = 5, MALI_JOB_TYPE_GEOMETRY = 6, MALI_JOB_TYPE_TILER = 7, MALI_JOB_TYPE_FUSED = 8, MALI_JOB_TYPE_FRAGMENT = 9, MALI_JOB_TYPE_INDEXED_VERTEX = 10, }; static inline const char * mali_job_type_as_str(enum mali_job_type imm) { switch (imm) { case MALI_JOB_TYPE_NOT_STARTED: return "Not started"; case MALI_JOB_TYPE_NULL: return "Null"; case MALI_JOB_TYPE_WRITE_VALUE: return "Write value"; case MALI_JOB_TYPE_CACHE_FLUSH: return "Cache flush"; case MALI_JOB_TYPE_COMPUTE: return "Compute"; case MALI_JOB_TYPE_VERTEX: return "Vertex"; case MALI_JOB_TYPE_GEOMETRY: return "Geometry"; case MALI_JOB_TYPE_TILER: return "Tiler"; case MALI_JOB_TYPE_FUSED: return "Fused"; case MALI_JOB_TYPE_FRAGMENT: return "Fragment"; case MALI_JOB_TYPE_INDEXED_VERTEX: return "Indexed Vertex"; default: return "XXX: INVALID"; } } enum mali_draw_mode { MALI_DRAW_MODE_NONE = 0, MALI_DRAW_MODE_POINTS = 1, MALI_DRAW_MODE_LINES = 2, MALI_DRAW_MODE_LINE_STRIP = 4, MALI_DRAW_MODE_LINE_LOOP = 6, MALI_DRAW_MODE_TRIANGLES = 8, MALI_DRAW_MODE_TRIANGLE_STRIP = 10, MALI_DRAW_MODE_TRIANGLE_FAN = 12, MALI_DRAW_MODE_POLYGON = 13, MALI_DRAW_MODE_QUADS = 14, MALI_DRAW_MODE_QUAD_STRIP = 15, }; static inline const char * mali_draw_mode_as_str(enum mali_draw_mode imm) { switch (imm) { case MALI_DRAW_MODE_NONE: return "None"; case MALI_DRAW_MODE_POINTS: return "Points"; case MALI_DRAW_MODE_LINES: return "Lines"; case MALI_DRAW_MODE_LINE_STRIP: return "Line strip"; case MALI_DRAW_MODE_LINE_LOOP: return "Line loop"; case MALI_DRAW_MODE_TRIANGLES: return "Triangles"; case MALI_DRAW_MODE_TRIANGLE_STRIP: return "Triangle strip"; case MALI_DRAW_MODE_TRIANGLE_FAN: return "Triangle fan"; case MALI_DRAW_MODE_POLYGON: return "Polygon"; case MALI_DRAW_MODE_QUADS: return "Quads"; case MALI_DRAW_MODE_QUAD_STRIP: return "Quad strip"; default: return "XXX: INVALID"; } } enum mali_exception_access { MALI_EXCEPTION_ACCESS_NONE = 0, MALI_EXCEPTION_ACCESS_EXECUTE = 2, MALI_EXCEPTION_ACCESS_READ = 1, MALI_EXCEPTION_ACCESS_WRITE = 3, }; static inline const char * mali_exception_access_as_str(enum mali_exception_access imm) { switch (imm) { case MALI_EXCEPTION_ACCESS_NONE: return "None"; case MALI_EXCEPTION_ACCESS_EXECUTE: return "Execute"; case MALI_EXCEPTION_ACCESS_READ: return "Read"; case MALI_EXCEPTION_ACCESS_WRITE: return "Write"; default: return "XXX: INVALID"; } } enum mali_func { MALI_FUNC_NEVER = 0, MALI_FUNC_LESS = 1, MALI_FUNC_EQUAL = 2, MALI_FUNC_LEQUAL = 3, MALI_FUNC_GREATER = 4, MALI_FUNC_NOT_EQUAL = 5, MALI_FUNC_GEQUAL = 6, MALI_FUNC_ALWAYS = 7, }; static inline const char * mali_func_as_str(enum mali_func imm) { switch (imm) { case MALI_FUNC_NEVER: return "Never"; case MALI_FUNC_LESS: return "Less"; case MALI_FUNC_EQUAL: return "Equal"; case MALI_FUNC_LEQUAL: return "Lequal"; case MALI_FUNC_GREATER: return "Greater"; case MALI_FUNC_NOT_EQUAL: return "Not Equal"; case MALI_FUNC_GEQUAL: return "Gequal"; case MALI_FUNC_ALWAYS: return "Always"; default: return "XXX: INVALID"; } } enum mali_format { MALI_ETC2_RGB8 = 1, MALI_ETC2_R11_UNORM = 2, MALI_ETC2_RGBA8 = 3, MALI_ETC2_RG11_UNORM = 4, MALI_BC1_UNORM = 7, MALI_BC2_UNORM = 8, MALI_BC3_UNORM = 9, MALI_BC4_UNORM = 10, MALI_BC4_SNORM = 11, MALI_BC5_UNORM = 12, MALI_BC5_SNORM = 13, MALI_BC6H_UF16 = 14, MALI_BC6H_SF16 = 15, MALI_BC7_UNORM = 16, MALI_ETC2_R11_SNORM = 17, MALI_ETC2_RG11_SNORM = 18, MALI_ETC2_RGB8A1 = 19, MALI_ASTC_3D_LDR = 20, MALI_ASTC_3D_HDR = 21, MALI_ASTC_2D_LDR = 22, MALI_ASTC_2D_HDR = 23, MALI_RGB565 = 64, MALI_RGB5_A1_UNORM = 65, MALI_A1_BGR5_UNORM = 66, MALI_RGB10_A2_UNORM = 67, MALI_A2_BGR10_UNORM = 68, MALI_RGB10_A2_SNORM = 69, MALI_A2_BGR10_SNORM = 70, MALI_RGB10_A2UI = 71, MALI_A2_BGR10UI = 72, MALI_RGB10_A2I = 73, MALI_A2_BGR10I = 74, MALI_Z24X8_UNORM = 77, MALI_X8Z24 = 78, MALI_X32_S8X24 = 79, MALI_X24S8_X32 = 80, MALI_R32_FIXED = 81, MALI_RG32_FIXED = 82, MALI_RGB32_FIXED = 83, MALI_RGBA32_FIXED = 84, MALI_R11F_G11F_B10F = 89, MALI_B10F_G11F_R11F = 90, MALI_R9F_G9F_B9F_E5F = 91, MALI_E5F_B9F_G9F_R9F = 92, MALI_SNAP_2 = 93, MALI_SNAP_4 = 94, MALI_CONSTANT = 95, MALI_R1_SNORM = 96, MALI_R2_SNORM = 97, MALI_R4_SNORM = 98, MALI_R8_SNORM = 99, MALI_R16_SNORM = 100, MALI_R32_SNORM = 101, MALI_R64_SNORM = 102, MALI_RG1_SNORM = 104, MALI_RG2_SNORM = 105, MALI_RG4_SNORM = 106, MALI_RG8_SNORM = 107, MALI_RG16_SNORM = 108, MALI_RG32_SNORM = 109, MALI_RG64_SNORM = 110, MALI_RGB1_SNORM = 112, MALI_RGB2_SNORM = 113, MALI_RGB4_SNORM = 114, MALI_RGB8_SNORM = 115, MALI_RGB16_SNORM = 116, MALI_RGB32_SNORM = 117, MALI_RGB64_SNORM = 118, MALI_RGBA1_SNORM = 120, MALI_RGBA2_SNORM = 121, MALI_RGBA4_SNORM = 122, MALI_RGBA8_SNORM = 123, MALI_RGBA16_SNORM = 124, MALI_RGBA32_SNORM = 125, MALI_RGBA64_SNORM = 126, MALI_R1UI = 128, MALI_R2UI = 129, MALI_R4UI = 130, MALI_R8UI = 131, MALI_R16UI = 132, MALI_R32UI = 133, MALI_R64UI = 134, MALI_R64F = 135, MALI_RG1UI = 136, MALI_RG2UI = 137, MALI_RG4UI = 138, MALI_RG8UI = 139, MALI_RG16UI = 140, MALI_RG32UI = 141, MALI_RG64UI = 142, MALI_RG64F = 143, MALI_RGB1UI = 144, MALI_RGB2UI = 145, MALI_RGB4UI = 146, MALI_RGB8UI = 147, MALI_RGB16UI = 148, MALI_RGB32UI = 149, MALI_RGB64UI = 150, MALI_RGB64F = 151, MALI_RGBA1UI = 152, MALI_RGBA2UI = 153, MALI_RGBA4UI = 154, MALI_RGBA8UI = 155, MALI_RGBA16UI = 156, MALI_RGBA32UI = 157, MALI_RGBA64UI = 158, MALI_RGBA64F = 159, MALI_R1_UNORM = 160, MALI_R2_UNORM = 161, MALI_R4_UNORM = 162, MALI_R8_UNORM = 163, MALI_R16_UNORM = 164, MALI_R32_UNORM = 165, MALI_R64_UNORM = 166, MALI_R32F = 167, MALI_RG1_UNORM = 168, MALI_RG2_UNORM = 169, MALI_RG4_UNORM = 170, MALI_RG8_UNORM = 171, MALI_RG16_UNORM = 172, MALI_RG32_UNORM = 173, MALI_RG64_UNORM = 174, MALI_RG32F = 175, MALI_RGB1_UNORM = 176, MALI_RGB2_UNORM = 177, MALI_RGB4_UNORM = 178, MALI_RGB8_UNORM = 179, MALI_RGB16_UNORM = 180, MALI_RGB32_UNORM = 181, MALI_RGB64_UNORM = 182, MALI_RGB32F = 183, MALI_RGBA1_UNORM = 184, MALI_RGBA2_UNORM = 185, MALI_RGBA4_UNORM = 186, MALI_RGBA8_UNORM = 187, MALI_RGBA16_UNORM = 188, MALI_RGBA32_UNORM = 189, MALI_RGBA64_UNORM = 190, MALI_RGBA32F = 191, MALI_R1I = 192, MALI_R2I = 193, MALI_R4I = 194, MALI_R8I = 195, MALI_R16I = 196, MALI_R32I = 197, MALI_R64I = 198, MALI_R16F = 199, MALI_RG1I = 200, MALI_RG2I = 201, MALI_RG4I = 202, MALI_RG8I = 203, MALI_RG16I = 204, MALI_RG32I = 205, MALI_RG64I = 206, MALI_RG16F = 207, MALI_RGB1I = 208, MALI_RGB2I = 209, MALI_RGB4I = 210, MALI_RGB8I = 211, MALI_RGB16I = 212, MALI_RGB32I = 213, MALI_RGB64I = 214, MALI_RGB16F = 215, MALI_RGBA1I = 216, MALI_RGBA2I = 217, MALI_RGBA4I = 218, MALI_RGBA8I = 219, MALI_RGBA16I = 220, MALI_RGBA32I = 221, MALI_RGBA64I = 222, MALI_RGBA16F = 223, MALI_RGB5_A1_AU = 224, MALI_RGB5_A1_PU = 225, MALI_R5G6B5_AU = 226, MALI_R5G6B5_PU = 227, MALI_SNAP4_V = 230, MALI_RGBA4_AU = 232, MALI_RGBA4_PU = 233, MALI_RGBA8_TB = 237, MALI_RGB10_A2_TB = 238, MALI_TESS_VERTEX_PACK = 240, MALI_RGB8_A2_AU = 241, MALI_RGB8_A2_PU = 242, }; static inline const char * mali_format_as_str(enum mali_format imm) { switch (imm) { case MALI_ETC2_RGB8: return "ETC2 RGB8"; case MALI_ETC2_R11_UNORM: return "ETC2 R11 UNORM"; case MALI_ETC2_RGBA8: return "ETC2 RGBA8"; case MALI_ETC2_RG11_UNORM: return "ETC2 RG11 UNORM"; case MALI_BC1_UNORM: return "BC1 UNORM"; case MALI_BC2_UNORM: return "BC2 UNORM"; case MALI_BC3_UNORM: return "BC3 UNORM"; case MALI_BC4_UNORM: return "BC4 UNORM"; case MALI_BC4_SNORM: return "BC4 SNORM"; case MALI_BC5_UNORM: return "BC5 UNORM"; case MALI_BC5_SNORM: return "BC5 SNORM"; case MALI_BC6H_UF16: return "BC6H UF16"; case MALI_BC6H_SF16: return "BC6H SF16"; case MALI_BC7_UNORM: return "BC7 UNORM"; case MALI_ETC2_R11_SNORM: return "ETC2 R11 SNORM"; case MALI_ETC2_RG11_SNORM: return "ETC2 RG11 SNORM"; case MALI_ETC2_RGB8A1: return "ETC2 RGB8A1"; case MALI_ASTC_3D_LDR: return "ASTC 3D LDR"; case MALI_ASTC_3D_HDR: return "ASTC 3D HDR"; case MALI_ASTC_2D_LDR: return "ASTC 2D LDR"; case MALI_ASTC_2D_HDR: return "ASTC 2D HDR"; case MALI_RGB565: return "RGB565"; case MALI_RGB5_A1_UNORM: return "RGB5 A1 UNORM"; case MALI_A1_BGR5_UNORM: return "A1 BGR5 UNORM"; case MALI_RGB10_A2_UNORM: return "RGB10 A2 UNORM"; case MALI_A2_BGR10_UNORM: return "A2 BGR10 UNORM"; case MALI_RGB10_A2_SNORM: return "RGB10 A2 SNORM"; case MALI_A2_BGR10_SNORM: return "A2 BGR10 SNORM"; case MALI_RGB10_A2UI: return "RGB10 A2UI"; case MALI_A2_BGR10UI: return "A2 BGR10UI"; case MALI_RGB10_A2I: return "RGB10 A2I"; case MALI_A2_BGR10I: return "A2 BGR10I"; case MALI_Z24X8_UNORM: return "Z24X8 UNORM"; case MALI_X8Z24: return "X8Z24"; case MALI_X32_S8X24: return "X32 S8X24"; case MALI_X24S8_X32: return "X24S8 X32"; case MALI_R32_FIXED: return "R32 FIXED"; case MALI_RG32_FIXED: return "RG32 FIXED"; case MALI_RGB32_FIXED: return "RGB32 FIXED"; case MALI_RGBA32_FIXED: return "RGBA32 FIXED"; case MALI_R11F_G11F_B10F: return "R11F G11F B10F"; case MALI_B10F_G11F_R11F: return "B10F G11F R11F"; case MALI_R9F_G9F_B9F_E5F: return "R9F G9F B9F E5F"; case MALI_E5F_B9F_G9F_R9F: return "E5F B9F G9F R9F"; case MALI_SNAP_2: return "Snap 2"; case MALI_SNAP_4: return "Snap 4"; case MALI_CONSTANT: return "Constant"; case MALI_R1_SNORM: return "R1 SNORM"; case MALI_R2_SNORM: return "R2 SNORM"; case MALI_R4_SNORM: return "R4 SNORM"; case MALI_R8_SNORM: return "R8 SNORM"; case MALI_R16_SNORM: return "R16 SNORM"; case MALI_R32_SNORM: return "R32 SNORM"; case MALI_R64_SNORM: return "R64 SNORM"; case MALI_RG1_SNORM: return "RG1 SNORM"; case MALI_RG2_SNORM: return "RG2 SNORM"; case MALI_RG4_SNORM: return "RG4 SNORM"; case MALI_RG8_SNORM: return "RG8 SNORM"; case MALI_RG16_SNORM: return "RG16 SNORM"; case MALI_RG32_SNORM: return "RG32 SNORM"; case MALI_RG64_SNORM: return "RG64 SNORM"; case MALI_RGB1_SNORM: return "RGB1 SNORM"; case MALI_RGB2_SNORM: return "RGB2 SNORM"; case MALI_RGB4_SNORM: return "RGB4 SNORM"; case MALI_RGB8_SNORM: return "RGB8 SNORM"; case MALI_RGB16_SNORM: return "RGB16 SNORM"; case MALI_RGB32_SNORM: return "RGB32 SNORM"; case MALI_RGB64_SNORM: return "RGB64 SNORM"; case MALI_RGBA1_SNORM: return "RGBA1 SNORM"; case MALI_RGBA2_SNORM: return "RGBA2 SNORM"; case MALI_RGBA4_SNORM: return "RGBA4 SNORM"; case MALI_RGBA8_SNORM: return "RGBA8 SNORM"; case MALI_RGBA16_SNORM: return "RGBA16 SNORM"; case MALI_RGBA32_SNORM: return "RGBA32 SNORM"; case MALI_RGBA64_SNORM: return "RGBA64 SNORM"; case MALI_R1UI: return "R1UI"; case MALI_R2UI: return "R2UI"; case MALI_R4UI: return "R4UI"; case MALI_R8UI: return "R8UI"; case MALI_R16UI: return "R16UI"; case MALI_R32UI: return "R32UI"; case MALI_R64UI: return "R64UI"; case MALI_R64F: return "R64F"; case MALI_RG1UI: return "RG1UI"; case MALI_RG2UI: return "RG2UI"; case MALI_RG4UI: return "RG4UI"; case MALI_RG8UI: return "RG8UI"; case MALI_RG16UI: return "RG16UI"; case MALI_RG32UI: return "RG32UI"; case MALI_RG64UI: return "RG64UI"; case MALI_RG64F: return "RG64F"; case MALI_RGB1UI: return "RGB1UI"; case MALI_RGB2UI: return "RGB2UI"; case MALI_RGB4UI: return "RGB4UI"; case MALI_RGB8UI: return "RGB8UI"; case MALI_RGB16UI: return "RGB16UI"; case MALI_RGB32UI: return "RGB32UI"; case MALI_RGB64UI: return "RGB64UI"; case MALI_RGB64F: return "RGB64F"; case MALI_RGBA1UI: return "RGBA1UI"; case MALI_RGBA2UI: return "RGBA2UI"; case MALI_RGBA4UI: return "RGBA4UI"; case MALI_RGBA8UI: return "RGBA8UI"; case MALI_RGBA16UI: return "RGBA16UI"; case MALI_RGBA32UI: return "RGBA32UI"; case MALI_RGBA64UI: return "RGBA64UI"; case MALI_RGBA64F: return "RGBA64F"; case MALI_R1_UNORM: return "R1 UNORM"; case MALI_R2_UNORM: return "R2 UNORM"; case MALI_R4_UNORM: return "R4 UNORM"; case MALI_R8_UNORM: return "R8 UNORM"; case MALI_R16_UNORM: return "R16 UNORM"; case MALI_R32_UNORM: return "R32 UNORM"; case MALI_R64_UNORM: return "R64 UNORM"; case MALI_R32F: return "R32F"; case MALI_RG1_UNORM: return "RG1 UNORM"; case MALI_RG2_UNORM: return "RG2 UNORM"; case MALI_RG4_UNORM: return "RG4 UNORM"; case MALI_RG8_UNORM: return "RG8 UNORM"; case MALI_RG16_UNORM: return "RG16 UNORM"; case MALI_RG32_UNORM: return "RG32 UNORM"; case MALI_RG64_UNORM: return "RG64 UNORM"; case MALI_RG32F: return "RG32F"; case MALI_RGB1_UNORM: return "RGB1 UNORM"; case MALI_RGB2_UNORM: return "RGB2 UNORM"; case MALI_RGB4_UNORM: return "RGB4 UNORM"; case MALI_RGB8_UNORM: return "RGB8 UNORM"; case MALI_RGB16_UNORM: return "RGB16 UNORM"; case MALI_RGB32_UNORM: return "RGB32 UNORM"; case MALI_RGB64_UNORM: return "RGB64 UNORM"; case MALI_RGB32F: return "RGB32F"; case MALI_RGBA1_UNORM: return "RGBA1 UNORM"; case MALI_RGBA2_UNORM: return "RGBA2 UNORM"; case MALI_RGBA4_UNORM: return "RGBA4 UNORM"; case MALI_RGBA8_UNORM: return "RGBA8 UNORM"; case MALI_RGBA16_UNORM: return "RGBA16 UNORM"; case MALI_RGBA32_UNORM: return "RGBA32 UNORM"; case MALI_RGBA64_UNORM: return "RGBA64 UNORM"; case MALI_RGBA32F: return "RGBA32F"; case MALI_R1I: return "R1I"; case MALI_R2I: return "R2I"; case MALI_R4I: return "R4I"; case MALI_R8I: return "R8I"; case MALI_R16I: return "R16I"; case MALI_R32I: return "R32I"; case MALI_R64I: return "R64I"; case MALI_R16F: return "R16F"; case MALI_RG1I: return "RG1I"; case MALI_RG2I: return "RG2I"; case MALI_RG4I: return "RG4I"; case MALI_RG8I: return "RG8I"; case MALI_RG16I: return "RG16I"; case MALI_RG32I: return "RG32I"; case MALI_RG64I: return "RG64I"; case MALI_RG16F: return "RG16F"; case MALI_RGB1I: return "RGB1I"; case MALI_RGB2I: return "RGB2I"; case MALI_RGB4I: return "RGB4I"; case MALI_RGB8I: return "RGB8I"; case MALI_RGB16I: return "RGB16I"; case MALI_RGB32I: return "RGB32I"; case MALI_RGB64I: return "RGB64I"; case MALI_RGB16F: return "RGB16F"; case MALI_RGBA1I: return "RGBA1I"; case MALI_RGBA2I: return "RGBA2I"; case MALI_RGBA4I: return "RGBA4I"; case MALI_RGBA8I: return "RGBA8I"; case MALI_RGBA16I: return "RGBA16I"; case MALI_RGBA32I: return "RGBA32I"; case MALI_RGBA64I: return "RGBA64I"; case MALI_RGBA16F: return "RGBA16F"; case MALI_RGB5_A1_AU: return "RGB5 A1 AU"; case MALI_RGB5_A1_PU: return "RGB5 A1 PU"; case MALI_R5G6B5_AU: return "R5G6B5 AU"; case MALI_R5G6B5_PU: return "R5G6B5 PU"; case MALI_SNAP4_V: return "Snap4 V"; case MALI_RGBA4_AU: return "RGBA4 AU"; case MALI_RGBA4_PU: return "RGBA4 PU"; case MALI_RGBA8_TB: return "RGBA8 TB"; case MALI_RGB10_A2_TB: return "RGB10 A2 TB"; case MALI_TESS_VERTEX_PACK: return "Tess Vertex Pack"; case MALI_RGB8_A2_AU: return "RGB8 A2 AU"; case MALI_RGB8_A2_PU: return "RGB8 A2 PU"; default: return "XXX: INVALID"; } } enum mali_yuv_swizzle { MALI_YUV_SWIZZLE_YUVA = 0, MALI_YUV_SWIZZLE_YVUA = 1, MALI_YUV_SWIZZLE_UYVA = 2, MALI_YUV_SWIZZLE_UVYA = 3, MALI_YUV_SWIZZLE_VUYA = 4, MALI_YUV_SWIZZLE_VYUA = 5, MALI_YUV_SWIZZLE_Y00A = 6, MALI_YUV_SWIZZLE_YXXA = 7, }; static inline const char * mali_yuv_swizzle_as_str(enum mali_yuv_swizzle imm) { switch (imm) { case MALI_YUV_SWIZZLE_YUVA: return "YUVA"; case MALI_YUV_SWIZZLE_YVUA: return "YVUA"; case MALI_YUV_SWIZZLE_UYVA: return "UYVA"; case MALI_YUV_SWIZZLE_UVYA: return "UVYA"; case MALI_YUV_SWIZZLE_VUYA: return "VUYA"; case MALI_YUV_SWIZZLE_VYUA: return "VYUA"; case MALI_YUV_SWIZZLE_Y00A: return "Y00A"; case MALI_YUV_SWIZZLE_YXXA: return "YXXA"; default: return "XXX: INVALID"; } } enum mali_yuv_conversion_mode { MALI_YUV_CONVERSION_MODE_NO_CONVERSION = 0, MALI_YUV_CONVERSION_MODE_BT_601 = 3, MALI_YUV_CONVERSION_MODE_BT_709 = 4, MALI_YUV_CONVERSION_MODE_BT_2020 = 6, }; static inline const char * mali_yuv_conversion_mode_as_str(enum mali_yuv_conversion_mode imm) { switch (imm) { case MALI_YUV_CONVERSION_MODE_NO_CONVERSION: return "No Conversion"; case MALI_YUV_CONVERSION_MODE_BT_601: return "BT 601"; case MALI_YUV_CONVERSION_MODE_BT_709: return "BT 709"; case MALI_YUV_CONVERSION_MODE_BT_2020: return "BT 2020"; default: return "XXX: INVALID"; } } enum mali_yuv_cr_siting { MALI_YUV_CR_SITING_CO_SITED = 0, MALI_YUV_CR_SITING_CENTER_Y = 1, MALI_YUV_CR_SITING_CENTER_X = 2, MALI_YUV_CR_SITING_CENTER = 3, MALI_YUV_CR_SITING_ONE_QUARTER = 4, MALI_YUV_CR_SITING_THREE_QUARTERS = 5, MALI_YUV_CR_SITING_REPLICATED = 7, }; static inline const char * mali_yuv_cr_siting_as_str(enum mali_yuv_cr_siting imm) { switch (imm) { case MALI_YUV_CR_SITING_CO_SITED: return "Co-Sited"; case MALI_YUV_CR_SITING_CENTER_Y: return "Center Y"; case MALI_YUV_CR_SITING_CENTER_X: return "Center X"; case MALI_YUV_CR_SITING_CENTER: return "Center"; case MALI_YUV_CR_SITING_ONE_QUARTER: return "One Quarter"; case MALI_YUV_CR_SITING_THREE_QUARTERS: return "Three Quarters"; case MALI_YUV_CR_SITING_REPLICATED: return "Replicated"; default: return "XXX: INVALID"; } } enum mali_astc_2d_dimension { MALI_ASTC_2D_DIMENSION_4 = 0, MALI_ASTC_2D_DIMENSION_5 = 1, MALI_ASTC_2D_DIMENSION_6 = 2, MALI_ASTC_2D_DIMENSION_8 = 4, MALI_ASTC_2D_DIMENSION_10 = 6, MALI_ASTC_2D_DIMENSION_12 = 7, }; static inline const char * mali_astc_2d_dimension_as_str(enum mali_astc_2d_dimension imm) { switch (imm) { case MALI_ASTC_2D_DIMENSION_4: return "4"; case MALI_ASTC_2D_DIMENSION_5: return "5"; case MALI_ASTC_2D_DIMENSION_6: return "6"; case MALI_ASTC_2D_DIMENSION_8: return "8"; case MALI_ASTC_2D_DIMENSION_10: return "10"; case MALI_ASTC_2D_DIMENSION_12: return "12"; default: return "XXX: INVALID"; } } enum mali_astc_3d_dimension { MALI_ASTC_3D_DIMENSION_4 = 0, MALI_ASTC_3D_DIMENSION_5 = 1, MALI_ASTC_3D_DIMENSION_6 = 2, MALI_ASTC_3D_DIMENSION_3 = 3, }; static inline const char * mali_astc_3d_dimension_as_str(enum mali_astc_3d_dimension imm) { switch (imm) { case MALI_ASTC_3D_DIMENSION_4: return "4"; case MALI_ASTC_3D_DIMENSION_5: return "5"; case MALI_ASTC_3D_DIMENSION_6: return "6"; case MALI_ASTC_3D_DIMENSION_3: return "3"; default: return "XXX: INVALID"; } } enum mali_pixel_kill { MALI_PIXEL_KILL_FORCE_EARLY = 0, MALI_PIXEL_KILL_STRONG_EARLY = 1, MALI_PIXEL_KILL_WEAK_EARLY = 2, MALI_PIXEL_KILL_FORCE_LATE = 3, }; static inline const char * mali_pixel_kill_as_str(enum mali_pixel_kill imm) { switch (imm) { case MALI_PIXEL_KILL_FORCE_EARLY: return "Force Early"; case MALI_PIXEL_KILL_STRONG_EARLY: return "Strong Early"; case MALI_PIXEL_KILL_WEAK_EARLY: return "Weak Early"; case MALI_PIXEL_KILL_FORCE_LATE: return "Force Late"; default: return "XXX: INVALID"; } } enum mali_block_format { MALI_BLOCK_FORMAT_TILED_U_INTERLEAVED = 0, MALI_BLOCK_FORMAT_TILED_LINEAR = 1, MALI_BLOCK_FORMAT_LINEAR = 2, MALI_BLOCK_FORMAT_AFBC = 3, }; static inline const char * mali_block_format_as_str(enum mali_block_format imm) { switch (imm) { case MALI_BLOCK_FORMAT_TILED_U_INTERLEAVED: return "Tiled U-Interleaved"; case MALI_BLOCK_FORMAT_TILED_LINEAR: return "Tiled Linear"; case MALI_BLOCK_FORMAT_LINEAR: return "Linear"; case MALI_BLOCK_FORMAT_AFBC: return "AFBC"; default: return "XXX: INVALID"; } } enum mali_mipmap_mode { MALI_MIPMAP_MODE_NEAREST = 0, MALI_MIPMAP_MODE_NONE = 1, MALI_MIPMAP_MODE_TRILINEAR = 3, }; static inline const char * mali_mipmap_mode_as_str(enum mali_mipmap_mode imm) { switch (imm) { case MALI_MIPMAP_MODE_NEAREST: return "Nearest"; case MALI_MIPMAP_MODE_NONE: return "None"; case MALI_MIPMAP_MODE_TRILINEAR: return "Trilinear"; default: return "XXX: INVALID"; } } enum mali_lod_algorithm { MALI_LOD_ALGORITHM_ISOTROPIC = 0, MALI_LOD_ALGORITHM_ANISOTROPIC = 3, }; static inline const char * mali_lod_algorithm_as_str(enum mali_lod_algorithm imm) { switch (imm) { case MALI_LOD_ALGORITHM_ISOTROPIC: return "Isotropic"; case MALI_LOD_ALGORITHM_ANISOTROPIC: return "Anisotropic"; default: return "XXX: INVALID"; } } enum mali_msaa { MALI_MSAA_SINGLE = 0, MALI_MSAA_AVERAGE = 1, MALI_MSAA_MULTIPLE = 2, MALI_MSAA_LAYERED = 3, }; static inline const char * mali_msaa_as_str(enum mali_msaa imm) { switch (imm) { case MALI_MSAA_SINGLE: return "Single"; case MALI_MSAA_AVERAGE: return "Average"; case MALI_MSAA_MULTIPLE: return "Multiple"; case MALI_MSAA_LAYERED: return "Layered"; default: return "XXX: INVALID"; } } enum mali_index_type { MALI_INDEX_TYPE_NONE = 0, MALI_INDEX_TYPE_UINT8 = 1, MALI_INDEX_TYPE_UINT16 = 2, MALI_INDEX_TYPE_UINT32 = 3, }; static inline const char * mali_index_type_as_str(enum mali_index_type imm) { switch (imm) { case MALI_INDEX_TYPE_NONE: return "None"; case MALI_INDEX_TYPE_UINT8: return "UINT8"; case MALI_INDEX_TYPE_UINT16: return "UINT16"; case MALI_INDEX_TYPE_UINT32: return "UINT32"; default: return "XXX: INVALID"; } } enum mali_occlusion_mode { MALI_OCCLUSION_MODE_DISABLED = 0, MALI_OCCLUSION_MODE_PREDICATE = 1, MALI_OCCLUSION_MODE_COUNTER = 3, }; static inline const char * mali_occlusion_mode_as_str(enum mali_occlusion_mode imm) { switch (imm) { case MALI_OCCLUSION_MODE_DISABLED: return "Disabled"; case MALI_OCCLUSION_MODE_PREDICATE: return "Predicate"; case MALI_OCCLUSION_MODE_COUNTER: return "Counter"; default: return "XXX: INVALID"; } } enum mali_stencil_op { MALI_STENCIL_OP_KEEP = 0, MALI_STENCIL_OP_REPLACE = 1, MALI_STENCIL_OP_ZERO = 2, MALI_STENCIL_OP_INVERT = 3, MALI_STENCIL_OP_INCR_WRAP = 4, MALI_STENCIL_OP_DECR_WRAP = 5, MALI_STENCIL_OP_INCR_SAT = 6, MALI_STENCIL_OP_DECR_SAT = 7, }; static inline const char * mali_stencil_op_as_str(enum mali_stencil_op imm) { switch (imm) { case MALI_STENCIL_OP_KEEP: return "Keep"; case MALI_STENCIL_OP_REPLACE: return "Replace"; case MALI_STENCIL_OP_ZERO: return "Zero"; case MALI_STENCIL_OP_INVERT: return "Invert"; case MALI_STENCIL_OP_INCR_WRAP: return "Incr Wrap"; case MALI_STENCIL_OP_DECR_WRAP: return "Decr Wrap"; case MALI_STENCIL_OP_INCR_SAT: return "Incr Sat"; case MALI_STENCIL_OP_DECR_SAT: return "Decr Sat"; default: return "XXX: INVALID"; } } enum mali_texture_dimension { MALI_TEXTURE_DIMENSION_CUBE = 0, MALI_TEXTURE_DIMENSION_1D = 1, MALI_TEXTURE_DIMENSION_2D = 2, MALI_TEXTURE_DIMENSION_3D = 3, }; static inline const char * mali_texture_dimension_as_str(enum mali_texture_dimension imm) { switch (imm) { case MALI_TEXTURE_DIMENSION_CUBE: return "Cube"; case MALI_TEXTURE_DIMENSION_1D: return "1D"; case MALI_TEXTURE_DIMENSION_2D: return "2D"; case MALI_TEXTURE_DIMENSION_3D: return "3D"; default: return "XXX: INVALID"; } } enum mali_texture_layout { MALI_TEXTURE_LAYOUT_TILED = 1, MALI_TEXTURE_LAYOUT_LINEAR = 2, MALI_TEXTURE_LAYOUT_AFBC = 12, }; static inline const char * mali_texture_layout_as_str(enum mali_texture_layout imm) { switch (imm) { case MALI_TEXTURE_LAYOUT_TILED: return "Tiled"; case MALI_TEXTURE_LAYOUT_LINEAR: return "Linear"; case MALI_TEXTURE_LAYOUT_AFBC: return "AFBC"; default: return "XXX: INVALID"; } } enum mali_afbc_surface_flag { MALI_AFBC_SURFACE_FLAG_YTR = 1, MALI_AFBC_SURFACE_FLAG_SPLIT_BLOCK = 2, MALI_AFBC_SURFACE_FLAG_WIDE_BLOCK = 4, MALI_AFBC_SURFACE_FLAG_TILED_HEADER = 8, MALI_AFBC_SURFACE_FLAG_PREFETCH = 16, MALI_AFBC_SURFACE_FLAG_CHECK_PAYLOAD_RANGE = 32, }; static inline const char * mali_afbc_surface_flag_as_str(enum mali_afbc_surface_flag imm) { switch (imm) { case MALI_AFBC_SURFACE_FLAG_YTR: return "YTR"; case MALI_AFBC_SURFACE_FLAG_SPLIT_BLOCK: return "Split Block"; case MALI_AFBC_SURFACE_FLAG_WIDE_BLOCK: return "Wide Block"; case MALI_AFBC_SURFACE_FLAG_TILED_HEADER: return "Tiled Header"; case MALI_AFBC_SURFACE_FLAG_PREFETCH: return "Prefetch"; case MALI_AFBC_SURFACE_FLAG_CHECK_PAYLOAD_RANGE: return "Check Payload Range"; default: return "XXX: INVALID"; } } enum mali_wrap_mode { MALI_WRAP_MODE_REPEAT = 8, MALI_WRAP_MODE_CLAMP_TO_EDGE = 9, MALI_WRAP_MODE_CLAMP_TO_BORDER = 11, MALI_WRAP_MODE_MIRRORED_REPEAT = 12, MALI_WRAP_MODE_MIRRORED_CLAMP_TO_EDGE = 13, MALI_WRAP_MODE_MIRRORED_CLAMP_TO_BORDER = 15, }; static inline const char * mali_wrap_mode_as_str(enum mali_wrap_mode imm) { switch (imm) { case MALI_WRAP_MODE_REPEAT: return "Repeat"; case MALI_WRAP_MODE_CLAMP_TO_EDGE: return "Clamp to Edge"; case MALI_WRAP_MODE_CLAMP_TO_BORDER: return "Clamp to Border"; case MALI_WRAP_MODE_MIRRORED_REPEAT: return "Mirrored Repeat"; case MALI_WRAP_MODE_MIRRORED_CLAMP_TO_EDGE: return "Mirrored Clamp to Edge"; case MALI_WRAP_MODE_MIRRORED_CLAMP_TO_BORDER: return "Mirrored Clamp to Border"; default: return "XXX: INVALID"; } } struct MALI_ATTRIBUTE { uint32_t buffer_index; bool offset_enable; uint32_t format; int32_t offset; }; #define MALI_ATTRIBUTE_header \ .offset_enable = true static inline void MALI_ATTRIBUTE_pack(uint32_t * restrict cl, const struct MALI_ATTRIBUTE * restrict values) { cl[ 0] = __gen_uint(values->buffer_index, 0, 8) | __gen_uint(values->offset_enable, 9, 9) | __gen_uint(values->format, 10, 31); cl[ 1] = __gen_sint(values->offset, 0, 31); } #define MALI_ATTRIBUTE_LENGTH 8 #define MALI_ATTRIBUTE_ALIGN 8 struct mali_attribute_packed { uint32_t opaque[2]; }; static inline void MALI_ATTRIBUTE_unpack(const uint8_t * restrict cl, struct MALI_ATTRIBUTE * restrict values) { values->buffer_index = __gen_unpack_uint(cl, 0, 8); values->offset_enable = __gen_unpack_uint(cl, 9, 9); values->format = __gen_unpack_uint(cl, 10, 31); values->offset = __gen_unpack_sint(cl, 32, 63); } static inline void MALI_ATTRIBUTE_print(FILE *fp, const struct MALI_ATTRIBUTE * values, unsigned indent) { fprintf(fp, "%*sBuffer index: %u\n", indent, "", values->buffer_index); fprintf(fp, "%*sOffset enable: %s\n", indent, "", values->offset_enable ? "true" : "false"); mali_pixel_format_print(fp, values->format); fprintf(fp, "%*sOffset: %d\n", indent, "", values->offset); } struct MALI_ATTRIBUTE_BUFFER { enum mali_attribute_type type; uint64_t pointer; uint32_t stride; uint32_t size; uint32_t divisor; uint32_t divisor_r; uint32_t divisor_p; uint32_t divisor_e; }; #define MALI_ATTRIBUTE_BUFFER_header \ .type = MALI_ATTRIBUTE_TYPE_1D, \ .divisor = 1 static inline void MALI_ATTRIBUTE_BUFFER_pack(uint32_t * restrict cl, const struct MALI_ATTRIBUTE_BUFFER * restrict values) { assert((values->pointer & 0x3f) == 0); cl[ 0] = __gen_uint(values->type, 0, 5) | __gen_uint(values->pointer >> 6, 6, 55); cl[ 1] = __gen_uint(values->pointer >> 6, 6, 55) >> 32 | __gen_padded(values->divisor, 24, 31) | __gen_uint(values->divisor_r, 24, 28) | __gen_uint(values->divisor_p, 29, 31) | __gen_uint(values->divisor_e, 29, 29); cl[ 2] = __gen_uint(values->stride, 0, 31); cl[ 3] = __gen_uint(values->size, 0, 31); } #define MALI_ATTRIBUTE_BUFFER_LENGTH 16 #define MALI_ATTRIBUTE_BUFFER_ALIGN 32 struct mali_attribute_buffer_packed { uint32_t opaque[4]; }; static inline void MALI_ATTRIBUTE_BUFFER_unpack(const uint8_t * restrict cl, struct MALI_ATTRIBUTE_BUFFER * restrict values) { values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5); values->pointer = __gen_unpack_uint(cl, 6, 55) << 6; values->stride = __gen_unpack_uint(cl, 64, 95); values->size = __gen_unpack_uint(cl, 96, 127); values->divisor = __gen_unpack_padded(cl, 56, 63); values->divisor_r = __gen_unpack_uint(cl, 56, 60); values->divisor_p = __gen_unpack_uint(cl, 61, 63); values->divisor_e = __gen_unpack_uint(cl, 61, 61); } static inline void MALI_ATTRIBUTE_BUFFER_print(FILE *fp, const struct MALI_ATTRIBUTE_BUFFER * values, unsigned indent) { fprintf(fp, "%*sType: %s\n", indent, "", mali_attribute_type_as_str(values->type)); fprintf(fp, "%*sPointer: 0x%" PRIx64 "\n", indent, "", values->pointer); fprintf(fp, "%*sStride: %u\n", indent, "", values->stride); fprintf(fp, "%*sSize: %u\n", indent, "", values->size); fprintf(fp, "%*sDivisor: %u\n", indent, "", values->divisor); fprintf(fp, "%*sDivisor R: %u\n", indent, "", values->divisor_r); fprintf(fp, "%*sDivisor P: %u\n", indent, "", values->divisor_p); fprintf(fp, "%*sDivisor E: %u\n", indent, "", values->divisor_e); } struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT { enum mali_attribute_type type; uint32_t divisor_numerator; uint32_t divisor; }; #define MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_header\ .type = MALI_ATTRIBUTE_TYPE_CONTINUATION static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_pack(uint32_t * restrict cl, const struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT * restrict values) { cl[ 0] = __gen_uint(values->type, 0, 5); cl[ 1] = __gen_uint(values->divisor_numerator, 0, 31); cl[ 2] = 0; cl[ 3] = __gen_uint(values->divisor, 0, 31); } #define MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_LENGTH 16 struct mali_attribute_buffer_continuation_npot_packed { uint32_t opaque[4]; }; static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_unpack(const uint8_t * restrict cl, struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffc0) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation NPOT unpacked at word 0\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation NPOT unpacked at word 2\n"); values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5); values->divisor_numerator = __gen_unpack_uint(cl, 32, 63); values->divisor = __gen_unpack_uint(cl, 96, 127); } static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_print(FILE *fp, const struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT * values, unsigned indent) { fprintf(fp, "%*sType: %s\n", indent, "", mali_attribute_type_as_str(values->type)); fprintf(fp, "%*sDivisor Numerator: %u\n", indent, "", values->divisor_numerator); fprintf(fp, "%*sDivisor: %u\n", indent, "", values->divisor); } struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D { enum mali_attribute_type type; uint32_t s_dimension; uint32_t t_dimension; uint32_t r_dimension; uint32_t row_stride; uint32_t slice_stride; }; #define MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_header\ .type = MALI_ATTRIBUTE_TYPE_CONTINUATION static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_pack(uint32_t * restrict cl, const struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D * restrict values) { assert(values->s_dimension >= 1); assert(values->t_dimension >= 1); assert(values->r_dimension >= 1); cl[ 0] = __gen_uint(values->type, 0, 5) | __gen_uint(values->s_dimension - 1, 16, 31); cl[ 1] = __gen_uint(values->t_dimension - 1, 0, 15) | __gen_uint(values->r_dimension - 1, 16, 31); cl[ 2] = __gen_uint(values->row_stride, 0, 31); cl[ 3] = __gen_uint(values->slice_stride, 0, 31); } #define MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_LENGTH 16 struct mali_attribute_buffer_continuation_3d_packed { uint32_t opaque[4]; }; static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_unpack(const uint8_t * restrict cl, struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D * restrict values) { if (((const uint32_t *) cl)[0] & 0xffc0) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation 3D unpacked at word 0\n"); values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5); values->s_dimension = __gen_unpack_uint(cl, 16, 31) + 1; values->t_dimension = __gen_unpack_uint(cl, 32, 47) + 1; values->r_dimension = __gen_unpack_uint(cl, 48, 63) + 1; values->row_stride = __gen_unpack_uint(cl, 64, 95); values->slice_stride = __gen_unpack_uint(cl, 96, 127); } static inline void MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_print(FILE *fp, const struct MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D * values, unsigned indent) { fprintf(fp, "%*sType: %s\n", indent, "", mali_attribute_type_as_str(values->type)); fprintf(fp, "%*sS dimension: %u\n", indent, "", values->s_dimension); fprintf(fp, "%*sT dimension: %u\n", indent, "", values->t_dimension); fprintf(fp, "%*sR dimension: %u\n", indent, "", values->r_dimension); fprintf(fp, "%*sRow Stride: %u\n", indent, "", values->row_stride); fprintf(fp, "%*sSlice Stride: %u\n", indent, "", values->slice_stride); } enum mali_blend_operand_a { MALI_BLEND_OPERAND_A_ZERO = 1, MALI_BLEND_OPERAND_A_SRC = 2, MALI_BLEND_OPERAND_A_DEST = 3, }; static inline const char * mali_blend_operand_a_as_str(enum mali_blend_operand_a imm) { switch (imm) { case MALI_BLEND_OPERAND_A_ZERO: return "Zero"; case MALI_BLEND_OPERAND_A_SRC: return "Src"; case MALI_BLEND_OPERAND_A_DEST: return "Dest"; default: return "XXX: INVALID"; } } enum mali_blend_operand_b { MALI_BLEND_OPERAND_B_SRC_MINUS_DEST = 0, MALI_BLEND_OPERAND_B_SRC_PLUS_DEST = 1, MALI_BLEND_OPERAND_B_SRC = 2, MALI_BLEND_OPERAND_B_DEST = 3, }; static inline const char * mali_blend_operand_b_as_str(enum mali_blend_operand_b imm) { switch (imm) { case MALI_BLEND_OPERAND_B_SRC_MINUS_DEST: return "Src Minus Dest"; case MALI_BLEND_OPERAND_B_SRC_PLUS_DEST: return "Src Plus Dest"; case MALI_BLEND_OPERAND_B_SRC: return "Src"; case MALI_BLEND_OPERAND_B_DEST: return "Dest"; default: return "XXX: INVALID"; } } enum mali_blend_operand_c { MALI_BLEND_OPERAND_C_ZERO = 1, MALI_BLEND_OPERAND_C_SRC = 2, MALI_BLEND_OPERAND_C_DEST = 3, MALI_BLEND_OPERAND_C_SRC_X_2 = 4, MALI_BLEND_OPERAND_C_SRC_ALPHA = 5, MALI_BLEND_OPERAND_C_DEST_ALPHA = 6, MALI_BLEND_OPERAND_C_CONSTANT = 7, }; static inline const char * mali_blend_operand_c_as_str(enum mali_blend_operand_c imm) { switch (imm) { case MALI_BLEND_OPERAND_C_ZERO: return "Zero"; case MALI_BLEND_OPERAND_C_SRC: return "Src"; case MALI_BLEND_OPERAND_C_DEST: return "Dest"; case MALI_BLEND_OPERAND_C_SRC_X_2: return "Src x 2"; case MALI_BLEND_OPERAND_C_SRC_ALPHA: return "Src Alpha"; case MALI_BLEND_OPERAND_C_DEST_ALPHA: return "Dest Alpha"; case MALI_BLEND_OPERAND_C_CONSTANT: return "Constant"; default: return "XXX: INVALID"; } } struct MALI_BLEND_FUNCTION { enum mali_blend_operand_a a; bool negate_a; enum mali_blend_operand_b b; bool negate_b; enum mali_blend_operand_c c; bool invert_c; }; #define MALI_BLEND_FUNCTION_header \ 0 static inline void MALI_BLEND_FUNCTION_print(FILE *fp, const struct MALI_BLEND_FUNCTION * values, unsigned indent) { fprintf(fp, "%*sA: %s\n", indent, "", mali_blend_operand_a_as_str(values->a)); fprintf(fp, "%*sNegate A: %s\n", indent, "", values->negate_a ? "true" : "false"); fprintf(fp, "%*sB: %s\n", indent, "", mali_blend_operand_b_as_str(values->b)); fprintf(fp, "%*sNegate B: %s\n", indent, "", values->negate_b ? "true" : "false"); fprintf(fp, "%*sC: %s\n", indent, "", mali_blend_operand_c_as_str(values->c)); fprintf(fp, "%*sInvert C: %s\n", indent, "", values->invert_c ? "true" : "false"); } struct MALI_BLEND_EQUATION { struct MALI_BLEND_FUNCTION rgb; struct MALI_BLEND_FUNCTION alpha; uint32_t color_mask; }; #define MALI_BLEND_EQUATION_header \ .rgb = { MALI_BLEND_FUNCTION_header }, \ .alpha = { MALI_BLEND_FUNCTION_header } static inline void MALI_BLEND_EQUATION_pack(uint32_t * restrict cl, const struct MALI_BLEND_EQUATION * restrict values) { cl[ 0] = __gen_uint(values->rgb.a, 0, 1) | __gen_uint(values->rgb.negate_a, 3, 3) | __gen_uint(values->rgb.b, 4, 5) | __gen_uint(values->rgb.negate_b, 7, 7) | __gen_uint(values->rgb.c, 8, 10) | __gen_uint(values->rgb.invert_c, 11, 11) | __gen_uint(values->alpha.a, 12, 13) | __gen_uint(values->alpha.negate_a, 15, 15) | __gen_uint(values->alpha.b, 16, 17) | __gen_uint(values->alpha.negate_b, 19, 19) | __gen_uint(values->alpha.c, 20, 22) | __gen_uint(values->alpha.invert_c, 23, 23) | __gen_uint(values->color_mask, 28, 31); } #define MALI_BLEND_EQUATION_LENGTH 4 struct mali_blend_equation_packed { uint32_t opaque[1]; }; static inline void MALI_BLEND_EQUATION_unpack(const uint8_t * restrict cl, struct MALI_BLEND_EQUATION * restrict values) { if (((const uint32_t *) cl)[0] & 0xf044044) fprintf(stderr, "XXX: Invalid field of Blend Equation unpacked at word 0\n"); values->rgb.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 0, 1); values->rgb.negate_a = __gen_unpack_uint(cl, 3, 3); values->rgb.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 4, 5); values->rgb.negate_b = __gen_unpack_uint(cl, 7, 7); values->rgb.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 8, 10); values->rgb.invert_c = __gen_unpack_uint(cl, 11, 11); values->alpha.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 12, 13); values->alpha.negate_a = __gen_unpack_uint(cl, 15, 15); values->alpha.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 16, 17); values->alpha.negate_b = __gen_unpack_uint(cl, 19, 19); values->alpha.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 20, 22); values->alpha.invert_c = __gen_unpack_uint(cl, 23, 23); values->color_mask = __gen_unpack_uint(cl, 28, 31); } static inline void MALI_BLEND_EQUATION_print(FILE *fp, const struct MALI_BLEND_EQUATION * values, unsigned indent) { fprintf(fp, "%*sRGB:\n", indent, ""); MALI_BLEND_FUNCTION_print(fp, &values->rgb, indent + 2); fprintf(fp, "%*sAlpha:\n", indent, ""); MALI_BLEND_FUNCTION_print(fp, &values->alpha, indent + 2); fprintf(fp, "%*sColor Mask: %u\n", indent, "", values->color_mask); } enum mali_register_file_format { MALI_REGISTER_FILE_FORMAT_F16 = 0, MALI_REGISTER_FILE_FORMAT_F32 = 1, MALI_REGISTER_FILE_FORMAT_I32 = 2, MALI_REGISTER_FILE_FORMAT_U32 = 3, MALI_REGISTER_FILE_FORMAT_I16 = 4, MALI_REGISTER_FILE_FORMAT_U16 = 5, }; static inline const char * mali_register_file_format_as_str(enum mali_register_file_format imm) { switch (imm) { case MALI_REGISTER_FILE_FORMAT_F16: return "F16"; case MALI_REGISTER_FILE_FORMAT_F32: return "F32"; case MALI_REGISTER_FILE_FORMAT_I32: return "I32"; case MALI_REGISTER_FILE_FORMAT_U32: return "U32"; case MALI_REGISTER_FILE_FORMAT_I16: return "I16"; case MALI_REGISTER_FILE_FORMAT_U16: return "U16"; default: return "XXX: INVALID"; } } enum mali_message_type { MALI_MESSAGE_TYPE_DISABLED = 0, MALI_MESSAGE_TYPE_LD_VAR = 1, MALI_MESSAGE_TYPE_VAR_TEX = 2, }; static inline const char * mali_message_type_as_str(enum mali_message_type imm) { switch (imm) { case MALI_MESSAGE_TYPE_DISABLED: return "Disabled"; case MALI_MESSAGE_TYPE_LD_VAR: return "LD_VAR"; case MALI_MESSAGE_TYPE_VAR_TEX: return "VAR_TEX"; default: return "XXX: INVALID"; } } enum mali_message_preload_register_format { MALI_MESSAGE_PRELOAD_REGISTER_FORMAT_F32 = 0, MALI_MESSAGE_PRELOAD_REGISTER_FORMAT_F16 = 1, }; static inline const char * mali_message_preload_register_format_as_str(enum mali_message_preload_register_format imm) { switch (imm) { case MALI_MESSAGE_PRELOAD_REGISTER_FORMAT_F32: return "F32"; case MALI_MESSAGE_PRELOAD_REGISTER_FORMAT_F16: return "F16"; default: return "XXX: INVALID"; } } enum mali_blend_mode { MALI_BLEND_MODE_SHADER = 0, MALI_BLEND_MODE_OPAQUE = 1, MALI_BLEND_MODE_FIXED_FUNCTION = 2, MALI_BLEND_MODE_OFF = 3, }; static inline const char * mali_blend_mode_as_str(enum mali_blend_mode imm) { switch (imm) { case MALI_BLEND_MODE_SHADER: return "Shader"; case MALI_BLEND_MODE_OPAQUE: return "Opaque"; case MALI_BLEND_MODE_FIXED_FUNCTION: return "Fixed-Function"; case MALI_BLEND_MODE_OFF: return "Off"; default: return "XXX: INVALID"; } } struct MALI_BLEND_SHADER { uint32_t return_value; uint32_t pc; }; #define MALI_BLEND_SHADER_header \ 0 static inline void MALI_BLEND_SHADER_pack(uint32_t * restrict cl, const struct MALI_BLEND_SHADER * restrict values) { assert((values->return_value & 0x7) == 0); assert((values->pc & 0xf) == 0); cl[ 0] = __gen_uint(values->return_value >> 3, 3, 31); cl[ 1] = __gen_uint(values->pc >> 4, 4, 31); } #define MALI_BLEND_SHADER_LENGTH 8 struct mali_blend_shader_packed { uint32_t opaque[2]; }; static inline void MALI_BLEND_SHADER_unpack(const uint8_t * restrict cl, struct MALI_BLEND_SHADER * restrict values) { if (((const uint32_t *) cl)[0] & 0x7) fprintf(stderr, "XXX: Invalid field of Blend Shader unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xf) fprintf(stderr, "XXX: Invalid field of Blend Shader unpacked at word 1\n"); values->return_value = __gen_unpack_uint(cl, 3, 31) << 3; values->pc = __gen_unpack_uint(cl, 36, 63) << 4; } static inline void MALI_BLEND_SHADER_print(FILE *fp, const struct MALI_BLEND_SHADER * values, unsigned indent) { fprintf(fp, "%*sReturn Value: %u\n", indent, "", values->return_value); fprintf(fp, "%*sPC: %u\n", indent, "", values->pc); } struct MALI_INTERNAL_CONVERSION { uint32_t memory_format; bool raw; enum mali_register_file_format register_format; }; #define MALI_INTERNAL_CONVERSION_header \ 0 static inline void MALI_INTERNAL_CONVERSION_pack(uint32_t * restrict cl, const struct MALI_INTERNAL_CONVERSION * restrict values) { cl[ 0] = __gen_uint(values->memory_format, 0, 21) | __gen_uint(values->raw, 22, 22) | __gen_uint(values->register_format, 24, 26); } #define MALI_INTERNAL_CONVERSION_LENGTH 4 struct mali_internal_conversion_packed { uint32_t opaque[1]; }; static inline void MALI_INTERNAL_CONVERSION_unpack(const uint8_t * restrict cl, struct MALI_INTERNAL_CONVERSION * restrict values) { if (((const uint32_t *) cl)[0] & 0xf8800000) fprintf(stderr, "XXX: Invalid field of Internal Conversion unpacked at word 0\n"); values->memory_format = __gen_unpack_uint(cl, 0, 21); values->raw = __gen_unpack_uint(cl, 22, 22); values->register_format = (enum mali_register_file_format)__gen_unpack_uint(cl, 24, 26); } static inline void MALI_INTERNAL_CONVERSION_print(FILE *fp, const struct MALI_INTERNAL_CONVERSION * values, unsigned indent) { mali_pixel_format_print(fp, values->memory_format); fprintf(fp, "%*sRaw: %s\n", indent, "", values->raw ? "true" : "false"); fprintf(fp, "%*sRegister Format: %s\n", indent, "", mali_register_file_format_as_str(values->register_format)); } struct MALI_BLEND_FIXED_FUNCTION { uint32_t num_comps; bool alpha_zero_nop; bool alpha_one_store; uint32_t rt; #define MALI_BIFROST_BLEND_MAX_RT 8 struct MALI_INTERNAL_CONVERSION conversion; }; #define MALI_BLEND_FIXED_FUNCTION_header \ .num_comps = 1, \ .conversion = { MALI_INTERNAL_CONVERSION_header } static inline void MALI_BLEND_FIXED_FUNCTION_pack(uint32_t * restrict cl, const struct MALI_BLEND_FIXED_FUNCTION * restrict values) { assert(values->num_comps >= 1); cl[ 0] = __gen_uint(values->num_comps - 1, 3, 4) | __gen_uint(values->alpha_zero_nop, 5, 5) | __gen_uint(values->alpha_one_store, 6, 6) | __gen_uint(values->rt, 16, 19); cl[ 1] = __gen_uint(values->conversion.memory_format, 0, 21) | __gen_uint(values->conversion.raw, 22, 22) | __gen_uint(values->conversion.register_format, 24, 26); } #define MALI_BLEND_FIXED_FUNCTION_LENGTH 8 struct mali_blend_fixed_function_packed { uint32_t opaque[2]; }; static inline void MALI_BLEND_FIXED_FUNCTION_unpack(const uint8_t * restrict cl, struct MALI_BLEND_FIXED_FUNCTION * restrict values) { if (((const uint32_t *) cl)[0] & 0xfff0ff87) fprintf(stderr, "XXX: Invalid field of Blend Fixed-Function unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xf8800000) fprintf(stderr, "XXX: Invalid field of Blend Fixed-Function unpacked at word 1\n"); values->num_comps = __gen_unpack_uint(cl, 3, 4) + 1; values->alpha_zero_nop = __gen_unpack_uint(cl, 5, 5); values->alpha_one_store = __gen_unpack_uint(cl, 6, 6); values->rt = __gen_unpack_uint(cl, 16, 19); values->conversion.memory_format = __gen_unpack_uint(cl, 32, 53); values->conversion.raw = __gen_unpack_uint(cl, 54, 54); values->conversion.register_format = (enum mali_register_file_format)__gen_unpack_uint(cl, 56, 58); } static inline void MALI_BLEND_FIXED_FUNCTION_print(FILE *fp, const struct MALI_BLEND_FIXED_FUNCTION * values, unsigned indent) { fprintf(fp, "%*sNum Comps: %u\n", indent, "", values->num_comps); fprintf(fp, "%*sAlpha Zero NOP: %s\n", indent, "", values->alpha_zero_nop ? "true" : "false"); fprintf(fp, "%*sAlpha One Store: %s\n", indent, "", values->alpha_one_store ? "true" : "false"); fprintf(fp, "%*sRT: %u\n", indent, "", values->rt); fprintf(fp, "%*sConversion:\n", indent, ""); MALI_INTERNAL_CONVERSION_print(fp, &values->conversion, indent + 2); } struct MALI_INTERNAL_BLEND { enum mali_blend_mode mode; struct MALI_BLEND_SHADER shader; struct MALI_BLEND_FIXED_FUNCTION fixed_function; }; #define MALI_INTERNAL_BLEND_header \ .shader = { MALI_BLEND_SHADER_header }, \ .fixed_function = { MALI_BLEND_FIXED_FUNCTION_header } static inline void MALI_INTERNAL_BLEND_pack(uint32_t * restrict cl, const struct MALI_INTERNAL_BLEND * restrict values) { cl[ 0] = __gen_uint(values->mode, 0, 1) | __gen_uint(values->shader.return_value >> 3, 3, 31) | __gen_uint(values->fixed_function.num_comps - 1, 3, 4) | __gen_uint(values->fixed_function.alpha_zero_nop, 5, 5) | __gen_uint(values->fixed_function.alpha_one_store, 6, 6) | __gen_uint(values->fixed_function.rt, 16, 19); cl[ 1] = __gen_uint(values->shader.pc >> 4, 4, 31) | __gen_uint(values->fixed_function.conversion.memory_format, 0, 21) | __gen_uint(values->fixed_function.conversion.raw, 22, 22) | __gen_uint(values->fixed_function.conversion.register_format, 24, 26); } #define MALI_INTERNAL_BLEND_LENGTH 8 struct mali_internal_blend_packed { uint32_t opaque[2]; }; static inline void MALI_INTERNAL_BLEND_unpack(const uint8_t * restrict cl, struct MALI_INTERNAL_BLEND * restrict values) { if (((const uint32_t *) cl)[0] & 0x4) fprintf(stderr, "XXX: Invalid field of Internal Blend unpacked at word 0\n"); values->mode = (enum mali_blend_mode)__gen_unpack_uint(cl, 0, 1); values->shader.return_value = __gen_unpack_uint(cl, 3, 31) << 3; values->shader.pc = __gen_unpack_uint(cl, 36, 63) << 4; values->fixed_function.num_comps = __gen_unpack_uint(cl, 3, 4) + 1; values->fixed_function.alpha_zero_nop = __gen_unpack_uint(cl, 5, 5); values->fixed_function.alpha_one_store = __gen_unpack_uint(cl, 6, 6); values->fixed_function.rt = __gen_unpack_uint(cl, 16, 19); values->fixed_function.conversion.memory_format = __gen_unpack_uint(cl, 32, 53); values->fixed_function.conversion.raw = __gen_unpack_uint(cl, 54, 54); values->fixed_function.conversion.register_format = (enum mali_register_file_format)__gen_unpack_uint(cl, 56, 58); } static inline void MALI_INTERNAL_BLEND_print(FILE *fp, const struct MALI_INTERNAL_BLEND * values, unsigned indent) { fprintf(fp, "%*sMode: %s\n", indent, "", mali_blend_mode_as_str(values->mode)); fprintf(fp, "%*sShader:\n", indent, ""); MALI_BLEND_SHADER_print(fp, &values->shader, indent + 2); fprintf(fp, "%*sFixed-Function:\n", indent, ""); MALI_BLEND_FIXED_FUNCTION_print(fp, &values->fixed_function, indent + 2); } struct MALI_BLEND { bool load_destination; bool alpha_to_one; bool enable; bool srgb; bool round_to_fb_precision; uint32_t constant; struct MALI_BLEND_EQUATION equation; struct MALI_INTERNAL_BLEND internal; }; #define MALI_BLEND_header \ .load_destination = false, \ .enable = true, \ .srgb = false, \ .round_to_fb_precision = false, \ .equation = { MALI_BLEND_EQUATION_header }, \ .internal = { MALI_INTERNAL_BLEND_header } static inline void MALI_BLEND_pack(uint32_t * restrict cl, const struct MALI_BLEND * restrict values) { cl[ 0] = __gen_uint(values->load_destination, 0, 0) | __gen_uint(values->alpha_to_one, 8, 8) | __gen_uint(values->enable, 9, 9) | __gen_uint(values->srgb, 10, 10) | __gen_uint(values->round_to_fb_precision, 11, 11) | __gen_uint(values->constant, 16, 31); cl[ 1] = __gen_uint(values->equation.rgb.a, 0, 1) | __gen_uint(values->equation.rgb.negate_a, 3, 3) | __gen_uint(values->equation.rgb.b, 4, 5) | __gen_uint(values->equation.rgb.negate_b, 7, 7) | __gen_uint(values->equation.rgb.c, 8, 10) | __gen_uint(values->equation.rgb.invert_c, 11, 11) | __gen_uint(values->equation.alpha.a, 12, 13) | __gen_uint(values->equation.alpha.negate_a, 15, 15) | __gen_uint(values->equation.alpha.b, 16, 17) | __gen_uint(values->equation.alpha.negate_b, 19, 19) | __gen_uint(values->equation.alpha.c, 20, 22) | __gen_uint(values->equation.alpha.invert_c, 23, 23) | __gen_uint(values->equation.color_mask, 28, 31); cl[ 2] = __gen_uint(values->internal.mode, 0, 1) | __gen_uint(values->internal.shader.return_value >> 3, 3, 31) | __gen_uint(values->internal.fixed_function.num_comps - 1, 3, 4) | __gen_uint(values->internal.fixed_function.alpha_zero_nop, 5, 5) | __gen_uint(values->internal.fixed_function.alpha_one_store, 6, 6) | __gen_uint(values->internal.fixed_function.rt, 16, 19); cl[ 3] = __gen_uint(values->internal.shader.pc >> 4, 4, 31) | __gen_uint(values->internal.fixed_function.conversion.memory_format, 0, 21) | __gen_uint(values->internal.fixed_function.conversion.raw, 22, 22) | __gen_uint(values->internal.fixed_function.conversion.register_format, 24, 26); } #define MALI_BLEND_LENGTH 16 #define MALI_BLEND_ALIGN 16 struct mali_blend_packed { uint32_t opaque[4]; }; static inline void MALI_BLEND_unpack(const uint8_t * restrict cl, struct MALI_BLEND * restrict values) { if (((const uint32_t *) cl)[0] & 0xf0fe) fprintf(stderr, "XXX: Invalid field of Blend unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xf044044) fprintf(stderr, "XXX: Invalid field of Blend unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0x4) fprintf(stderr, "XXX: Invalid field of Blend unpacked at word 2\n"); values->load_destination = __gen_unpack_uint(cl, 0, 0); values->alpha_to_one = __gen_unpack_uint(cl, 8, 8); values->enable = __gen_unpack_uint(cl, 9, 9); values->srgb = __gen_unpack_uint(cl, 10, 10); values->round_to_fb_precision = __gen_unpack_uint(cl, 11, 11); values->constant = __gen_unpack_uint(cl, 16, 31); values->equation.rgb.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 32, 33); values->equation.rgb.negate_a = __gen_unpack_uint(cl, 35, 35); values->equation.rgb.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 36, 37); values->equation.rgb.negate_b = __gen_unpack_uint(cl, 39, 39); values->equation.rgb.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 40, 42); values->equation.rgb.invert_c = __gen_unpack_uint(cl, 43, 43); values->equation.alpha.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 44, 45); values->equation.alpha.negate_a = __gen_unpack_uint(cl, 47, 47); values->equation.alpha.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 48, 49); values->equation.alpha.negate_b = __gen_unpack_uint(cl, 51, 51); values->equation.alpha.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 52, 54); values->equation.alpha.invert_c = __gen_unpack_uint(cl, 55, 55); values->equation.color_mask = __gen_unpack_uint(cl, 60, 63); values->internal.mode = (enum mali_blend_mode)__gen_unpack_uint(cl, 64, 65); values->internal.shader.return_value = __gen_unpack_uint(cl, 67, 95) << 3; values->internal.shader.pc = __gen_unpack_uint(cl, 100, 127) << 4; values->internal.fixed_function.num_comps = __gen_unpack_uint(cl, 67, 68) + 1; values->internal.fixed_function.alpha_zero_nop = __gen_unpack_uint(cl, 69, 69); values->internal.fixed_function.alpha_one_store = __gen_unpack_uint(cl, 70, 70); values->internal.fixed_function.rt = __gen_unpack_uint(cl, 80, 83); values->internal.fixed_function.conversion.memory_format = __gen_unpack_uint(cl, 96, 117); values->internal.fixed_function.conversion.raw = __gen_unpack_uint(cl, 118, 118); values->internal.fixed_function.conversion.register_format = (enum mali_register_file_format)__gen_unpack_uint(cl, 120, 122); } static inline void MALI_BLEND_print(FILE *fp, const struct MALI_BLEND * values, unsigned indent) { fprintf(fp, "%*sLoad Destination: %s\n", indent, "", values->load_destination ? "true" : "false"); fprintf(fp, "%*sAlpha To One: %s\n", indent, "", values->alpha_to_one ? "true" : "false"); fprintf(fp, "%*sEnable: %s\n", indent, "", values->enable ? "true" : "false"); fprintf(fp, "%*ssRGB: %s\n", indent, "", values->srgb ? "true" : "false"); fprintf(fp, "%*sRound to FB precision: %s\n", indent, "", values->round_to_fb_precision ? "true" : "false"); fprintf(fp, "%*sConstant: %u\n", indent, "", values->constant); fprintf(fp, "%*sEquation:\n", indent, ""); MALI_BLEND_EQUATION_print(fp, &values->equation, indent + 2); fprintf(fp, "%*sInternal:\n", indent, ""); MALI_INTERNAL_BLEND_print(fp, &values->internal, indent + 2); } struct MALI_INVOCATION { uint32_t invocations; uint32_t size_y_shift; uint32_t size_z_shift; uint32_t workgroups_x_shift; uint32_t workgroups_y_shift; uint32_t workgroups_z_shift; uint32_t thread_group_split; #define MALI_SPLIT_MIN_EFFICIENT 2 }; #define MALI_INVOCATION_header \ 0 static inline void MALI_INVOCATION_pack(uint32_t * restrict cl, const struct MALI_INVOCATION * restrict values) { cl[ 0] = __gen_uint(values->invocations, 0, 31); cl[ 1] = __gen_uint(values->size_y_shift, 0, 4) | __gen_uint(values->size_z_shift, 5, 9) | __gen_uint(values->workgroups_x_shift, 10, 15) | __gen_uint(values->workgroups_y_shift, 16, 21) | __gen_uint(values->workgroups_z_shift, 22, 27) | __gen_uint(values->thread_group_split, 28, 31); } #define MALI_INVOCATION_LENGTH 8 struct mali_invocation_packed { uint32_t opaque[2]; }; static inline void MALI_INVOCATION_unpack(const uint8_t * restrict cl, struct MALI_INVOCATION * restrict values) { values->invocations = __gen_unpack_uint(cl, 0, 31); values->size_y_shift = __gen_unpack_uint(cl, 32, 36); values->size_z_shift = __gen_unpack_uint(cl, 37, 41); values->workgroups_x_shift = __gen_unpack_uint(cl, 42, 47); values->workgroups_y_shift = __gen_unpack_uint(cl, 48, 53); values->workgroups_z_shift = __gen_unpack_uint(cl, 54, 59); values->thread_group_split = __gen_unpack_uint(cl, 60, 63); } static inline void MALI_INVOCATION_print(FILE *fp, const struct MALI_INVOCATION * values, unsigned indent) { fprintf(fp, "%*sInvocations: %u\n", indent, "", values->invocations); fprintf(fp, "%*sSize Y shift: %u\n", indent, "", values->size_y_shift); fprintf(fp, "%*sSize Z shift: %u\n", indent, "", values->size_z_shift); fprintf(fp, "%*sWorkgroups X shift: %u\n", indent, "", values->workgroups_x_shift); fprintf(fp, "%*sWorkgroups Y shift: %u\n", indent, "", values->workgroups_y_shift); fprintf(fp, "%*sWorkgroups Z shift: %u\n", indent, "", values->workgroups_z_shift); fprintf(fp, "%*sThread group split: %u\n", indent, "", values->thread_group_split); } enum mali_point_size_array_format { MALI_POINT_SIZE_ARRAY_FORMAT_NONE = 0, MALI_POINT_SIZE_ARRAY_FORMAT_FP16 = 2, MALI_POINT_SIZE_ARRAY_FORMAT_FP32 = 3, }; static inline const char * mali_point_size_array_format_as_str(enum mali_point_size_array_format imm) { switch (imm) { case MALI_POINT_SIZE_ARRAY_FORMAT_NONE: return "None"; case MALI_POINT_SIZE_ARRAY_FORMAT_FP16: return "FP16"; case MALI_POINT_SIZE_ARRAY_FORMAT_FP32: return "FP32"; default: return "XXX: INVALID"; } } enum mali_primitive_restart { MALI_PRIMITIVE_RESTART_NONE = 0, MALI_PRIMITIVE_RESTART_IMPLICIT = 2, MALI_PRIMITIVE_RESTART_EXPLICIT = 3, }; static inline const char * mali_primitive_restart_as_str(enum mali_primitive_restart imm) { switch (imm) { case MALI_PRIMITIVE_RESTART_NONE: return "None"; case MALI_PRIMITIVE_RESTART_IMPLICIT: return "Implicit"; case MALI_PRIMITIVE_RESTART_EXPLICIT: return "Explicit"; default: return "XXX: INVALID"; } } struct MALI_PRIMITIVE { enum mali_draw_mode draw_mode; enum mali_index_type index_type; enum mali_point_size_array_format point_size_array_format; bool primitive_index_enable; bool primitive_index_writeback; bool first_provoking_vertex; bool low_depth_cull; bool high_depth_cull; bool secondary_shader; enum mali_primitive_restart primitive_restart; uint32_t job_task_split; uint32_t base_vertex_offset; uint32_t primitive_restart_index; uint32_t index_count; uint64_t indices; }; #define MALI_PRIMITIVE_header \ .draw_mode = MALI_DRAW_MODE_NONE, \ .index_type = MALI_INDEX_TYPE_NONE, \ .first_provoking_vertex = true, \ .low_depth_cull = true, \ .high_depth_cull = true static inline void MALI_PRIMITIVE_pack(uint32_t * restrict cl, const struct MALI_PRIMITIVE * restrict values) { assert(values->index_count >= 1); cl[ 0] = __gen_uint(values->draw_mode, 0, 7) | __gen_uint(values->index_type, 8, 10) | __gen_uint(values->point_size_array_format, 11, 12) | __gen_uint(values->primitive_index_enable, 13, 13) | __gen_uint(values->primitive_index_writeback, 14, 14) | __gen_uint(values->first_provoking_vertex, 15, 15) | __gen_uint(values->low_depth_cull, 16, 16) | __gen_uint(values->high_depth_cull, 17, 17) | __gen_uint(values->secondary_shader, 18, 18) | __gen_uint(values->primitive_restart, 19, 20) | __gen_uint(values->job_task_split, 26, 31); cl[ 1] = __gen_uint(values->base_vertex_offset, 0, 31); cl[ 2] = __gen_uint(values->primitive_restart_index, 0, 31); cl[ 3] = __gen_uint(values->index_count - 1, 0, 31); cl[ 4] = __gen_uint(values->indices, 0, 63); cl[ 5] = __gen_uint(values->indices, 0, 63) >> 32; } #define MALI_PRIMITIVE_LENGTH 24 struct mali_primitive_packed { uint32_t opaque[6]; }; static inline void MALI_PRIMITIVE_unpack(const uint8_t * restrict cl, struct MALI_PRIMITIVE * restrict values) { if (((const uint32_t *) cl)[0] & 0x3e00000) fprintf(stderr, "XXX: Invalid field of Primitive unpacked at word 0\n"); values->draw_mode = (enum mali_draw_mode)__gen_unpack_uint(cl, 0, 7); values->index_type = (enum mali_index_type)__gen_unpack_uint(cl, 8, 10); values->point_size_array_format = (enum mali_point_size_array_format)__gen_unpack_uint(cl, 11, 12); values->primitive_index_enable = __gen_unpack_uint(cl, 13, 13); values->primitive_index_writeback = __gen_unpack_uint(cl, 14, 14); values->first_provoking_vertex = __gen_unpack_uint(cl, 15, 15); values->low_depth_cull = __gen_unpack_uint(cl, 16, 16); values->high_depth_cull = __gen_unpack_uint(cl, 17, 17); values->secondary_shader = __gen_unpack_uint(cl, 18, 18); values->primitive_restart = (enum mali_primitive_restart)__gen_unpack_uint(cl, 19, 20); values->job_task_split = __gen_unpack_uint(cl, 26, 31); values->base_vertex_offset = __gen_unpack_uint(cl, 32, 63); values->primitive_restart_index = __gen_unpack_uint(cl, 64, 95); values->index_count = __gen_unpack_uint(cl, 96, 127) + 1; values->indices = __gen_unpack_uint(cl, 128, 191); } static inline void MALI_PRIMITIVE_print(FILE *fp, const struct MALI_PRIMITIVE * values, unsigned indent) { fprintf(fp, "%*sDraw mode: %s\n", indent, "", mali_draw_mode_as_str(values->draw_mode)); fprintf(fp, "%*sIndex type: %s\n", indent, "", mali_index_type_as_str(values->index_type)); fprintf(fp, "%*sPoint size array format: %s\n", indent, "", mali_point_size_array_format_as_str(values->point_size_array_format)); fprintf(fp, "%*sPrimitive Index Enable: %s\n", indent, "", values->primitive_index_enable ? "true" : "false"); fprintf(fp, "%*sPrimitive Index Writeback: %s\n", indent, "", values->primitive_index_writeback ? "true" : "false"); fprintf(fp, "%*sFirst provoking vertex: %s\n", indent, "", values->first_provoking_vertex ? "true" : "false"); fprintf(fp, "%*sLow Depth Cull: %s\n", indent, "", values->low_depth_cull ? "true" : "false"); fprintf(fp, "%*sHigh Depth Cull: %s\n", indent, "", values->high_depth_cull ? "true" : "false"); fprintf(fp, "%*sSecondary Shader: %s\n", indent, "", values->secondary_shader ? "true" : "false"); fprintf(fp, "%*sPrimitive restart: %s\n", indent, "", mali_primitive_restart_as_str(values->primitive_restart)); fprintf(fp, "%*sJob Task Split: %u\n", indent, "", values->job_task_split); fprintf(fp, "%*sBase vertex offset: %u\n", indent, "", values->base_vertex_offset); fprintf(fp, "%*sPrimitive Restart Index: %u\n", indent, "", values->primitive_restart_index); fprintf(fp, "%*sIndex count: %u\n", indent, "", values->index_count); fprintf(fp, "%*sIndices: 0x%" PRIx64 "\n", indent, "", values->indices); } struct MALI_DRAW { bool four_components_per_vertex; bool draw_descriptor_is_64b; enum mali_occlusion_mode occlusion_query; bool front_face_ccw; bool cull_front_face; bool cull_back_face; uint32_t flat_shading_vertex; bool exclude_filtered_perf_counters; bool primitive_barrier; bool clean_fragment_write; uint32_t instance_size; uint32_t instance_primitive_size; uint32_t offset_start; uint32_t primitive_index_base; uint64_t position; uint64_t uniform_buffers; uint64_t textures; uint64_t samplers; uint64_t push_uniforms; uint64_t state; uint64_t attribute_buffers; uint64_t attributes; uint64_t varying_buffers; uint64_t varyings; uint64_t viewport; uint64_t occlusion; uint64_t thread_storage; uint64_t fbd; }; #define MALI_DRAW_header \ .occlusion_query = MALI_OCCLUSION_MODE_DISABLED, \ .instance_size = 1, \ .instance_primitive_size = 1 static inline void MALI_DRAW_pack(uint32_t * restrict cl, const struct MALI_DRAW * restrict values) { cl[ 0] = __gen_uint(values->four_components_per_vertex, 0, 0) | __gen_uint(values->draw_descriptor_is_64b, 1, 1) | __gen_uint(values->occlusion_query, 3, 4) | __gen_uint(values->front_face_ccw, 5, 5) | __gen_uint(values->cull_front_face, 6, 6) | __gen_uint(values->cull_back_face, 7, 7) | __gen_uint(values->flat_shading_vertex, 8, 8) | __gen_uint(values->exclude_filtered_perf_counters, 9, 9) | __gen_uint(values->primitive_barrier, 10, 10) | __gen_uint(values->clean_fragment_write, 11, 11) | __gen_padded(values->instance_size, 16, 23) | __gen_padded(values->instance_primitive_size, 24, 31); cl[ 1] = __gen_uint(values->offset_start, 0, 31); cl[ 2] = __gen_uint(values->primitive_index_base, 0, 31); cl[ 3] = 0; cl[ 4] = __gen_uint(values->position, 0, 63); cl[ 5] = __gen_uint(values->position, 0, 63) >> 32; cl[ 6] = __gen_uint(values->uniform_buffers, 0, 63); cl[ 7] = __gen_uint(values->uniform_buffers, 0, 63) >> 32; cl[ 8] = __gen_uint(values->textures, 0, 63); cl[ 9] = __gen_uint(values->textures, 0, 63) >> 32; cl[10] = __gen_uint(values->samplers, 0, 63); cl[11] = __gen_uint(values->samplers, 0, 63) >> 32; cl[12] = __gen_uint(values->push_uniforms, 0, 63); cl[13] = __gen_uint(values->push_uniforms, 0, 63) >> 32; cl[14] = __gen_uint(values->state, 0, 63); cl[15] = __gen_uint(values->state, 0, 63) >> 32; cl[16] = __gen_uint(values->attribute_buffers, 0, 63); cl[17] = __gen_uint(values->attribute_buffers, 0, 63) >> 32; cl[18] = __gen_uint(values->attributes, 0, 63); cl[19] = __gen_uint(values->attributes, 0, 63) >> 32; cl[20] = __gen_uint(values->varying_buffers, 0, 63); cl[21] = __gen_uint(values->varying_buffers, 0, 63) >> 32; cl[22] = __gen_uint(values->varyings, 0, 63); cl[23] = __gen_uint(values->varyings, 0, 63) >> 32; cl[24] = __gen_uint(values->viewport, 0, 63); cl[25] = __gen_uint(values->viewport, 0, 63) >> 32; cl[26] = __gen_uint(values->occlusion, 0, 63); cl[27] = __gen_uint(values->occlusion, 0, 63) >> 32; cl[28] = __gen_uint(values->thread_storage, 0, 63) | __gen_uint(values->fbd, 0, 63); cl[29] = __gen_uint(values->thread_storage, 0, 63) >> 32 | __gen_uint(values->fbd, 0, 63) >> 32; cl[30] = 0; cl[31] = 0; } #define MALI_DRAW_LENGTH 128 #define MALI_DRAW_ALIGN 64 struct mali_draw_packed { uint32_t opaque[32]; }; static inline void MALI_DRAW_unpack(const uint8_t * restrict cl, struct MALI_DRAW * restrict values) { if (((const uint32_t *) cl)[0] & 0xf004) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 0\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 3\n"); if (((const uint32_t *) cl)[30] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 30\n"); if (((const uint32_t *) cl)[31] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 31\n"); values->four_components_per_vertex = __gen_unpack_uint(cl, 0, 0); values->draw_descriptor_is_64b = __gen_unpack_uint(cl, 1, 1); values->occlusion_query = (enum mali_occlusion_mode)__gen_unpack_uint(cl, 3, 4); values->front_face_ccw = __gen_unpack_uint(cl, 5, 5); values->cull_front_face = __gen_unpack_uint(cl, 6, 6); values->cull_back_face = __gen_unpack_uint(cl, 7, 7); values->flat_shading_vertex = __gen_unpack_uint(cl, 8, 8); values->exclude_filtered_perf_counters = __gen_unpack_uint(cl, 9, 9); values->primitive_barrier = __gen_unpack_uint(cl, 10, 10); values->clean_fragment_write = __gen_unpack_uint(cl, 11, 11); values->instance_size = __gen_unpack_padded(cl, 16, 23); values->instance_primitive_size = __gen_unpack_padded(cl, 24, 31); values->offset_start = __gen_unpack_uint(cl, 32, 63); values->primitive_index_base = __gen_unpack_uint(cl, 64, 95); values->position = __gen_unpack_uint(cl, 128, 191); values->uniform_buffers = __gen_unpack_uint(cl, 192, 255); values->textures = __gen_unpack_uint(cl, 256, 319); values->samplers = __gen_unpack_uint(cl, 320, 383); values->push_uniforms = __gen_unpack_uint(cl, 384, 447); values->state = __gen_unpack_uint(cl, 448, 511); values->attribute_buffers = __gen_unpack_uint(cl, 512, 575); values->attributes = __gen_unpack_uint(cl, 576, 639); values->varying_buffers = __gen_unpack_uint(cl, 640, 703); values->varyings = __gen_unpack_uint(cl, 704, 767); values->viewport = __gen_unpack_uint(cl, 768, 831); values->occlusion = __gen_unpack_uint(cl, 832, 895); values->thread_storage = __gen_unpack_uint(cl, 896, 959); values->fbd = __gen_unpack_uint(cl, 896, 959); } static inline void MALI_DRAW_print(FILE *fp, const struct MALI_DRAW * values, unsigned indent) { fprintf(fp, "%*sFour Components Per Vertex: %s\n", indent, "", values->four_components_per_vertex ? "true" : "false"); fprintf(fp, "%*sDraw Descriptor Is 64b: %s\n", indent, "", values->draw_descriptor_is_64b ? "true" : "false"); fprintf(fp, "%*sOcclusion query: %s\n", indent, "", mali_occlusion_mode_as_str(values->occlusion_query)); fprintf(fp, "%*sFront face CCW: %s\n", indent, "", values->front_face_ccw ? "true" : "false"); fprintf(fp, "%*sCull front face: %s\n", indent, "", values->cull_front_face ? "true" : "false"); fprintf(fp, "%*sCull back face: %s\n", indent, "", values->cull_back_face ? "true" : "false"); fprintf(fp, "%*sFlat Shading Vertex: %u\n", indent, "", values->flat_shading_vertex); fprintf(fp, "%*sExclude Filtered Perf Counters: %s\n", indent, "", values->exclude_filtered_perf_counters ? "true" : "false"); fprintf(fp, "%*sPrimitive Barrier: %s\n", indent, "", values->primitive_barrier ? "true" : "false"); fprintf(fp, "%*sClean Fragment Write: %s\n", indent, "", values->clean_fragment_write ? "true" : "false"); fprintf(fp, "%*sInstance Size: %u\n", indent, "", values->instance_size); fprintf(fp, "%*sInstance Primitive Size: %u\n", indent, "", values->instance_primitive_size); fprintf(fp, "%*sOffset start: %u\n", indent, "", values->offset_start); fprintf(fp, "%*sPrimitive Index Base: %u\n", indent, "", values->primitive_index_base); fprintf(fp, "%*sPosition: 0x%" PRIx64 "\n", indent, "", values->position); fprintf(fp, "%*sUniform buffers: 0x%" PRIx64 "\n", indent, "", values->uniform_buffers); fprintf(fp, "%*sTextures: 0x%" PRIx64 "\n", indent, "", values->textures); fprintf(fp, "%*sSamplers: 0x%" PRIx64 "\n", indent, "", values->samplers); fprintf(fp, "%*sPush uniforms: 0x%" PRIx64 "\n", indent, "", values->push_uniforms); fprintf(fp, "%*sState: 0x%" PRIx64 "\n", indent, "", values->state); fprintf(fp, "%*sAttribute buffers: 0x%" PRIx64 "\n", indent, "", values->attribute_buffers); fprintf(fp, "%*sAttributes: 0x%" PRIx64 "\n", indent, "", values->attributes); fprintf(fp, "%*sVarying buffers: 0x%" PRIx64 "\n", indent, "", values->varying_buffers); fprintf(fp, "%*sVaryings: 0x%" PRIx64 "\n", indent, "", values->varyings); fprintf(fp, "%*sViewport: 0x%" PRIx64 "\n", indent, "", values->viewport); fprintf(fp, "%*sOcclusion: 0x%" PRIx64 "\n", indent, "", values->occlusion); fprintf(fp, "%*sThread Storage: 0x%" PRIx64 "\n", indent, "", values->thread_storage); fprintf(fp, "%*sFBD: 0x%" PRIx64 "\n", indent, "", values->fbd); } struct MALI_SURFACE { uint64_t pointer; }; #define MALI_SURFACE_header \ 0 static inline void MALI_SURFACE_pack(uint32_t * restrict cl, const struct MALI_SURFACE * restrict values) { cl[ 0] = __gen_uint(values->pointer, 0, 63); cl[ 1] = __gen_uint(values->pointer, 0, 63) >> 32; } #define MALI_SURFACE_LENGTH 8 #define MALI_SURFACE_ALIGN 8 struct mali_surface_packed { uint32_t opaque[2]; }; static inline void MALI_SURFACE_unpack(const uint8_t * restrict cl, struct MALI_SURFACE * restrict values) { values->pointer = __gen_unpack_uint(cl, 0, 63); } static inline void MALI_SURFACE_print(FILE *fp, const struct MALI_SURFACE * values, unsigned indent) { fprintf(fp, "%*sPointer: 0x%" PRIx64 "\n", indent, "", values->pointer); } struct MALI_SURFACE_WITH_STRIDE { uint64_t pointer; int32_t row_stride; int32_t surface_stride; }; #define MALI_SURFACE_WITH_STRIDE_header \ 0 static inline void MALI_SURFACE_WITH_STRIDE_pack(uint32_t * restrict cl, const struct MALI_SURFACE_WITH_STRIDE * restrict values) { cl[ 0] = __gen_uint(values->pointer, 0, 63); cl[ 1] = __gen_uint(values->pointer, 0, 63) >> 32; cl[ 2] = __gen_sint(values->row_stride, 0, 31); cl[ 3] = __gen_sint(values->surface_stride, 0, 31); } #define MALI_SURFACE_WITH_STRIDE_LENGTH 16 #define MALI_SURFACE_WITH_STRIDE_ALIGN 8 struct mali_surface_with_stride_packed { uint32_t opaque[4]; }; static inline void MALI_SURFACE_WITH_STRIDE_unpack(const uint8_t * restrict cl, struct MALI_SURFACE_WITH_STRIDE * restrict values) { values->pointer = __gen_unpack_uint(cl, 0, 63); values->row_stride = __gen_unpack_sint(cl, 64, 95); values->surface_stride = __gen_unpack_sint(cl, 96, 127); } static inline void MALI_SURFACE_WITH_STRIDE_print(FILE *fp, const struct MALI_SURFACE_WITH_STRIDE * values, unsigned indent) { fprintf(fp, "%*sPointer: 0x%" PRIx64 "\n", indent, "", values->pointer); fprintf(fp, "%*sRow stride: %d\n", indent, "", values->row_stride); fprintf(fp, "%*sSurface stride: %d\n", indent, "", values->surface_stride); } struct MALI_SAMPLER { uint32_t type; enum mali_wrap_mode wrap_mode_r; enum mali_wrap_mode wrap_mode_t; enum mali_wrap_mode wrap_mode_s; bool round_to_nearest_even; bool srgb_override; bool seamless_cube_map; bool clamp_integer_coordinates; bool normalized_coordinates; bool clamp_integer_array_indices; bool minify_nearest; bool magnify_nearest; bool magnify_cutoff; enum mali_mipmap_mode mipmap_mode; uint32_t minimum_lod; enum mali_func compare_function; uint32_t maximum_lod; int32_t lod_bias; uint32_t maximum_anisotropy; enum mali_lod_algorithm lod_algorithm; uint32_t border_color_r; uint32_t border_color_g; uint32_t border_color_b; uint32_t border_color_a; }; #define MALI_SAMPLER_header \ .type = 1, \ .wrap_mode_r = MALI_WRAP_MODE_CLAMP_TO_EDGE, \ .wrap_mode_t = MALI_WRAP_MODE_CLAMP_TO_EDGE, \ .wrap_mode_s = MALI_WRAP_MODE_CLAMP_TO_EDGE, \ .round_to_nearest_even = false, \ .srgb_override = false, \ .seamless_cube_map = true, \ .normalized_coordinates = true, \ .clamp_integer_array_indices = true, \ .minify_nearest = false, \ .magnify_nearest = false, \ .magnify_cutoff = false, \ .mipmap_mode = MALI_MIPMAP_MODE_NEAREST, \ .minimum_lod = 0, \ .compare_function = MALI_FUNC_NEVER, \ .maximum_lod = 0, \ .lod_bias = 0, \ .maximum_anisotropy = 1, \ .lod_algorithm = MALI_LOD_ALGORITHM_ISOTROPIC, \ .border_color_r = 0.0, \ .border_color_g = 0.0, \ .border_color_b = 0.0, \ .border_color_a = 0.0 static inline void MALI_SAMPLER_pack(uint32_t * restrict cl, const struct MALI_SAMPLER * restrict values) { assert(values->maximum_anisotropy >= 1); cl[ 0] = __gen_uint(values->type, 0, 3) | __gen_uint(values->wrap_mode_r, 8, 11) | __gen_uint(values->wrap_mode_t, 12, 15) | __gen_uint(values->wrap_mode_s, 16, 19) | __gen_uint(values->round_to_nearest_even, 21, 21) | __gen_uint(values->srgb_override, 22, 22) | __gen_uint(values->seamless_cube_map, 23, 23) | __gen_uint(values->clamp_integer_coordinates, 24, 24) | __gen_uint(values->normalized_coordinates, 25, 25) | __gen_uint(values->clamp_integer_array_indices, 26, 26) | __gen_uint(values->minify_nearest, 27, 27) | __gen_uint(values->magnify_nearest, 28, 28) | __gen_uint(values->magnify_cutoff, 29, 29) | __gen_uint(values->mipmap_mode, 30, 31); cl[ 1] = __gen_uint(values->minimum_lod, 0, 12) | __gen_uint(values->compare_function, 13, 15) | __gen_uint(values->maximum_lod, 16, 28); cl[ 2] = __gen_sint(values->lod_bias, 0, 15) | __gen_uint(values->maximum_anisotropy - 1, 16, 20) | __gen_uint(values->lod_algorithm, 24, 25); cl[ 3] = 0; cl[ 4] = __gen_uint(values->border_color_r, 0, 31); cl[ 5] = __gen_uint(values->border_color_g, 0, 31); cl[ 6] = __gen_uint(values->border_color_b, 0, 31); cl[ 7] = __gen_uint(values->border_color_a, 0, 31); } #define MALI_SAMPLER_LENGTH 32 #define MALI_SAMPLER_ALIGN 32 struct mali_sampler_packed { uint32_t opaque[8]; }; static inline void MALI_SAMPLER_unpack(const uint8_t * restrict cl, struct MALI_SAMPLER * restrict values) { if (((const uint32_t *) cl)[0] & 0x1000f0) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xe0000000) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xfce00000) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 3\n"); values->type = __gen_unpack_uint(cl, 0, 3); values->wrap_mode_r = (enum mali_wrap_mode)__gen_unpack_uint(cl, 8, 11); values->wrap_mode_t = (enum mali_wrap_mode)__gen_unpack_uint(cl, 12, 15); values->wrap_mode_s = (enum mali_wrap_mode)__gen_unpack_uint(cl, 16, 19); values->round_to_nearest_even = __gen_unpack_uint(cl, 21, 21); values->srgb_override = __gen_unpack_uint(cl, 22, 22); values->seamless_cube_map = __gen_unpack_uint(cl, 23, 23); values->clamp_integer_coordinates = __gen_unpack_uint(cl, 24, 24); values->normalized_coordinates = __gen_unpack_uint(cl, 25, 25); values->clamp_integer_array_indices = __gen_unpack_uint(cl, 26, 26); values->minify_nearest = __gen_unpack_uint(cl, 27, 27); values->magnify_nearest = __gen_unpack_uint(cl, 28, 28); values->magnify_cutoff = __gen_unpack_uint(cl, 29, 29); values->mipmap_mode = (enum mali_mipmap_mode)__gen_unpack_uint(cl, 30, 31); values->minimum_lod = __gen_unpack_uint(cl, 32, 44); values->compare_function = (enum mali_func)__gen_unpack_uint(cl, 45, 47); values->maximum_lod = __gen_unpack_uint(cl, 48, 60); values->lod_bias = __gen_unpack_sint(cl, 64, 79); values->maximum_anisotropy = __gen_unpack_uint(cl, 80, 84) + 1; values->lod_algorithm = (enum mali_lod_algorithm)__gen_unpack_uint(cl, 88, 89); values->border_color_r = __gen_unpack_uint(cl, 128, 159); values->border_color_g = __gen_unpack_uint(cl, 160, 191); values->border_color_b = __gen_unpack_uint(cl, 192, 223); values->border_color_a = __gen_unpack_uint(cl, 224, 255); } static inline void MALI_SAMPLER_print(FILE *fp, const struct MALI_SAMPLER * values, unsigned indent) { fprintf(fp, "%*sType: %u\n", indent, "", values->type); fprintf(fp, "%*sWrap Mode R: %s\n", indent, "", mali_wrap_mode_as_str(values->wrap_mode_r)); fprintf(fp, "%*sWrap Mode T: %s\n", indent, "", mali_wrap_mode_as_str(values->wrap_mode_t)); fprintf(fp, "%*sWrap Mode S: %s\n", indent, "", mali_wrap_mode_as_str(values->wrap_mode_s)); fprintf(fp, "%*sRound to nearest even: %s\n", indent, "", values->round_to_nearest_even ? "true" : "false"); fprintf(fp, "%*ssRGB override: %s\n", indent, "", values->srgb_override ? "true" : "false"); fprintf(fp, "%*sSeamless Cube Map: %s\n", indent, "", values->seamless_cube_map ? "true" : "false"); fprintf(fp, "%*sClamp integer coordinates: %s\n", indent, "", values->clamp_integer_coordinates ? "true" : "false"); fprintf(fp, "%*sNormalized Coordinates: %s\n", indent, "", values->normalized_coordinates ? "true" : "false"); fprintf(fp, "%*sClamp integer array indices: %s\n", indent, "", values->clamp_integer_array_indices ? "true" : "false"); fprintf(fp, "%*sMinify nearest: %s\n", indent, "", values->minify_nearest ? "true" : "false"); fprintf(fp, "%*sMagnify nearest: %s\n", indent, "", values->magnify_nearest ? "true" : "false"); fprintf(fp, "%*sMagnify cutoff: %s\n", indent, "", values->magnify_cutoff ? "true" : "false"); fprintf(fp, "%*sMipmap Mode: %s\n", indent, "", mali_mipmap_mode_as_str(values->mipmap_mode)); fprintf(fp, "%*sMinimum LOD: %u\n", indent, "", values->minimum_lod); fprintf(fp, "%*sCompare Function: %s\n", indent, "", mali_func_as_str(values->compare_function)); fprintf(fp, "%*sMaximum LOD: %u\n", indent, "", values->maximum_lod); fprintf(fp, "%*sLOD bias: %d\n", indent, "", values->lod_bias); fprintf(fp, "%*sMaximum anisotropy: %u\n", indent, "", values->maximum_anisotropy); fprintf(fp, "%*sLOD algorithm: %s\n", indent, "", mali_lod_algorithm_as_str(values->lod_algorithm)); fprintf(fp, "%*sBorder Color R: 0x%X (%f)\n", indent, "", values->border_color_r, uif(values->border_color_r)); fprintf(fp, "%*sBorder Color G: 0x%X (%f)\n", indent, "", values->border_color_g, uif(values->border_color_g)); fprintf(fp, "%*sBorder Color B: 0x%X (%f)\n", indent, "", values->border_color_b, uif(values->border_color_b)); fprintf(fp, "%*sBorder Color A: 0x%X (%f)\n", indent, "", values->border_color_a, uif(values->border_color_a)); } struct MALI_TEXTURE { uint32_t type; enum mali_texture_dimension dimension; bool sample_corner_position; bool normalize_coordinates; uint32_t format; uint32_t width; uint32_t height; uint32_t swizzle; enum mali_texture_layout texel_ordering; uint32_t levels; uint32_t minimum_level; uint32_t minimum_lod; uint32_t sample_count; uint32_t maximum_lod; uint64_t surfaces; uint32_t array_size; uint32_t depth; }; #define MALI_TEXTURE_header \ .type = 2, \ .sample_corner_position = false, \ .normalize_coordinates = false, \ .levels = 1, \ .minimum_lod = 0, \ .sample_count = 1, \ .maximum_lod = 0, \ .array_size = 1, \ .depth = 1 static inline void MALI_TEXTURE_pack(uint32_t * restrict cl, const struct MALI_TEXTURE * restrict values) { assert(values->width >= 1); assert(values->height >= 1); assert(values->levels >= 1); assert(util_is_power_of_two_nonzero(values->sample_count)); assert(values->array_size >= 1); assert(values->depth >= 1); cl[ 0] = __gen_uint(values->type, 0, 3) | __gen_uint(values->dimension, 4, 5) | __gen_uint(values->sample_corner_position, 8, 8) | __gen_uint(values->normalize_coordinates, 9, 9) | __gen_uint(values->format, 10, 31); cl[ 1] = __gen_uint(values->width - 1, 0, 15) | __gen_uint(values->height - 1, 16, 31); cl[ 2] = __gen_uint(values->swizzle, 0, 11) | __gen_uint(values->texel_ordering, 12, 15) | __gen_uint(values->levels - 1, 16, 20) | __gen_uint(values->minimum_level, 24, 28); cl[ 3] = __gen_uint(values->minimum_lod, 0, 12) | __gen_uint(util_logbase2(values->sample_count), 13, 15) | __gen_uint(values->maximum_lod, 16, 28); cl[ 4] = __gen_uint(values->surfaces, 0, 63); cl[ 5] = __gen_uint(values->surfaces, 0, 63) >> 32; cl[ 6] = __gen_uint(values->array_size - 1, 0, 15); cl[ 7] = __gen_uint(values->depth - 1, 0, 15); } #define MALI_TEXTURE_LENGTH 32 #define MALI_TEXTURE_ALIGN 32 struct mali_texture_packed { uint32_t opaque[8]; }; static inline void MALI_TEXTURE_unpack(const uint8_t * restrict cl, struct MALI_TEXTURE * restrict values) { if (((const uint32_t *) cl)[0] & 0xc0) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 0\n"); if (((const uint32_t *) cl)[2] & 0xe0e00000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xe0000000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 3\n"); if (((const uint32_t *) cl)[6] & 0xffff0000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffff0000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 7\n"); values->type = __gen_unpack_uint(cl, 0, 3); values->dimension = (enum mali_texture_dimension)__gen_unpack_uint(cl, 4, 5); values->sample_corner_position = __gen_unpack_uint(cl, 8, 8); values->normalize_coordinates = __gen_unpack_uint(cl, 9, 9); values->format = __gen_unpack_uint(cl, 10, 31); values->width = __gen_unpack_uint(cl, 32, 47) + 1; values->height = __gen_unpack_uint(cl, 48, 63) + 1; values->swizzle = __gen_unpack_uint(cl, 64, 75); values->texel_ordering = (enum mali_texture_layout)__gen_unpack_uint(cl, 76, 79); values->levels = __gen_unpack_uint(cl, 80, 84) + 1; values->minimum_level = __gen_unpack_uint(cl, 88, 92); values->minimum_lod = __gen_unpack_uint(cl, 96, 108); values->sample_count = 1U << __gen_unpack_uint(cl, 109, 111); values->maximum_lod = __gen_unpack_uint(cl, 112, 124); values->surfaces = __gen_unpack_uint(cl, 128, 191); values->array_size = __gen_unpack_uint(cl, 192, 207) + 1; values->depth = __gen_unpack_uint(cl, 224, 239) + 1; } static inline void MALI_TEXTURE_print(FILE *fp, const struct MALI_TEXTURE * values, unsigned indent) { fprintf(fp, "%*sType: %u\n", indent, "", values->type); fprintf(fp, "%*sDimension: %s\n", indent, "", mali_texture_dimension_as_str(values->dimension)); fprintf(fp, "%*sSample corner position: %s\n", indent, "", values->sample_corner_position ? "true" : "false"); fprintf(fp, "%*sNormalize coordinates: %s\n", indent, "", values->normalize_coordinates ? "true" : "false"); mali_pixel_format_print(fp, values->format); fprintf(fp, "%*sWidth: %u\n", indent, "", values->width); fprintf(fp, "%*sHeight: %u\n", indent, "", values->height); fprintf(fp, "%*sSwizzle: %u\n", indent, "", values->swizzle); fprintf(fp, "%*sTexel ordering: %s\n", indent, "", mali_texture_layout_as_str(values->texel_ordering)); fprintf(fp, "%*sLevels: %u\n", indent, "", values->levels); fprintf(fp, "%*sMinimum level: %u\n", indent, "", values->minimum_level); fprintf(fp, "%*sMinimum LOD: %u\n", indent, "", values->minimum_lod); fprintf(fp, "%*sSample count: %u\n", indent, "", values->sample_count); fprintf(fp, "%*sMaximum LOD: %u\n", indent, "", values->maximum_lod); fprintf(fp, "%*sSurfaces: 0x%" PRIx64 "\n", indent, "", values->surfaces); fprintf(fp, "%*sArray size: %u\n", indent, "", values->array_size); fprintf(fp, "%*sDepth: %u\n", indent, "", values->depth); } enum mali_shader_register_allocation { MALI_SHADER_REGISTER_ALLOCATION_64_PER_THREAD = 0, MALI_SHADER_REGISTER_ALLOCATION_32_PER_THREAD = 2, }; static inline const char * mali_shader_register_allocation_as_str(enum mali_shader_register_allocation imm) { switch (imm) { case MALI_SHADER_REGISTER_ALLOCATION_64_PER_THREAD: return "64 Per Thread"; case MALI_SHADER_REGISTER_ALLOCATION_32_PER_THREAD: return "32 Per Thread"; default: return "XXX: INVALID"; } } struct MALI_RENDERER_PROPERTIES { uint32_t uniform_buffer_count; enum mali_depth_source depth_source; bool shader_contains_barrier; enum mali_shader_register_allocation shader_register_allocation; bool shader_modifies_coverage; bool allow_forward_pixel_to_kill; bool allow_forward_pixel_to_be_killed; enum mali_pixel_kill pixel_kill_operation; enum mali_pixel_kill zs_update_operation; bool point_sprite_coord_origin_max_y; bool stencil_from_shader; }; #define MALI_RENDERER_PROPERTIES_header \ .depth_source = MALI_DEPTH_SOURCE_MINIMUM static inline void MALI_RENDERER_PROPERTIES_pack(uint32_t * restrict cl, const struct MALI_RENDERER_PROPERTIES * restrict values) { cl[ 0] = __gen_uint(values->uniform_buffer_count, 0, 7) | __gen_uint(values->depth_source, 8, 9) | __gen_uint(values->shader_contains_barrier, 11, 11) | __gen_uint(values->shader_register_allocation, 12, 13) | __gen_uint(values->shader_modifies_coverage, 16, 16) | __gen_uint(values->allow_forward_pixel_to_kill, 19, 19) | __gen_uint(values->allow_forward_pixel_to_be_killed, 20, 20) | __gen_uint(values->pixel_kill_operation, 21, 22) | __gen_uint(values->zs_update_operation, 23, 24) | __gen_uint(values->point_sprite_coord_origin_max_y, 27, 27) | __gen_uint(values->stencil_from_shader, 28, 28); } #define MALI_RENDERER_PROPERTIES_LENGTH 4 struct mali_renderer_properties_packed { uint32_t opaque[1]; }; static inline void MALI_RENDERER_PROPERTIES_unpack(const uint8_t * restrict cl, struct MALI_RENDERER_PROPERTIES * restrict values) { if (((const uint32_t *) cl)[0] & 0xe606c400) fprintf(stderr, "XXX: Invalid field of Renderer Properties unpacked at word 0\n"); values->uniform_buffer_count = __gen_unpack_uint(cl, 0, 7); values->depth_source = (enum mali_depth_source)__gen_unpack_uint(cl, 8, 9); values->shader_contains_barrier = __gen_unpack_uint(cl, 11, 11); values->shader_register_allocation = (enum mali_shader_register_allocation)__gen_unpack_uint(cl, 12, 13); values->shader_modifies_coverage = __gen_unpack_uint(cl, 16, 16); values->allow_forward_pixel_to_kill = __gen_unpack_uint(cl, 19, 19); values->allow_forward_pixel_to_be_killed = __gen_unpack_uint(cl, 20, 20); values->pixel_kill_operation = (enum mali_pixel_kill)__gen_unpack_uint(cl, 21, 22); values->zs_update_operation = (enum mali_pixel_kill)__gen_unpack_uint(cl, 23, 24); values->point_sprite_coord_origin_max_y = __gen_unpack_uint(cl, 27, 27); values->stencil_from_shader = __gen_unpack_uint(cl, 28, 28); } static inline void MALI_RENDERER_PROPERTIES_print(FILE *fp, const struct MALI_RENDERER_PROPERTIES * values, unsigned indent) { fprintf(fp, "%*sUniform buffer count: %u\n", indent, "", values->uniform_buffer_count); fprintf(fp, "%*sDepth source: %s\n", indent, "", mali_depth_source_as_str(values->depth_source)); fprintf(fp, "%*sShader contains barrier: %s\n", indent, "", values->shader_contains_barrier ? "true" : "false"); fprintf(fp, "%*sShader register allocation: %s\n", indent, "", mali_shader_register_allocation_as_str(values->shader_register_allocation)); fprintf(fp, "%*sShader modifies coverage: %s\n", indent, "", values->shader_modifies_coverage ? "true" : "false"); fprintf(fp, "%*sAllow forward pixel to kill: %s\n", indent, "", values->allow_forward_pixel_to_kill ? "true" : "false"); fprintf(fp, "%*sAllow forward pixel to be killed: %s\n", indent, "", values->allow_forward_pixel_to_be_killed ? "true" : "false"); fprintf(fp, "%*sPixel kill operation: %s\n", indent, "", mali_pixel_kill_as_str(values->pixel_kill_operation)); fprintf(fp, "%*sZS update operation: %s\n", indent, "", mali_pixel_kill_as_str(values->zs_update_operation)); fprintf(fp, "%*sPoint sprite coord origin max Y: %s\n", indent, "", values->point_sprite_coord_origin_max_y ? "true" : "false"); fprintf(fp, "%*sStencil from shader: %s\n", indent, "", values->stencil_from_shader ? "true" : "false"); } struct MALI_COMPUTE_PRELOAD { bool pc; bool local_invocation_xy; bool local_invocation_z; bool work_group_x; bool work_group_y; bool work_group_z; bool global_invocation_x; bool global_invocation_y; bool global_invocation_z; }; #define MALI_COMPUTE_PRELOAD_header \ 0 static inline void MALI_COMPUTE_PRELOAD_print(FILE *fp, const struct MALI_COMPUTE_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sPC: %s\n", indent, "", values->pc ? "true" : "false"); fprintf(fp, "%*sLocal Invocation XY: %s\n", indent, "", values->local_invocation_xy ? "true" : "false"); fprintf(fp, "%*sLocal Invocation Z: %s\n", indent, "", values->local_invocation_z ? "true" : "false"); fprintf(fp, "%*sWork group X: %s\n", indent, "", values->work_group_x ? "true" : "false"); fprintf(fp, "%*sWork group Y: %s\n", indent, "", values->work_group_y ? "true" : "false"); fprintf(fp, "%*sWork group Z: %s\n", indent, "", values->work_group_z ? "true" : "false"); fprintf(fp, "%*sGlobal Invocation X: %s\n", indent, "", values->global_invocation_x ? "true" : "false"); fprintf(fp, "%*sGlobal Invocation Y: %s\n", indent, "", values->global_invocation_y ? "true" : "false"); fprintf(fp, "%*sGlobal Invocation Z: %s\n", indent, "", values->global_invocation_z ? "true" : "false"); } enum mali_warp_limit { MALI_WARP_LIMIT_NONE = 0, MALI_WARP_LIMIT_2 = 1, MALI_WARP_LIMIT_4 = 2, MALI_WARP_LIMIT_8 = 3, }; static inline const char * mali_warp_limit_as_str(enum mali_warp_limit imm) { switch (imm) { case MALI_WARP_LIMIT_NONE: return "None"; case MALI_WARP_LIMIT_2: return "2"; case MALI_WARP_LIMIT_4: return "4"; case MALI_WARP_LIMIT_8: return "8"; default: return "XXX: INVALID"; } } struct MALI_VERTEX_PRELOAD { enum mali_warp_limit warp_limit; bool pc; bool position_result_address_lo; bool position_result_address_hi; bool vertex_id; bool instance_id; }; #define MALI_VERTEX_PRELOAD_header \ 0 static inline void MALI_VERTEX_PRELOAD_print(FILE *fp, const struct MALI_VERTEX_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sWarp limit: %s\n", indent, "", mali_warp_limit_as_str(values->warp_limit)); fprintf(fp, "%*sPC: %s\n", indent, "", values->pc ? "true" : "false"); fprintf(fp, "%*sPosition result address lo: %s\n", indent, "", values->position_result_address_lo ? "true" : "false"); fprintf(fp, "%*sPosition result address hi: %s\n", indent, "", values->position_result_address_hi ? "true" : "false"); fprintf(fp, "%*sVertex ID: %s\n", indent, "", values->vertex_id ? "true" : "false"); fprintf(fp, "%*sInstance ID: %s\n", indent, "", values->instance_id ? "true" : "false"); } struct MALI_FRAGMENT_PRELOAD { bool pc; bool coverage; bool primitive_id; bool primitive_flags; bool fragment_position; bool sample_mask_id; }; #define MALI_FRAGMENT_PRELOAD_header \ 0 static inline void MALI_FRAGMENT_PRELOAD_print(FILE *fp, const struct MALI_FRAGMENT_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sPC: %s\n", indent, "", values->pc ? "true" : "false"); fprintf(fp, "%*sCoverage: %s\n", indent, "", values->coverage ? "true" : "false"); fprintf(fp, "%*sPrimitive ID: %s\n", indent, "", values->primitive_id ? "true" : "false"); fprintf(fp, "%*sPrimitive flags: %s\n", indent, "", values->primitive_flags ? "true" : "false"); fprintf(fp, "%*sFragment position: %s\n", indent, "", values->fragment_position ? "true" : "false"); fprintf(fp, "%*sSample mask/ID: %s\n", indent, "", values->sample_mask_id ? "true" : "false"); } struct MALI_PRELOAD { struct MALI_COMPUTE_PRELOAD compute; struct MALI_VERTEX_PRELOAD vertex; struct MALI_FRAGMENT_PRELOAD fragment; uint32_t uniform_count; }; #define MALI_PRELOAD_header \ .compute = { MALI_COMPUTE_PRELOAD_header }, \ .vertex = { MALI_VERTEX_PRELOAD_header }, \ .fragment = { MALI_FRAGMENT_PRELOAD_header } static inline void MALI_PRELOAD_pack(uint32_t * restrict cl, const struct MALI_PRELOAD * restrict values) { cl[ 0] = __gen_uint(values->compute.pc, 6, 6) | __gen_uint(values->compute.local_invocation_xy, 7, 7) | __gen_uint(values->compute.local_invocation_z, 8, 8) | __gen_uint(values->compute.work_group_x, 9, 9) | __gen_uint(values->compute.work_group_y, 10, 10) | __gen_uint(values->compute.work_group_z, 11, 11) | __gen_uint(values->compute.global_invocation_x, 12, 12) | __gen_uint(values->compute.global_invocation_y, 13, 13) | __gen_uint(values->compute.global_invocation_z, 14, 14) | __gen_uint(values->vertex.warp_limit, 0, 1) | __gen_uint(values->vertex.pc, 6, 6) | __gen_uint(values->vertex.position_result_address_lo, 10, 10) | __gen_uint(values->vertex.position_result_address_hi, 11, 11) | __gen_uint(values->vertex.vertex_id, 13, 13) | __gen_uint(values->vertex.instance_id, 14, 14) | __gen_uint(values->fragment.pc, 6, 6) | __gen_uint(values->fragment.coverage, 7, 7) | __gen_uint(values->fragment.primitive_id, 9, 9) | __gen_uint(values->fragment.primitive_flags, 10, 10) | __gen_uint(values->fragment.fragment_position, 11, 11) | __gen_uint(values->fragment.sample_mask_id, 13, 13) | __gen_uint(values->uniform_count, 15, 21); } #define MALI_PRELOAD_LENGTH 4 struct mali_preload_packed { uint32_t opaque[1]; }; static inline void MALI_PRELOAD_unpack(const uint8_t * restrict cl, struct MALI_PRELOAD * restrict values) { if (((const uint32_t *) cl)[0] & 0xffc0003c) fprintf(stderr, "XXX: Invalid field of Preload unpacked at word 0\n"); values->compute.pc = __gen_unpack_uint(cl, 6, 6); values->compute.local_invocation_xy = __gen_unpack_uint(cl, 7, 7); values->compute.local_invocation_z = __gen_unpack_uint(cl, 8, 8); values->compute.work_group_x = __gen_unpack_uint(cl, 9, 9); values->compute.work_group_y = __gen_unpack_uint(cl, 10, 10); values->compute.work_group_z = __gen_unpack_uint(cl, 11, 11); values->compute.global_invocation_x = __gen_unpack_uint(cl, 12, 12); values->compute.global_invocation_y = __gen_unpack_uint(cl, 13, 13); values->compute.global_invocation_z = __gen_unpack_uint(cl, 14, 14); values->vertex.warp_limit = (enum mali_warp_limit)__gen_unpack_uint(cl, 0, 1); values->vertex.pc = __gen_unpack_uint(cl, 6, 6); values->vertex.position_result_address_lo = __gen_unpack_uint(cl, 10, 10); values->vertex.position_result_address_hi = __gen_unpack_uint(cl, 11, 11); values->vertex.vertex_id = __gen_unpack_uint(cl, 13, 13); values->vertex.instance_id = __gen_unpack_uint(cl, 14, 14); values->fragment.pc = __gen_unpack_uint(cl, 6, 6); values->fragment.coverage = __gen_unpack_uint(cl, 7, 7); values->fragment.primitive_id = __gen_unpack_uint(cl, 9, 9); values->fragment.primitive_flags = __gen_unpack_uint(cl, 10, 10); values->fragment.fragment_position = __gen_unpack_uint(cl, 11, 11); values->fragment.sample_mask_id = __gen_unpack_uint(cl, 13, 13); values->uniform_count = __gen_unpack_uint(cl, 15, 21); } static inline void MALI_PRELOAD_print(FILE *fp, const struct MALI_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sCompute:\n", indent, ""); MALI_COMPUTE_PRELOAD_print(fp, &values->compute, indent + 2); fprintf(fp, "%*sVertex:\n", indent, ""); MALI_VERTEX_PRELOAD_print(fp, &values->vertex, indent + 2); fprintf(fp, "%*sFragment:\n", indent, ""); MALI_FRAGMENT_PRELOAD_print(fp, &values->fragment, indent + 2); fprintf(fp, "%*sUniform count: %u\n", indent, "", values->uniform_count); } struct MALI_SHADER { uint64_t shader; uint32_t sampler_count; uint32_t texture_count; uint32_t attribute_count; uint32_t varying_count; }; #define MALI_SHADER_header \ 0 static inline void MALI_SHADER_pack(uint32_t * restrict cl, const struct MALI_SHADER * restrict values) { cl[ 0] = __gen_uint(values->shader, 0, 63); cl[ 1] = __gen_uint(values->shader, 0, 63) >> 32; cl[ 2] = __gen_uint(values->sampler_count, 0, 15) | __gen_uint(values->texture_count, 16, 31); cl[ 3] = __gen_uint(values->attribute_count, 0, 15) | __gen_uint(values->varying_count, 16, 31); } #define MALI_SHADER_LENGTH 16 struct mali_shader_packed { uint32_t opaque[4]; }; static inline void MALI_SHADER_unpack(const uint8_t * restrict cl, struct MALI_SHADER * restrict values) { values->shader = __gen_unpack_uint(cl, 0, 63); values->sampler_count = __gen_unpack_uint(cl, 64, 79); values->texture_count = __gen_unpack_uint(cl, 80, 95); values->attribute_count = __gen_unpack_uint(cl, 96, 111); values->varying_count = __gen_unpack_uint(cl, 112, 127); } static inline void MALI_SHADER_print(FILE *fp, const struct MALI_SHADER * values, unsigned indent) { fprintf(fp, "%*sShader: 0x%" PRIx64 "\n", indent, "", values->shader); fprintf(fp, "%*sSampler count: %u\n", indent, "", values->sampler_count); fprintf(fp, "%*sTexture count: %u\n", indent, "", values->texture_count); fprintf(fp, "%*sAttribute count: %u\n", indent, "", values->attribute_count); fprintf(fp, "%*sVarying count: %u\n", indent, "", values->varying_count); } struct MALI_MULTISAMPLE_MISC { uint32_t sample_mask; bool multisample_enable; bool multisample_late_coverage; bool evaluate_per_sample; bool fixed_function_depth_range_fixed; bool shader_depth_range_fixed; bool overdraw_alpha1; bool overdraw_alpha0; enum mali_func depth_function; bool depth_write_mask; bool fixed_function_near_discard; bool fixed_function_far_discard; bool fragment_near_discard; bool fragment_far_discard; }; #define MALI_MULTISAMPLE_MISC_header \ 0 static inline void MALI_MULTISAMPLE_MISC_pack(uint32_t * restrict cl, const struct MALI_MULTISAMPLE_MISC * restrict values) { cl[ 0] = __gen_uint(values->sample_mask, 0, 15) | __gen_uint(values->multisample_enable, 16, 16) | __gen_uint(values->multisample_late_coverage, 17, 17) | __gen_uint(values->evaluate_per_sample, 18, 18) | __gen_uint(values->fixed_function_depth_range_fixed, 19, 19) | __gen_uint(values->shader_depth_range_fixed, 20, 20) | __gen_uint(values->overdraw_alpha1, 22, 22) | __gen_uint(values->overdraw_alpha0, 23, 23) | __gen_uint(values->depth_function, 24, 26) | __gen_uint(values->depth_write_mask, 27, 27) | __gen_uint(values->fixed_function_near_discard, 28, 28) | __gen_uint(values->fixed_function_far_discard, 29, 29) | __gen_uint(values->fragment_near_discard, 30, 30) | __gen_uint(values->fragment_far_discard, 31, 31); } #define MALI_MULTISAMPLE_MISC_LENGTH 4 struct mali_multisample_misc_packed { uint32_t opaque[1]; }; static inline void MALI_MULTISAMPLE_MISC_unpack(const uint8_t * restrict cl, struct MALI_MULTISAMPLE_MISC * restrict values) { if (((const uint32_t *) cl)[0] & 0x200000) fprintf(stderr, "XXX: Invalid field of Multisample, Misc unpacked at word 0\n"); values->sample_mask = __gen_unpack_uint(cl, 0, 15); values->multisample_enable = __gen_unpack_uint(cl, 16, 16); values->multisample_late_coverage = __gen_unpack_uint(cl, 17, 17); values->evaluate_per_sample = __gen_unpack_uint(cl, 18, 18); values->fixed_function_depth_range_fixed = __gen_unpack_uint(cl, 19, 19); values->shader_depth_range_fixed = __gen_unpack_uint(cl, 20, 20); values->overdraw_alpha1 = __gen_unpack_uint(cl, 22, 22); values->overdraw_alpha0 = __gen_unpack_uint(cl, 23, 23); values->depth_function = (enum mali_func)__gen_unpack_uint(cl, 24, 26); values->depth_write_mask = __gen_unpack_uint(cl, 27, 27); values->fixed_function_near_discard = __gen_unpack_uint(cl, 28, 28); values->fixed_function_far_discard = __gen_unpack_uint(cl, 29, 29); values->fragment_near_discard = __gen_unpack_uint(cl, 30, 30); values->fragment_far_discard = __gen_unpack_uint(cl, 31, 31); } static inline void MALI_MULTISAMPLE_MISC_print(FILE *fp, const struct MALI_MULTISAMPLE_MISC * values, unsigned indent) { fprintf(fp, "%*sSample mask: %u\n", indent, "", values->sample_mask); fprintf(fp, "%*sMultisample enable: %s\n", indent, "", values->multisample_enable ? "true" : "false"); fprintf(fp, "%*sMultisample late coverage: %s\n", indent, "", values->multisample_late_coverage ? "true" : "false"); fprintf(fp, "%*sEvaluate per-sample: %s\n", indent, "", values->evaluate_per_sample ? "true" : "false"); fprintf(fp, "%*sFixed-function depth range fixed: %s\n", indent, "", values->fixed_function_depth_range_fixed ? "true" : "false"); fprintf(fp, "%*sShader depth range fixed: %s\n", indent, "", values->shader_depth_range_fixed ? "true" : "false"); fprintf(fp, "%*sOverdraw alpha1: %s\n", indent, "", values->overdraw_alpha1 ? "true" : "false"); fprintf(fp, "%*sOverdraw alpha0: %s\n", indent, "", values->overdraw_alpha0 ? "true" : "false"); fprintf(fp, "%*sDepth function: %s\n", indent, "", mali_func_as_str(values->depth_function)); fprintf(fp, "%*sDepth write mask: %s\n", indent, "", values->depth_write_mask ? "true" : "false"); fprintf(fp, "%*sFixed-function near discard: %s\n", indent, "", values->fixed_function_near_discard ? "true" : "false"); fprintf(fp, "%*sFixed-function far discard: %s\n", indent, "", values->fixed_function_far_discard ? "true" : "false"); fprintf(fp, "%*sFragment near discard: %s\n", indent, "", values->fragment_near_discard ? "true" : "false"); fprintf(fp, "%*sFragment far discard: %s\n", indent, "", values->fragment_far_discard ? "true" : "false"); } struct MALI_STENCIL_MASK_MISC { uint32_t stencil_mask_front; uint32_t stencil_mask_back; bool stencil_enable; bool alpha_to_coverage; bool alpha_to_coverage_invert; enum mali_func alpha_test_compare_function; bool force_seamless_cubemaps; bool depth_range_1; bool depth_range_2; bool single_sampled_lines; bool point_snap; }; #define MALI_STENCIL_MASK_MISC_header \ 0 static inline void MALI_STENCIL_MASK_MISC_pack(uint32_t * restrict cl, const struct MALI_STENCIL_MASK_MISC * restrict values) { cl[ 0] = __gen_uint(values->stencil_mask_front, 0, 7) | __gen_uint(values->stencil_mask_back, 8, 15) | __gen_uint(values->stencil_enable, 16, 16) | __gen_uint(values->alpha_to_coverage, 17, 17) | __gen_uint(values->alpha_to_coverage_invert, 18, 18) | __gen_uint(values->alpha_test_compare_function, 21, 23) | __gen_uint(values->force_seamless_cubemaps, 26, 26) | __gen_uint(values->depth_range_1, 28, 28) | __gen_uint(values->depth_range_2, 29, 29) | __gen_uint(values->single_sampled_lines, 30, 30) | __gen_uint(values->point_snap, 31, 31); } #define MALI_STENCIL_MASK_MISC_LENGTH 4 struct mali_stencil_mask_misc_packed { uint32_t opaque[1]; }; static inline void MALI_STENCIL_MASK_MISC_unpack(const uint8_t * restrict cl, struct MALI_STENCIL_MASK_MISC * restrict values) { if (((const uint32_t *) cl)[0] & 0xb180000) fprintf(stderr, "XXX: Invalid field of Stencil Mask, Misc unpacked at word 0\n"); values->stencil_mask_front = __gen_unpack_uint(cl, 0, 7); values->stencil_mask_back = __gen_unpack_uint(cl, 8, 15); values->stencil_enable = __gen_unpack_uint(cl, 16, 16); values->alpha_to_coverage = __gen_unpack_uint(cl, 17, 17); values->alpha_to_coverage_invert = __gen_unpack_uint(cl, 18, 18); values->alpha_test_compare_function = (enum mali_func)__gen_unpack_uint(cl, 21, 23); values->force_seamless_cubemaps = __gen_unpack_uint(cl, 26, 26); values->depth_range_1 = __gen_unpack_uint(cl, 28, 28); values->depth_range_2 = __gen_unpack_uint(cl, 29, 29); values->single_sampled_lines = __gen_unpack_uint(cl, 30, 30); values->point_snap = __gen_unpack_uint(cl, 31, 31); } static inline void MALI_STENCIL_MASK_MISC_print(FILE *fp, const struct MALI_STENCIL_MASK_MISC * values, unsigned indent) { fprintf(fp, "%*sStencil mask front: %u\n", indent, "", values->stencil_mask_front); fprintf(fp, "%*sStencil mask back: %u\n", indent, "", values->stencil_mask_back); fprintf(fp, "%*sStencil enable: %s\n", indent, "", values->stencil_enable ? "true" : "false"); fprintf(fp, "%*sAlpha-to-coverage: %s\n", indent, "", values->alpha_to_coverage ? "true" : "false"); fprintf(fp, "%*sAlpha-to-coverage Invert: %s\n", indent, "", values->alpha_to_coverage_invert ? "true" : "false"); fprintf(fp, "%*sAlpha test compare function: %s\n", indent, "", mali_func_as_str(values->alpha_test_compare_function)); fprintf(fp, "%*sForce seamless cubemaps: %s\n", indent, "", values->force_seamless_cubemaps ? "true" : "false"); fprintf(fp, "%*sDepth Range 1: %s\n", indent, "", values->depth_range_1 ? "true" : "false"); fprintf(fp, "%*sDepth Range 2: %s\n", indent, "", values->depth_range_2 ? "true" : "false"); fprintf(fp, "%*sSingle-sampled lines: %s\n", indent, "", values->single_sampled_lines ? "true" : "false"); fprintf(fp, "%*sPoint snap: %s\n", indent, "", values->point_snap ? "true" : "false"); } struct MALI_STENCIL { uint32_t reference_value; uint32_t mask; enum mali_func compare_function; enum mali_stencil_op stencil_fail; enum mali_stencil_op depth_fail; enum mali_stencil_op depth_pass; }; #define MALI_STENCIL_header \ 0 static inline void MALI_STENCIL_pack(uint32_t * restrict cl, const struct MALI_STENCIL * restrict values) { cl[ 0] = __gen_uint(values->reference_value, 0, 7) | __gen_uint(values->mask, 8, 15) | __gen_uint(values->compare_function, 16, 18) | __gen_uint(values->stencil_fail, 19, 21) | __gen_uint(values->depth_fail, 22, 24) | __gen_uint(values->depth_pass, 25, 27); } #define MALI_STENCIL_LENGTH 4 struct mali_stencil_packed { uint32_t opaque[1]; }; static inline void MALI_STENCIL_unpack(const uint8_t * restrict cl, struct MALI_STENCIL * restrict values) { if (((const uint32_t *) cl)[0] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Stencil unpacked at word 0\n"); values->reference_value = __gen_unpack_uint(cl, 0, 7); values->mask = __gen_unpack_uint(cl, 8, 15); values->compare_function = (enum mali_func)__gen_unpack_uint(cl, 16, 18); values->stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 19, 21); values->depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 22, 24); values->depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 25, 27); } static inline void MALI_STENCIL_print(FILE *fp, const struct MALI_STENCIL * values, unsigned indent) { fprintf(fp, "%*sReference Value: %u\n", indent, "", values->reference_value); fprintf(fp, "%*sMask: %u\n", indent, "", values->mask); fprintf(fp, "%*sCompare Function: %s\n", indent, "", mali_func_as_str(values->compare_function)); fprintf(fp, "%*sStencil Fail: %s\n", indent, "", mali_stencil_op_as_str(values->stencil_fail)); fprintf(fp, "%*sDepth Fail: %s\n", indent, "", mali_stencil_op_as_str(values->depth_fail)); fprintf(fp, "%*sDepth Pass: %s\n", indent, "", mali_stencil_op_as_str(values->depth_pass)); } struct MALI_LD_VAR_PRELOAD { uint32_t varying_index; enum mali_message_preload_register_format register_format; uint32_t num_components; }; #define MALI_LD_VAR_PRELOAD_header \ .num_components = 1 static inline void MALI_LD_VAR_PRELOAD_print(FILE *fp, const struct MALI_LD_VAR_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sVarying Index: %u\n", indent, "", values->varying_index); fprintf(fp, "%*sRegister Format: %s\n", indent, "", mali_message_preload_register_format_as_str(values->register_format)); fprintf(fp, "%*sNum Components: %u\n", indent, "", values->num_components); } struct MALI_VAR_TEX_PRELOAD { uint32_t varying_index; uint32_t sampler_index; enum mali_message_preload_register_format register_format; bool skip; bool zero_lod; }; #define MALI_VAR_TEX_PRELOAD_header \ 0 static inline void MALI_VAR_TEX_PRELOAD_print(FILE *fp, const struct MALI_VAR_TEX_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sVarying Index: %u\n", indent, "", values->varying_index); fprintf(fp, "%*sSampler Index: %u\n", indent, "", values->sampler_index); fprintf(fp, "%*sRegister Format: %s\n", indent, "", mali_message_preload_register_format_as_str(values->register_format)); fprintf(fp, "%*sSkip: %s\n", indent, "", values->skip ? "true" : "false"); fprintf(fp, "%*sZero LOD: %s\n", indent, "", values->zero_lod ? "true" : "false"); } struct MALI_MESSAGE_PRELOAD { enum mali_message_type type; struct MALI_LD_VAR_PRELOAD ld_var; struct MALI_VAR_TEX_PRELOAD var_tex; }; #define MALI_MESSAGE_PRELOAD_header \ .ld_var = { MALI_LD_VAR_PRELOAD_header }, \ .var_tex = { MALI_VAR_TEX_PRELOAD_header } static inline void MALI_MESSAGE_PRELOAD_pack(uint32_t * restrict cl, const struct MALI_MESSAGE_PRELOAD * restrict values) { cl[ 0] = __gen_uint(values->type, 0, 3) | __gen_uint(values->ld_var.varying_index, 4, 8) | __gen_uint(values->ld_var.register_format, 9, 10) | __gen_uint(values->ld_var.num_components - 1, 11, 12) | __gen_uint(values->var_tex.varying_index, 4, 6) | __gen_uint(values->var_tex.sampler_index, 7, 8) | __gen_uint(values->var_tex.register_format, 9, 10) | __gen_uint(values->var_tex.skip, 14, 14) | __gen_uint(values->var_tex.zero_lod, 15, 15); } #define MALI_MESSAGE_PRELOAD_LENGTH 4 struct mali_message_preload_packed { uint32_t opaque[1]; }; static inline void MALI_MESSAGE_PRELOAD_unpack(const uint8_t * restrict cl, struct MALI_MESSAGE_PRELOAD * restrict values) { if (((const uint32_t *) cl)[0] & 0xffff2000) fprintf(stderr, "XXX: Invalid field of Message Preload unpacked at word 0\n"); values->type = (enum mali_message_type)__gen_unpack_uint(cl, 0, 3); values->ld_var.varying_index = __gen_unpack_uint(cl, 4, 8); values->ld_var.register_format = (enum mali_message_preload_register_format)__gen_unpack_uint(cl, 9, 10); values->ld_var.num_components = __gen_unpack_uint(cl, 11, 12) + 1; values->var_tex.varying_index = __gen_unpack_uint(cl, 4, 6); values->var_tex.sampler_index = __gen_unpack_uint(cl, 7, 8); values->var_tex.register_format = (enum mali_message_preload_register_format)__gen_unpack_uint(cl, 9, 10); values->var_tex.skip = __gen_unpack_uint(cl, 14, 14); values->var_tex.zero_lod = __gen_unpack_uint(cl, 15, 15); } static inline void MALI_MESSAGE_PRELOAD_print(FILE *fp, const struct MALI_MESSAGE_PRELOAD * values, unsigned indent) { fprintf(fp, "%*sType: %s\n", indent, "", mali_message_type_as_str(values->type)); fprintf(fp, "%*sLD_VAR:\n", indent, ""); MALI_LD_VAR_PRELOAD_print(fp, &values->ld_var, indent + 2); fprintf(fp, "%*sVAR_TEX:\n", indent, ""); MALI_VAR_TEX_PRELOAD_print(fp, &values->var_tex, indent + 2); } struct MALI_RENDERER_STATE { struct MALI_SHADER shader; struct MALI_RENDERER_PROPERTIES properties; float depth_units; float depth_factor; float depth_bias_clamp; struct MALI_MULTISAMPLE_MISC multisample_misc; struct MALI_STENCIL_MASK_MISC stencil_mask_misc; struct MALI_STENCIL stencil_front; struct MALI_STENCIL stencil_back; struct MALI_PRELOAD preload; float alpha_reference; uint32_t thread_balancing; struct MALI_PRELOAD secondary_preload; uint64_t secondary_shader; }; #define MALI_RENDERER_STATE_header \ .shader = { MALI_SHADER_header }, \ .properties = { MALI_RENDERER_PROPERTIES_header }, \ .multisample_misc = { MALI_MULTISAMPLE_MISC_header }, \ .stencil_mask_misc = { MALI_STENCIL_MASK_MISC_header }, \ .stencil_front = { MALI_STENCIL_header }, \ .stencil_back = { MALI_STENCIL_header }, \ .preload = { MALI_PRELOAD_header }, \ .secondary_preload = { MALI_PRELOAD_header } static inline void MALI_RENDERER_STATE_pack(uint32_t * restrict cl, const struct MALI_RENDERER_STATE * restrict values) { cl[ 0] = __gen_uint(values->shader.shader, 0, 63); cl[ 1] = __gen_uint(values->shader.shader, 0, 63) >> 32; cl[ 2] = __gen_uint(values->shader.sampler_count, 0, 15) | __gen_uint(values->shader.texture_count, 16, 31); cl[ 3] = __gen_uint(values->shader.attribute_count, 0, 15) | __gen_uint(values->shader.varying_count, 16, 31); cl[ 4] = __gen_uint(values->properties.uniform_buffer_count, 0, 7) | __gen_uint(values->properties.depth_source, 8, 9) | __gen_uint(values->properties.shader_contains_barrier, 11, 11) | __gen_uint(values->properties.shader_register_allocation, 12, 13) | __gen_uint(values->properties.shader_modifies_coverage, 16, 16) | __gen_uint(values->properties.allow_forward_pixel_to_kill, 19, 19) | __gen_uint(values->properties.allow_forward_pixel_to_be_killed, 20, 20) | __gen_uint(values->properties.pixel_kill_operation, 21, 22) | __gen_uint(values->properties.zs_update_operation, 23, 24) | __gen_uint(values->properties.point_sprite_coord_origin_max_y, 27, 27) | __gen_uint(values->properties.stencil_from_shader, 28, 28); cl[ 5] = __gen_uint(fui(values->depth_units), 0, 32); cl[ 6] = __gen_uint(fui(values->depth_factor), 0, 32); cl[ 7] = __gen_uint(fui(values->depth_bias_clamp), 0, 32); cl[ 8] = __gen_uint(values->multisample_misc.sample_mask, 0, 15) | __gen_uint(values->multisample_misc.multisample_enable, 16, 16) | __gen_uint(values->multisample_misc.multisample_late_coverage, 17, 17) | __gen_uint(values->multisample_misc.evaluate_per_sample, 18, 18) | __gen_uint(values->multisample_misc.fixed_function_depth_range_fixed, 19, 19) | __gen_uint(values->multisample_misc.shader_depth_range_fixed, 20, 20) | __gen_uint(values->multisample_misc.overdraw_alpha1, 22, 22) | __gen_uint(values->multisample_misc.overdraw_alpha0, 23, 23) | __gen_uint(values->multisample_misc.depth_function, 24, 26) | __gen_uint(values->multisample_misc.depth_write_mask, 27, 27) | __gen_uint(values->multisample_misc.fixed_function_near_discard, 28, 28) | __gen_uint(values->multisample_misc.fixed_function_far_discard, 29, 29) | __gen_uint(values->multisample_misc.fragment_near_discard, 30, 30) | __gen_uint(values->multisample_misc.fragment_far_discard, 31, 31); cl[ 9] = __gen_uint(values->stencil_mask_misc.stencil_mask_front, 0, 7) | __gen_uint(values->stencil_mask_misc.stencil_mask_back, 8, 15) | __gen_uint(values->stencil_mask_misc.stencil_enable, 16, 16) | __gen_uint(values->stencil_mask_misc.alpha_to_coverage, 17, 17) | __gen_uint(values->stencil_mask_misc.alpha_to_coverage_invert, 18, 18) | __gen_uint(values->stencil_mask_misc.alpha_test_compare_function, 21, 23) | __gen_uint(values->stencil_mask_misc.force_seamless_cubemaps, 26, 26) | __gen_uint(values->stencil_mask_misc.depth_range_1, 28, 28) | __gen_uint(values->stencil_mask_misc.depth_range_2, 29, 29) | __gen_uint(values->stencil_mask_misc.single_sampled_lines, 30, 30) | __gen_uint(values->stencil_mask_misc.point_snap, 31, 31); cl[10] = __gen_uint(values->stencil_front.reference_value, 0, 7) | __gen_uint(values->stencil_front.mask, 8, 15) | __gen_uint(values->stencil_front.compare_function, 16, 18) | __gen_uint(values->stencil_front.stencil_fail, 19, 21) | __gen_uint(values->stencil_front.depth_fail, 22, 24) | __gen_uint(values->stencil_front.depth_pass, 25, 27); cl[11] = __gen_uint(values->stencil_back.reference_value, 0, 7) | __gen_uint(values->stencil_back.mask, 8, 15) | __gen_uint(values->stencil_back.compare_function, 16, 18) | __gen_uint(values->stencil_back.stencil_fail, 19, 21) | __gen_uint(values->stencil_back.depth_fail, 22, 24) | __gen_uint(values->stencil_back.depth_pass, 25, 27); cl[12] = __gen_uint(values->preload.compute.pc, 6, 6) | __gen_uint(values->preload.compute.local_invocation_xy, 7, 7) | __gen_uint(values->preload.compute.local_invocation_z, 8, 8) | __gen_uint(values->preload.compute.work_group_x, 9, 9) | __gen_uint(values->preload.compute.work_group_y, 10, 10) | __gen_uint(values->preload.compute.work_group_z, 11, 11) | __gen_uint(values->preload.compute.global_invocation_x, 12, 12) | __gen_uint(values->preload.compute.global_invocation_y, 13, 13) | __gen_uint(values->preload.compute.global_invocation_z, 14, 14) | __gen_uint(values->preload.vertex.warp_limit, 0, 1) | __gen_uint(values->preload.vertex.pc, 6, 6) | __gen_uint(values->preload.vertex.position_result_address_lo, 10, 10) | __gen_uint(values->preload.vertex.position_result_address_hi, 11, 11) | __gen_uint(values->preload.vertex.vertex_id, 13, 13) | __gen_uint(values->preload.vertex.instance_id, 14, 14) | __gen_uint(values->preload.fragment.pc, 6, 6) | __gen_uint(values->preload.fragment.coverage, 7, 7) | __gen_uint(values->preload.fragment.primitive_id, 9, 9) | __gen_uint(values->preload.fragment.primitive_flags, 10, 10) | __gen_uint(values->preload.fragment.fragment_position, 11, 11) | __gen_uint(values->preload.fragment.sample_mask_id, 13, 13) | __gen_uint(values->preload.uniform_count, 15, 21) | __gen_uint(fui(values->alpha_reference), 0, 32); cl[13] = __gen_uint(values->thread_balancing, 0, 15) | __gen_uint(values->secondary_preload.compute.pc, 6, 6) | __gen_uint(values->secondary_preload.compute.local_invocation_xy, 7, 7) | __gen_uint(values->secondary_preload.compute.local_invocation_z, 8, 8) | __gen_uint(values->secondary_preload.compute.work_group_x, 9, 9) | __gen_uint(values->secondary_preload.compute.work_group_y, 10, 10) | __gen_uint(values->secondary_preload.compute.work_group_z, 11, 11) | __gen_uint(values->secondary_preload.compute.global_invocation_x, 12, 12) | __gen_uint(values->secondary_preload.compute.global_invocation_y, 13, 13) | __gen_uint(values->secondary_preload.compute.global_invocation_z, 14, 14) | __gen_uint(values->secondary_preload.vertex.warp_limit, 0, 1) | __gen_uint(values->secondary_preload.vertex.pc, 6, 6) | __gen_uint(values->secondary_preload.vertex.position_result_address_lo, 10, 10) | __gen_uint(values->secondary_preload.vertex.position_result_address_hi, 11, 11) | __gen_uint(values->secondary_preload.vertex.vertex_id, 13, 13) | __gen_uint(values->secondary_preload.vertex.instance_id, 14, 14) | __gen_uint(values->secondary_preload.fragment.pc, 6, 6) | __gen_uint(values->secondary_preload.fragment.coverage, 7, 7) | __gen_uint(values->secondary_preload.fragment.primitive_id, 9, 9) | __gen_uint(values->secondary_preload.fragment.primitive_flags, 10, 10) | __gen_uint(values->secondary_preload.fragment.fragment_position, 11, 11) | __gen_uint(values->secondary_preload.fragment.sample_mask_id, 13, 13) | __gen_uint(values->secondary_preload.uniform_count, 15, 21); cl[14] = __gen_uint(values->secondary_shader, 0, 63); cl[15] = __gen_uint(values->secondary_shader, 0, 63) >> 32; } #define MALI_RENDERER_STATE_LENGTH 64 #define MALI_RENDERER_STATE_ALIGN 64 struct mali_renderer_state_packed { uint32_t opaque[16]; }; static inline void MALI_RENDERER_STATE_unpack(const uint8_t * restrict cl, struct MALI_RENDERER_STATE * restrict values) { if (((const uint32_t *) cl)[4] & 0xe606c400) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 4\n"); if (((const uint32_t *) cl)[8] & 0x200000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 8\n"); if (((const uint32_t *) cl)[9] & 0xb180000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 9\n"); if (((const uint32_t *) cl)[10] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 10\n"); if (((const uint32_t *) cl)[11] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 11\n"); if (((const uint32_t *) cl)[13] & 0xffc00000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 13\n"); values->shader.shader = __gen_unpack_uint(cl, 0, 63); values->shader.sampler_count = __gen_unpack_uint(cl, 64, 79); values->shader.texture_count = __gen_unpack_uint(cl, 80, 95); values->shader.attribute_count = __gen_unpack_uint(cl, 96, 111); values->shader.varying_count = __gen_unpack_uint(cl, 112, 127); values->properties.uniform_buffer_count = __gen_unpack_uint(cl, 128, 135); values->properties.depth_source = (enum mali_depth_source)__gen_unpack_uint(cl, 136, 137); values->properties.shader_contains_barrier = __gen_unpack_uint(cl, 139, 139); values->properties.shader_register_allocation = (enum mali_shader_register_allocation)__gen_unpack_uint(cl, 140, 141); values->properties.shader_modifies_coverage = __gen_unpack_uint(cl, 144, 144); values->properties.allow_forward_pixel_to_kill = __gen_unpack_uint(cl, 147, 147); values->properties.allow_forward_pixel_to_be_killed = __gen_unpack_uint(cl, 148, 148); values->properties.pixel_kill_operation = (enum mali_pixel_kill)__gen_unpack_uint(cl, 149, 150); values->properties.zs_update_operation = (enum mali_pixel_kill)__gen_unpack_uint(cl, 151, 152); values->properties.point_sprite_coord_origin_max_y = __gen_unpack_uint(cl, 155, 155); values->properties.stencil_from_shader = __gen_unpack_uint(cl, 156, 156); values->depth_units = __gen_unpack_float(cl, 160, 191); values->depth_factor = __gen_unpack_float(cl, 192, 223); values->depth_bias_clamp = __gen_unpack_float(cl, 224, 255); values->multisample_misc.sample_mask = __gen_unpack_uint(cl, 256, 271); values->multisample_misc.multisample_enable = __gen_unpack_uint(cl, 272, 272); values->multisample_misc.multisample_late_coverage = __gen_unpack_uint(cl, 273, 273); values->multisample_misc.evaluate_per_sample = __gen_unpack_uint(cl, 274, 274); values->multisample_misc.fixed_function_depth_range_fixed = __gen_unpack_uint(cl, 275, 275); values->multisample_misc.shader_depth_range_fixed = __gen_unpack_uint(cl, 276, 276); values->multisample_misc.overdraw_alpha1 = __gen_unpack_uint(cl, 278, 278); values->multisample_misc.overdraw_alpha0 = __gen_unpack_uint(cl, 279, 279); values->multisample_misc.depth_function = (enum mali_func)__gen_unpack_uint(cl, 280, 282); values->multisample_misc.depth_write_mask = __gen_unpack_uint(cl, 283, 283); values->multisample_misc.fixed_function_near_discard = __gen_unpack_uint(cl, 284, 284); values->multisample_misc.fixed_function_far_discard = __gen_unpack_uint(cl, 285, 285); values->multisample_misc.fragment_near_discard = __gen_unpack_uint(cl, 286, 286); values->multisample_misc.fragment_far_discard = __gen_unpack_uint(cl, 287, 287); values->stencil_mask_misc.stencil_mask_front = __gen_unpack_uint(cl, 288, 295); values->stencil_mask_misc.stencil_mask_back = __gen_unpack_uint(cl, 296, 303); values->stencil_mask_misc.stencil_enable = __gen_unpack_uint(cl, 304, 304); values->stencil_mask_misc.alpha_to_coverage = __gen_unpack_uint(cl, 305, 305); values->stencil_mask_misc.alpha_to_coverage_invert = __gen_unpack_uint(cl, 306, 306); values->stencil_mask_misc.alpha_test_compare_function = (enum mali_func)__gen_unpack_uint(cl, 309, 311); values->stencil_mask_misc.force_seamless_cubemaps = __gen_unpack_uint(cl, 314, 314); values->stencil_mask_misc.depth_range_1 = __gen_unpack_uint(cl, 316, 316); values->stencil_mask_misc.depth_range_2 = __gen_unpack_uint(cl, 317, 317); values->stencil_mask_misc.single_sampled_lines = __gen_unpack_uint(cl, 318, 318); values->stencil_mask_misc.point_snap = __gen_unpack_uint(cl, 319, 319); values->stencil_front.reference_value = __gen_unpack_uint(cl, 320, 327); values->stencil_front.mask = __gen_unpack_uint(cl, 328, 335); values->stencil_front.compare_function = (enum mali_func)__gen_unpack_uint(cl, 336, 338); values->stencil_front.stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 339, 341); values->stencil_front.depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 342, 344); values->stencil_front.depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 345, 347); values->stencil_back.reference_value = __gen_unpack_uint(cl, 352, 359); values->stencil_back.mask = __gen_unpack_uint(cl, 360, 367); values->stencil_back.compare_function = (enum mali_func)__gen_unpack_uint(cl, 368, 370); values->stencil_back.stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 371, 373); values->stencil_back.depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 374, 376); values->stencil_back.depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 377, 379); values->preload.compute.pc = __gen_unpack_uint(cl, 390, 390); values->preload.compute.local_invocation_xy = __gen_unpack_uint(cl, 391, 391); values->preload.compute.local_invocation_z = __gen_unpack_uint(cl, 392, 392); values->preload.compute.work_group_x = __gen_unpack_uint(cl, 393, 393); values->preload.compute.work_group_y = __gen_unpack_uint(cl, 394, 394); values->preload.compute.work_group_z = __gen_unpack_uint(cl, 395, 395); values->preload.compute.global_invocation_x = __gen_unpack_uint(cl, 396, 396); values->preload.compute.global_invocation_y = __gen_unpack_uint(cl, 397, 397); values->preload.compute.global_invocation_z = __gen_unpack_uint(cl, 398, 398); values->preload.vertex.warp_limit = (enum mali_warp_limit)__gen_unpack_uint(cl, 384, 385); values->preload.vertex.pc = __gen_unpack_uint(cl, 390, 390); values->preload.vertex.position_result_address_lo = __gen_unpack_uint(cl, 394, 394); values->preload.vertex.position_result_address_hi = __gen_unpack_uint(cl, 395, 395); values->preload.vertex.vertex_id = __gen_unpack_uint(cl, 397, 397); values->preload.vertex.instance_id = __gen_unpack_uint(cl, 398, 398); values->preload.fragment.pc = __gen_unpack_uint(cl, 390, 390); values->preload.fragment.coverage = __gen_unpack_uint(cl, 391, 391); values->preload.fragment.primitive_id = __gen_unpack_uint(cl, 393, 393); values->preload.fragment.primitive_flags = __gen_unpack_uint(cl, 394, 394); values->preload.fragment.fragment_position = __gen_unpack_uint(cl, 395, 395); values->preload.fragment.sample_mask_id = __gen_unpack_uint(cl, 397, 397); values->preload.uniform_count = __gen_unpack_uint(cl, 399, 405); values->alpha_reference = __gen_unpack_float(cl, 384, 415); values->thread_balancing = __gen_unpack_uint(cl, 416, 431); values->secondary_preload.compute.pc = __gen_unpack_uint(cl, 422, 422); values->secondary_preload.compute.local_invocation_xy = __gen_unpack_uint(cl, 423, 423); values->secondary_preload.compute.local_invocation_z = __gen_unpack_uint(cl, 424, 424); values->secondary_preload.compute.work_group_x = __gen_unpack_uint(cl, 425, 425); values->secondary_preload.compute.work_group_y = __gen_unpack_uint(cl, 426, 426); values->secondary_preload.compute.work_group_z = __gen_unpack_uint(cl, 427, 427); values->secondary_preload.compute.global_invocation_x = __gen_unpack_uint(cl, 428, 428); values->secondary_preload.compute.global_invocation_y = __gen_unpack_uint(cl, 429, 429); values->secondary_preload.compute.global_invocation_z = __gen_unpack_uint(cl, 430, 430); values->secondary_preload.vertex.warp_limit = (enum mali_warp_limit)__gen_unpack_uint(cl, 416, 417); values->secondary_preload.vertex.pc = __gen_unpack_uint(cl, 422, 422); values->secondary_preload.vertex.position_result_address_lo = __gen_unpack_uint(cl, 426, 426); values->secondary_preload.vertex.position_result_address_hi = __gen_unpack_uint(cl, 427, 427); values->secondary_preload.vertex.vertex_id = __gen_unpack_uint(cl, 429, 429); values->secondary_preload.vertex.instance_id = __gen_unpack_uint(cl, 430, 430); values->secondary_preload.fragment.pc = __gen_unpack_uint(cl, 422, 422); values->secondary_preload.fragment.coverage = __gen_unpack_uint(cl, 423, 423); values->secondary_preload.fragment.primitive_id = __gen_unpack_uint(cl, 425, 425); values->secondary_preload.fragment.primitive_flags = __gen_unpack_uint(cl, 426, 426); values->secondary_preload.fragment.fragment_position = __gen_unpack_uint(cl, 427, 427); values->secondary_preload.fragment.sample_mask_id = __gen_unpack_uint(cl, 429, 429); values->secondary_preload.uniform_count = __gen_unpack_uint(cl, 431, 437); values->secondary_shader = __gen_unpack_uint(cl, 448, 511); } static inline void MALI_RENDERER_STATE_print(FILE *fp, const struct MALI_RENDERER_STATE * values, unsigned indent) { fprintf(fp, "%*sShader:\n", indent, ""); MALI_SHADER_print(fp, &values->shader, indent + 2); fprintf(fp, "%*sProperties:\n", indent, ""); MALI_RENDERER_PROPERTIES_print(fp, &values->properties, indent + 2); fprintf(fp, "%*sDepth units: %f\n", indent, "", values->depth_units); fprintf(fp, "%*sDepth factor: %f\n", indent, "", values->depth_factor); fprintf(fp, "%*sDepth bias clamp: %f\n", indent, "", values->depth_bias_clamp); fprintf(fp, "%*sMultisample, Misc:\n", indent, ""); MALI_MULTISAMPLE_MISC_print(fp, &values->multisample_misc, indent + 2); fprintf(fp, "%*sStencil Mask, Misc:\n", indent, ""); MALI_STENCIL_MASK_MISC_print(fp, &values->stencil_mask_misc, indent + 2); fprintf(fp, "%*sStencil front:\n", indent, ""); MALI_STENCIL_print(fp, &values->stencil_front, indent + 2); fprintf(fp, "%*sStencil back:\n", indent, ""); MALI_STENCIL_print(fp, &values->stencil_back, indent + 2); fprintf(fp, "%*sPreload:\n", indent, ""); MALI_PRELOAD_print(fp, &values->preload, indent + 2); fprintf(fp, "%*sAlpha reference: %f\n", indent, "", values->alpha_reference); fprintf(fp, "%*sThread Balancing: %u\n", indent, "", values->thread_balancing); fprintf(fp, "%*sSecondary preload:\n", indent, ""); MALI_PRELOAD_print(fp, &values->secondary_preload, indent + 2); fprintf(fp, "%*sSecondary shader: 0x%" PRIx64 "\n", indent, "", values->secondary_shader); } struct MALI_UNIFORM_BUFFER { uint32_t entries; uint64_t pointer; }; #define MALI_UNIFORM_BUFFER_header \ 0 static inline void MALI_UNIFORM_BUFFER_pack(uint32_t * restrict cl, const struct MALI_UNIFORM_BUFFER * restrict values) { assert(values->entries >= 1); assert((values->pointer & 0xf) == 0); cl[ 0] = __gen_uint(values->entries - 1, 0, 11) | __gen_uint(values->pointer >> 4, 12, 63); cl[ 1] = __gen_uint(values->pointer >> 4, 12, 63) >> 32; } #define MALI_UNIFORM_BUFFER_LENGTH 8 #define MALI_UNIFORM_BUFFER_ALIGN 8 struct mali_uniform_buffer_packed { uint32_t opaque[2]; }; static inline void MALI_UNIFORM_BUFFER_unpack(const uint8_t * restrict cl, struct MALI_UNIFORM_BUFFER * restrict values) { values->entries = __gen_unpack_uint(cl, 0, 11) + 1; values->pointer = __gen_unpack_uint(cl, 12, 63) << 4; } static inline void MALI_UNIFORM_BUFFER_print(FILE *fp, const struct MALI_UNIFORM_BUFFER * values, unsigned indent) { fprintf(fp, "%*sEntries: %u\n", indent, "", values->entries); fprintf(fp, "%*sPointer: 0x%" PRIx64 "\n", indent, "", values->pointer); } struct MALI_VIEWPORT { float minimum_x; float minimum_y; float maximum_x; float maximum_y; float minimum_z; float maximum_z; uint32_t scissor_minimum_x; uint32_t scissor_minimum_y; uint32_t scissor_maximum_x; uint32_t scissor_maximum_y; }; #define MALI_VIEWPORT_header \ .minimum_x = -INFINITY, \ .minimum_y = -INFINITY, \ .maximum_x = +INFINITY, \ .maximum_y = +INFINITY, \ .minimum_z = 0.0, \ .maximum_z = 1.0, \ .scissor_minimum_x = 0, \ .scissor_minimum_y = 0 static inline void MALI_VIEWPORT_pack(uint32_t * restrict cl, const struct MALI_VIEWPORT * restrict values) { cl[ 0] = __gen_uint(fui(values->minimum_x), 0, 32); cl[ 1] = __gen_uint(fui(values->minimum_y), 0, 32); cl[ 2] = __gen_uint(fui(values->maximum_x), 0, 32); cl[ 3] = __gen_uint(fui(values->maximum_y), 0, 32); cl[ 4] = __gen_uint(fui(values->minimum_z), 0, 32); cl[ 5] = __gen_uint(fui(values->maximum_z), 0, 32); cl[ 6] = __gen_uint(values->scissor_minimum_x, 0, 15) | __gen_uint(values->scissor_minimum_y, 16, 31); cl[ 7] = __gen_uint(values->scissor_maximum_x, 0, 15) | __gen_uint(values->scissor_maximum_y, 16, 31); } #define MALI_VIEWPORT_LENGTH 32 #define MALI_VIEWPORT_ALIGN 32 struct mali_viewport_packed { uint32_t opaque[8]; }; static inline void MALI_VIEWPORT_unpack(const uint8_t * restrict cl, struct MALI_VIEWPORT * restrict values) { values->minimum_x = __gen_unpack_float(cl, 0, 31); values->minimum_y = __gen_unpack_float(cl, 32, 63); values->maximum_x = __gen_unpack_float(cl, 64, 95); values->maximum_y = __gen_unpack_float(cl, 96, 127); values->minimum_z = __gen_unpack_float(cl, 128, 159); values->maximum_z = __gen_unpack_float(cl, 160, 191); values->scissor_minimum_x = __gen_unpack_uint(cl, 192, 207); values->scissor_minimum_y = __gen_unpack_uint(cl, 208, 223); values->scissor_maximum_x = __gen_unpack_uint(cl, 224, 239); values->scissor_maximum_y = __gen_unpack_uint(cl, 240, 255); } static inline void MALI_VIEWPORT_print(FILE *fp, const struct MALI_VIEWPORT * values, unsigned indent) { fprintf(fp, "%*sMinimum X: %f\n", indent, "", values->minimum_x); fprintf(fp, "%*sMinimum Y: %f\n", indent, "", values->minimum_y); fprintf(fp, "%*sMaximum X: %f\n", indent, "", values->maximum_x); fprintf(fp, "%*sMaximum Y: %f\n", indent, "", values->maximum_y); fprintf(fp, "%*sMinimum Z: %f\n", indent, "", values->minimum_z); fprintf(fp, "%*sMaximum Z: %f\n", indent, "", values->maximum_z); fprintf(fp, "%*sScissor Minimum X: %u\n", indent, "", values->scissor_minimum_x); fprintf(fp, "%*sScissor Minimum Y: %u\n", indent, "", values->scissor_minimum_y); fprintf(fp, "%*sScissor Maximum X: %u\n", indent, "", values->scissor_maximum_x); fprintf(fp, "%*sScissor Maximum Y: %u\n", indent, "", values->scissor_maximum_y); } struct MALI_LOCAL_STORAGE { uint32_t tls_size; uint32_t tls_initial_stack_pointer_offset; uint32_t wls_instances; #define MALI_LOCAL_STORAGE_NO_WORKGROUP_MEM 2147483648 uint32_t wls_size_base; uint32_t wls_size_scale; uint64_t tls_base_pointer; uint64_t wls_base_pointer; }; #define MALI_LOCAL_STORAGE_header \ .wls_instances = MALI_LOCAL_STORAGE_NO_WORKGROUP_MEM static inline void MALI_LOCAL_STORAGE_pack(uint32_t * restrict cl, const struct MALI_LOCAL_STORAGE * restrict values) { assert(util_is_power_of_two_nonzero(values->wls_instances)); cl[ 0] = __gen_uint(values->tls_size, 0, 4) | __gen_uint(values->tls_initial_stack_pointer_offset, 5, 31); cl[ 1] = __gen_uint(util_logbase2(values->wls_instances), 0, 4) | __gen_uint(values->wls_size_base, 5, 6) | __gen_uint(values->wls_size_scale, 8, 12); cl[ 2] = __gen_uint(values->tls_base_pointer, 0, 63); cl[ 3] = __gen_uint(values->tls_base_pointer, 0, 63) >> 32; cl[ 4] = __gen_uint(values->wls_base_pointer, 0, 63); cl[ 5] = __gen_uint(values->wls_base_pointer, 0, 63) >> 32; cl[ 6] = 0; cl[ 7] = 0; } #define MALI_LOCAL_STORAGE_LENGTH 32 #define MALI_LOCAL_STORAGE_ALIGN 64 struct mali_local_storage_packed { uint32_t opaque[8]; }; static inline void MALI_LOCAL_STORAGE_unpack(const uint8_t * restrict cl, struct MALI_LOCAL_STORAGE * restrict values) { if (((const uint32_t *) cl)[1] & 0xffffe080) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 1\n"); if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 7\n"); values->tls_size = __gen_unpack_uint(cl, 0, 4); values->tls_initial_stack_pointer_offset = __gen_unpack_uint(cl, 5, 31); values->wls_instances = 1U << __gen_unpack_uint(cl, 32, 36); values->wls_size_base = __gen_unpack_uint(cl, 37, 38); values->wls_size_scale = __gen_unpack_uint(cl, 40, 44); values->tls_base_pointer = __gen_unpack_uint(cl, 64, 127); values->wls_base_pointer = __gen_unpack_uint(cl, 128, 191); } static inline void MALI_LOCAL_STORAGE_print(FILE *fp, const struct MALI_LOCAL_STORAGE * values, unsigned indent) { fprintf(fp, "%*sTLS Size: %u\n", indent, "", values->tls_size); fprintf(fp, "%*sTLS Initial Stack Pointer Offset: %u\n", indent, "", values->tls_initial_stack_pointer_offset); fprintf(fp, "%*sWLS Instances: %u\n", indent, "", values->wls_instances); fprintf(fp, "%*sWLS Size Base: %u\n", indent, "", values->wls_size_base); fprintf(fp, "%*sWLS Size Scale: %u\n", indent, "", values->wls_size_scale); fprintf(fp, "%*sTLS Base Pointer: 0x%" PRIx64 "\n", indent, "", values->tls_base_pointer); fprintf(fp, "%*sWLS Base Pointer: 0x%" PRIx64 "\n", indent, "", values->wls_base_pointer); } enum mali_color_buffer_internal_format { MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW_VALUE = 0, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R8G8B8A8 = 1, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R10G10B10A2 = 2, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R8G8B8A2 = 3, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R4G4B4A4 = 4, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R5G6B5A0 = 5, MALI_COLOR_BUFFER_INTERNAL_FORMAT_R5G5B5A1 = 6, MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW8 = 32, MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW16 = 33, MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW32 = 34, MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW64 = 35, MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW128 = 36, }; static inline const char * mali_color_buffer_internal_format_as_str(enum mali_color_buffer_internal_format imm) { switch (imm) { case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW_VALUE: return "Raw Value"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R8G8B8A8: return "R8G8B8A8"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R10G10B10A2: return "R10G10B10A2"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R8G8B8A2: return "R8G8B8A2"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R4G4B4A4: return "R4G4B4A4"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R5G6B5A0: return "R5G6B5A0"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_R5G5B5A1: return "R5G5B5A1"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW8: return "RAW8"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW16: return "RAW16"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW32: return "RAW32"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW64: return "RAW64"; case MALI_COLOR_BUFFER_INTERNAL_FORMAT_RAW128: return "RAW128"; default: return "XXX: INVALID"; } } enum mali_color_format { MALI_COLOR_FORMAT_RAW8 = 0, MALI_COLOR_FORMAT_RAW16 = 1, MALI_COLOR_FORMAT_RAW24 = 2, MALI_COLOR_FORMAT_RAW32 = 3, MALI_COLOR_FORMAT_RAW48 = 4, MALI_COLOR_FORMAT_RAW64 = 5, MALI_COLOR_FORMAT_RAW96 = 6, MALI_COLOR_FORMAT_RAW128 = 7, MALI_COLOR_FORMAT_RAW192 = 8, MALI_COLOR_FORMAT_RAW256 = 9, MALI_COLOR_FORMAT_RAW384 = 10, MALI_COLOR_FORMAT_RAW512 = 11, MALI_COLOR_FORMAT_RAW768 = 12, MALI_COLOR_FORMAT_RAW1024 = 13, MALI_COLOR_FORMAT_RAW1536 = 14, MALI_COLOR_FORMAT_RAW2048 = 15, MALI_COLOR_FORMAT_R8 = 16, MALI_COLOR_FORMAT_R8G8 = 17, MALI_COLOR_FORMAT_R8G8B8 = 18, MALI_COLOR_FORMAT_R8G8B8A8 = 19, MALI_COLOR_FORMAT_R4G4B4A4 = 20, MALI_COLOR_FORMAT_R5G6B5 = 21, MALI_COLOR_FORMAT_R8G8B8_FROM_R8G8B8A2 = 22, MALI_COLOR_FORMAT_R10G10B10A2 = 24, MALI_COLOR_FORMAT_A2B10G10R10 = 25, MALI_COLOR_FORMAT_R5G5B5A1 = 28, MALI_COLOR_FORMAT_A1B5G5R5 = 29, MALI_COLOR_FORMAT_NATIVE = 31, }; static inline const char * mali_color_format_as_str(enum mali_color_format imm) { switch (imm) { case MALI_COLOR_FORMAT_RAW8: return "RAW8"; case MALI_COLOR_FORMAT_RAW16: return "RAW16"; case MALI_COLOR_FORMAT_RAW24: return "RAW24"; case MALI_COLOR_FORMAT_RAW32: return "RAW32"; case MALI_COLOR_FORMAT_RAW48: return "RAW48"; case MALI_COLOR_FORMAT_RAW64: return "RAW64"; case MALI_COLOR_FORMAT_RAW96: return "RAW96"; case MALI_COLOR_FORMAT_RAW128: return "RAW128"; case MALI_COLOR_FORMAT_RAW192: return "RAW192"; case MALI_COLOR_FORMAT_RAW256: return "RAW256"; case MALI_COLOR_FORMAT_RAW384: return "RAW384"; case MALI_COLOR_FORMAT_RAW512: return "RAW512"; case MALI_COLOR_FORMAT_RAW768: return "RAW768"; case MALI_COLOR_FORMAT_RAW1024: return "RAW1024"; case MALI_COLOR_FORMAT_RAW1536: return "RAW1536"; case MALI_COLOR_FORMAT_RAW2048: return "RAW2048"; case MALI_COLOR_FORMAT_R8: return "R8"; case MALI_COLOR_FORMAT_R8G8: return "R8G8"; case MALI_COLOR_FORMAT_R8G8B8: return "R8G8B8"; case MALI_COLOR_FORMAT_R8G8B8A8: return "R8G8B8A8"; case MALI_COLOR_FORMAT_R4G4B4A4: return "R4G4B4A4"; case MALI_COLOR_FORMAT_R5G6B5: return "R5G6B5"; case MALI_COLOR_FORMAT_R8G8B8_FROM_R8G8B8A2: return "R8G8B8_FROM_R8G8B8A2"; case MALI_COLOR_FORMAT_R10G10B10A2: return "R10G10B10A2"; case MALI_COLOR_FORMAT_A2B10G10R10: return "A2B10G10R10"; case MALI_COLOR_FORMAT_R5G5B5A1: return "R5G5B5A1"; case MALI_COLOR_FORMAT_A1B5G5R5: return "A1B5G5R5"; case MALI_COLOR_FORMAT_NATIVE: return "NATIVE"; default: return "XXX: INVALID"; } } enum mali_downsampling_accumulation_mode { MALI_DOWNSAMPLING_ACCUMULATION_MODE_UNSIGNED_NORMALIZED_INTEGER = 0, MALI_DOWNSAMPLING_ACCUMULATION_MODE_SIGNED_NORMALIZED_INTEGER = 1, }; static inline const char * mali_downsampling_accumulation_mode_as_str(enum mali_downsampling_accumulation_mode imm) { switch (imm) { case MALI_DOWNSAMPLING_ACCUMULATION_MODE_UNSIGNED_NORMALIZED_INTEGER: return "Unsigned normalized integer"; case MALI_DOWNSAMPLING_ACCUMULATION_MODE_SIGNED_NORMALIZED_INTEGER: return "Signed normalized integer"; default: return "XXX: INVALID"; } } enum mali_sample_layout { MALI_SAMPLE_LAYOUT_ORDERED_4X_GRID = 0, MALI_SAMPLE_LAYOUT_ROTATED_4X_GRID = 1, MALI_SAMPLE_LAYOUT_D3D_8X_GRID = 2, MALI_SAMPLE_LAYOUT_D3D_16X_GRID = 3, }; static inline const char * mali_sample_layout_as_str(enum mali_sample_layout imm) { switch (imm) { case MALI_SAMPLE_LAYOUT_ORDERED_4X_GRID: return "Ordered 4x Grid"; case MALI_SAMPLE_LAYOUT_ROTATED_4X_GRID: return "Rotated 4x Grid"; case MALI_SAMPLE_LAYOUT_D3D_8X_GRID: return "D3D 8x Grid"; case MALI_SAMPLE_LAYOUT_D3D_16X_GRID: return "D3D 16x Grid"; default: return "XXX: INVALID"; } } enum mali_zs_format { MALI_ZS_FORMAT_D16 = 1, MALI_ZS_FORMAT_D24 = 2, MALI_ZS_FORMAT_D24X8 = 4, MALI_ZS_FORMAT_D24S8 = 5, MALI_ZS_FORMAT_X8D24 = 6, MALI_ZS_FORMAT_S8D24 = 7, MALI_ZS_FORMAT_D32_X8X24 = 13, MALI_ZS_FORMAT_D32 = 14, MALI_ZS_FORMAT_D32_S8X24 = 15, }; static inline const char * mali_zs_format_as_str(enum mali_zs_format imm) { switch (imm) { case MALI_ZS_FORMAT_D16: return "D16"; case MALI_ZS_FORMAT_D24: return "D24"; case MALI_ZS_FORMAT_D24X8: return "D24X8"; case MALI_ZS_FORMAT_D24S8: return "D24S8"; case MALI_ZS_FORMAT_X8D24: return "X8D24"; case MALI_ZS_FORMAT_S8D24: return "S8D24"; case MALI_ZS_FORMAT_D32_X8X24: return "D32_X8X24"; case MALI_ZS_FORMAT_D32: return "D32"; case MALI_ZS_FORMAT_D32_S8X24: return "D32_S8X24"; default: return "XXX: INVALID"; } } enum mali_zs_preload_format { MALI_ZS_PRELOAD_FORMAT_D32_S8X24 = 4, }; static inline const char * mali_zs_preload_format_as_str(enum mali_zs_preload_format imm) { switch (imm) { case MALI_ZS_PRELOAD_FORMAT_D32_S8X24: return "D32_S8X24"; default: return "XXX: INVALID"; } } enum mali_s_format { MALI_S_FORMAT_S8 = 1, MALI_S_FORMAT_S8X8 = 2, MALI_S_FORMAT_S8X24 = 3, MALI_S_FORMAT_X24S8 = 4, MALI_S_FORMAT_X8S8 = 5, MALI_S_FORMAT_X32_S8X24 = 6, }; static inline const char * mali_s_format_as_str(enum mali_s_format imm) { switch (imm) { case MALI_S_FORMAT_S8: return "S8"; case MALI_S_FORMAT_S8X8: return "S8X8"; case MALI_S_FORMAT_S8X24: return "S8X24"; case MALI_S_FORMAT_X24S8: return "X24S8"; case MALI_S_FORMAT_X8S8: return "X8S8"; case MALI_S_FORMAT_X32_S8X24: return "X32_S8X24"; default: return "XXX: INVALID"; } } enum mali_tie_break_rule { MALI_TIE_BREAK_RULE_0_IN_180_OUT = 0, MALI_TIE_BREAK_RULE_0_OUT_180_IN = 1, MALI_TIE_BREAK_RULE_MINUS_180_IN_0_OUT = 2, MALI_TIE_BREAK_RULE_MINUS_180_OUT_0_IN = 3, MALI_TIE_BREAK_RULE_90_IN_270_OUT = 4, MALI_TIE_BREAK_RULE_90_OUT_270_IN = 5, MALI_TIE_BREAK_RULE_MINUS_90_IN_90_OUT = 6, MALI_TIE_BREAK_RULE_MINUS_90_OUT_90_IN = 7, }; static inline const char * mali_tie_break_rule_as_str(enum mali_tie_break_rule imm) { switch (imm) { case MALI_TIE_BREAK_RULE_0_IN_180_OUT: return "0_IN_180_OUT"; case MALI_TIE_BREAK_RULE_0_OUT_180_IN: return "0_OUT_180_IN"; case MALI_TIE_BREAK_RULE_MINUS_180_IN_0_OUT: return "MINUS_180_IN_0_OUT"; case MALI_TIE_BREAK_RULE_MINUS_180_OUT_0_IN: return "MINUS_180_OUT_0_IN"; case MALI_TIE_BREAK_RULE_90_IN_270_OUT: return "90_IN_270_OUT"; case MALI_TIE_BREAK_RULE_90_OUT_270_IN: return "90_OUT_270_IN"; case MALI_TIE_BREAK_RULE_MINUS_90_IN_90_OUT: return "MINUS_90_IN_90_OUT"; case MALI_TIE_BREAK_RULE_MINUS_90_OUT_90_IN: return "MINUS_90_OUT_90_IN"; default: return "XXX: INVALID"; } } struct MALI_RT_BUFFER { uint64_t base; uint32_t row_stride; uint32_t surface_stride; }; #define MALI_RT_BUFFER_header \ 0 static inline void MALI_RT_BUFFER_pack(uint32_t * restrict cl, const struct MALI_RT_BUFFER * restrict values) { cl[ 0] = __gen_uint(values->base, 0, 63); cl[ 1] = __gen_uint(values->base, 0, 63) >> 32; cl[ 2] = __gen_uint(values->row_stride, 0, 31); cl[ 3] = __gen_uint(values->surface_stride, 0, 31); } #define MALI_RT_BUFFER_LENGTH 16 struct mali_rt_buffer_packed { uint32_t opaque[4]; }; static inline void MALI_RT_BUFFER_unpack(const uint8_t * restrict cl, struct MALI_RT_BUFFER * restrict values) { values->base = __gen_unpack_uint(cl, 0, 63); values->row_stride = __gen_unpack_uint(cl, 64, 95); values->surface_stride = __gen_unpack_uint(cl, 96, 127); } static inline void MALI_RT_BUFFER_print(FILE *fp, const struct MALI_RT_BUFFER * values, unsigned indent) { fprintf(fp, "%*sBase: 0x%" PRIx64 "\n", indent, "", values->base); fprintf(fp, "%*sRow Stride: %u\n", indent, "", values->row_stride); fprintf(fp, "%*sSurface Stride: %u\n", indent, "", values->surface_stride); } enum mali_sample_pattern { MALI_SAMPLE_PATTERN_SINGLE_SAMPLED = 0, MALI_SAMPLE_PATTERN_ORDERED_4X_GRID = 1, MALI_SAMPLE_PATTERN_ROTATED_4X_GRID = 2, MALI_SAMPLE_PATTERN_D3D_8X_GRID = 3, MALI_SAMPLE_PATTERN_D3D_16X_GRID = 4, }; static inline const char * mali_sample_pattern_as_str(enum mali_sample_pattern imm) { switch (imm) { case MALI_SAMPLE_PATTERN_SINGLE_SAMPLED: return "Single-sampled"; case MALI_SAMPLE_PATTERN_ORDERED_4X_GRID: return "Ordered 4x Grid"; case MALI_SAMPLE_PATTERN_ROTATED_4X_GRID: return "Rotated 4x Grid"; case MALI_SAMPLE_PATTERN_D3D_8X_GRID: return "D3D 8x Grid"; case MALI_SAMPLE_PATTERN_D3D_16X_GRID: return "D3D 16x Grid"; default: return "XXX: INVALID"; } } enum mali_z_internal_format { MALI_Z_INTERNAL_FORMAT_D16 = 0, MALI_Z_INTERNAL_FORMAT_D24 = 1, MALI_Z_INTERNAL_FORMAT_D32 = 2, }; static inline const char * mali_z_internal_format_as_str(enum mali_z_internal_format imm) { switch (imm) { case MALI_Z_INTERNAL_FORMAT_D16: return "D16"; case MALI_Z_INTERNAL_FORMAT_D24: return "D24"; case MALI_Z_INTERNAL_FORMAT_D32: return "D32"; default: return "XXX: INVALID"; } } enum mali_fbd_tag { MALI_FBD_TAG_IS_MFBD = 1, MALI_FBD_TAG_HAS_ZS_RT = 2, MALI_FBD_TAG_MASK = 63, }; static inline const char * mali_fbd_tag_as_str(enum mali_fbd_tag imm) { switch (imm) { case MALI_FBD_TAG_IS_MFBD: return "IS_MFBD"; case MALI_FBD_TAG_HAS_ZS_RT: return "HAS_ZS_RT"; case MALI_FBD_TAG_MASK: return "MASK"; default: return "XXX: INVALID"; } } enum mali_pre_post_frame_shader_mode { MALI_PRE_POST_FRAME_SHADER_MODE_NEVER = 0, MALI_PRE_POST_FRAME_SHADER_MODE_ALWAYS = 1, MALI_PRE_POST_FRAME_SHADER_MODE_INTERSECT = 2, MALI_PRE_POST_FRAME_SHADER_MODE_EARLY_ZS_ALWAYS = 3, }; static inline const char * mali_pre_post_frame_shader_mode_as_str(enum mali_pre_post_frame_shader_mode imm) { switch (imm) { case MALI_PRE_POST_FRAME_SHADER_MODE_NEVER: return "Never"; case MALI_PRE_POST_FRAME_SHADER_MODE_ALWAYS: return "Always"; case MALI_PRE_POST_FRAME_SHADER_MODE_INTERSECT: return "Intersect"; case MALI_PRE_POST_FRAME_SHADER_MODE_EARLY_ZS_ALWAYS: return "Early ZS always"; default: return "XXX: INVALID"; } } struct MALI_FRAMEBUFFER_PARAMETERS { enum mali_pre_post_frame_shader_mode pre_frame_0; enum mali_pre_post_frame_shader_mode pre_frame_1; enum mali_pre_post_frame_shader_mode post_frame; uint64_t sample_locations; uint64_t frame_shader_dcds; uint32_t width; uint32_t height; uint32_t bound_min_x; uint32_t bound_min_y; uint32_t bound_max_x; uint32_t bound_max_y; uint32_t sample_count; enum mali_sample_pattern sample_pattern; enum mali_tie_break_rule tie_break_rule; uint32_t effective_tile_size; uint32_t x_downsampling_scale; uint32_t y_downsampling_scale; uint32_t render_target_count; uint32_t color_buffer_allocation; uint32_t s_clear; bool s_write_enable; bool s_preload_enable; bool s_unload_enable; enum mali_z_internal_format z_internal_format; bool z_write_enable; bool z_preload_enable; bool z_unload_enable; bool has_zs_crc_extension; bool crc_read_enable; bool crc_write_enable; float z_clear; uint64_t tiler; }; #define MALI_FRAMEBUFFER_PARAMETERS_header \ .sample_count = 1 static inline void MALI_FRAMEBUFFER_PARAMETERS_pack(uint32_t * restrict cl, const struct MALI_FRAMEBUFFER_PARAMETERS * restrict values) { assert(values->width >= 1); assert(values->height >= 1); assert(util_is_power_of_two_nonzero(values->sample_count)); assert(util_is_power_of_two_nonzero(values->effective_tile_size)); assert(values->render_target_count >= 1); assert((values->color_buffer_allocation & 0x3ff) == 0); cl[ 0] = __gen_uint(values->pre_frame_0, 0, 2) | __gen_uint(values->pre_frame_1, 3, 5) | __gen_uint(values->post_frame, 6, 8); cl[ 1] = 0; cl[ 2] = 0; cl[ 3] = 0; cl[ 4] = __gen_uint(values->sample_locations, 0, 63); cl[ 5] = __gen_uint(values->sample_locations, 0, 63) >> 32; cl[ 6] = __gen_uint(values->frame_shader_dcds, 0, 63); cl[ 7] = __gen_uint(values->frame_shader_dcds, 0, 63) >> 32; cl[ 8] = __gen_uint(values->width - 1, 0, 15) | __gen_uint(values->height - 1, 16, 31); cl[ 9] = __gen_uint(values->bound_min_x, 0, 15) | __gen_uint(values->bound_min_y, 16, 31); cl[10] = __gen_uint(values->bound_max_x, 0, 15) | __gen_uint(values->bound_max_y, 16, 31); cl[11] = __gen_uint(util_logbase2(values->sample_count), 0, 2) | __gen_uint(values->sample_pattern, 3, 5) | __gen_uint(values->tie_break_rule, 6, 8) | __gen_uint(util_logbase2(values->effective_tile_size), 9, 12) | __gen_uint(values->x_downsampling_scale, 13, 15) | __gen_uint(values->y_downsampling_scale, 16, 18) | __gen_uint(values->render_target_count - 1, 19, 22) | __gen_uint(values->color_buffer_allocation >> 10, 24, 31); cl[12] = __gen_uint(values->s_clear, 0, 7) | __gen_uint(values->s_write_enable, 8, 8) | __gen_uint(values->s_preload_enable, 9, 9) | __gen_uint(values->s_unload_enable, 10, 10) | __gen_uint(values->z_internal_format, 16, 17) | __gen_uint(values->z_write_enable, 18, 18) | __gen_uint(values->z_preload_enable, 19, 19) | __gen_uint(values->z_unload_enable, 20, 20) | __gen_uint(values->has_zs_crc_extension, 21, 21) | __gen_uint(values->crc_read_enable, 30, 30) | __gen_uint(values->crc_write_enable, 31, 31); cl[13] = __gen_uint(fui(values->z_clear), 0, 32); cl[14] = __gen_uint(values->tiler, 0, 63); cl[15] = __gen_uint(values->tiler, 0, 63) >> 32; } #define MALI_FRAMEBUFFER_PARAMETERS_LENGTH 64 struct mali_framebuffer_parameters_packed { uint32_t opaque[16]; }; static inline void MALI_FRAMEBUFFER_PARAMETERS_unpack(const uint8_t * restrict cl, struct MALI_FRAMEBUFFER_PARAMETERS * restrict values) { if (((const uint32_t *) cl)[0] & 0xfffffe00) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 3\n"); if (((const uint32_t *) cl)[11] & 0x800000) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 11\n"); if (((const uint32_t *) cl)[12] & 0x3fc0f800) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 12\n"); values->pre_frame_0 = (enum mali_pre_post_frame_shader_mode)__gen_unpack_uint(cl, 0, 2); values->pre_frame_1 = (enum mali_pre_post_frame_shader_mode)__gen_unpack_uint(cl, 3, 5); values->post_frame = (enum mali_pre_post_frame_shader_mode)__gen_unpack_uint(cl, 6, 8); values->sample_locations = __gen_unpack_uint(cl, 128, 191); values->frame_shader_dcds = __gen_unpack_uint(cl, 192, 255); values->width = __gen_unpack_uint(cl, 256, 271) + 1; values->height = __gen_unpack_uint(cl, 272, 287) + 1; values->bound_min_x = __gen_unpack_uint(cl, 288, 303); values->bound_min_y = __gen_unpack_uint(cl, 304, 319); values->bound_max_x = __gen_unpack_uint(cl, 320, 335); values->bound_max_y = __gen_unpack_uint(cl, 336, 351); values->sample_count = 1U << __gen_unpack_uint(cl, 352, 354); values->sample_pattern = (enum mali_sample_pattern)__gen_unpack_uint(cl, 355, 357); values->tie_break_rule = (enum mali_tie_break_rule)__gen_unpack_uint(cl, 358, 360); values->effective_tile_size = 1U << __gen_unpack_uint(cl, 361, 364); values->x_downsampling_scale = __gen_unpack_uint(cl, 365, 367); values->y_downsampling_scale = __gen_unpack_uint(cl, 368, 370); values->render_target_count = __gen_unpack_uint(cl, 371, 374) + 1; values->color_buffer_allocation = __gen_unpack_uint(cl, 376, 383) << 10; values->s_clear = __gen_unpack_uint(cl, 384, 391); values->s_write_enable = __gen_unpack_uint(cl, 392, 392); values->s_preload_enable = __gen_unpack_uint(cl, 393, 393); values->s_unload_enable = __gen_unpack_uint(cl, 394, 394); values->z_internal_format = (enum mali_z_internal_format)__gen_unpack_uint(cl, 400, 401); values->z_write_enable = __gen_unpack_uint(cl, 402, 402); values->z_preload_enable = __gen_unpack_uint(cl, 403, 403); values->z_unload_enable = __gen_unpack_uint(cl, 404, 404); values->has_zs_crc_extension = __gen_unpack_uint(cl, 405, 405); values->crc_read_enable = __gen_unpack_uint(cl, 414, 414); values->crc_write_enable = __gen_unpack_uint(cl, 415, 415); values->z_clear = __gen_unpack_float(cl, 416, 447); values->tiler = __gen_unpack_uint(cl, 448, 511); } static inline void MALI_FRAMEBUFFER_PARAMETERS_print(FILE *fp, const struct MALI_FRAMEBUFFER_PARAMETERS * values, unsigned indent) { fprintf(fp, "%*sPre Frame 0: %s\n", indent, "", mali_pre_post_frame_shader_mode_as_str(values->pre_frame_0)); fprintf(fp, "%*sPre Frame 1: %s\n", indent, "", mali_pre_post_frame_shader_mode_as_str(values->pre_frame_1)); fprintf(fp, "%*sPost Frame: %s\n", indent, "", mali_pre_post_frame_shader_mode_as_str(values->post_frame)); fprintf(fp, "%*sSample Locations: 0x%" PRIx64 "\n", indent, "", values->sample_locations); fprintf(fp, "%*sFrame Shader DCDs: 0x%" PRIx64 "\n", indent, "", values->frame_shader_dcds); fprintf(fp, "%*sWidth: %u\n", indent, "", values->width); fprintf(fp, "%*sHeight: %u\n", indent, "", values->height); fprintf(fp, "%*sBound Min X: %u\n", indent, "", values->bound_min_x); fprintf(fp, "%*sBound Min Y: %u\n", indent, "", values->bound_min_y); fprintf(fp, "%*sBound Max X: %u\n", indent, "", values->bound_max_x); fprintf(fp, "%*sBound Max Y: %u\n", indent, "", values->bound_max_y); fprintf(fp, "%*sSample Count: %u\n", indent, "", values->sample_count); fprintf(fp, "%*sSample Pattern: %s\n", indent, "", mali_sample_pattern_as_str(values->sample_pattern)); fprintf(fp, "%*sTie-Break Rule: %s\n", indent, "", mali_tie_break_rule_as_str(values->tie_break_rule)); fprintf(fp, "%*sEffective Tile Size: %u\n", indent, "", values->effective_tile_size); fprintf(fp, "%*sX Downsampling Scale: %u\n", indent, "", values->x_downsampling_scale); fprintf(fp, "%*sY Downsampling Scale: %u\n", indent, "", values->y_downsampling_scale); fprintf(fp, "%*sRender Target Count: %u\n", indent, "", values->render_target_count); fprintf(fp, "%*sColor Buffer Allocation: %u\n", indent, "", values->color_buffer_allocation); fprintf(fp, "%*sS Clear: %u\n", indent, "", values->s_clear); fprintf(fp, "%*sS Write Enable: %s\n", indent, "", values->s_write_enable ? "true" : "false"); fprintf(fp, "%*sS Preload Enable: %s\n", indent, "", values->s_preload_enable ? "true" : "false"); fprintf(fp, "%*sS Unload Enable: %s\n", indent, "", values->s_unload_enable ? "true" : "false"); fprintf(fp, "%*sZ Internal Format: %s\n", indent, "", mali_z_internal_format_as_str(values->z_internal_format)); fprintf(fp, "%*sZ Write Enable: %s\n", indent, "", values->z_write_enable ? "true" : "false"); fprintf(fp, "%*sZ Preload Enable: %s\n", indent, "", values->z_preload_enable ? "true" : "false"); fprintf(fp, "%*sZ Unload Enable: %s\n", indent, "", values->z_unload_enable ? "true" : "false"); fprintf(fp, "%*sHas ZS CRC Extension: %s\n", indent, "", values->has_zs_crc_extension ? "true" : "false"); fprintf(fp, "%*sCRC Read Enable: %s\n", indent, "", values->crc_read_enable ? "true" : "false"); fprintf(fp, "%*sCRC Write Enable: %s\n", indent, "", values->crc_write_enable ? "true" : "false"); fprintf(fp, "%*sZ Clear: %f\n", indent, "", values->z_clear); fprintf(fp, "%*sTiler: 0x%" PRIx64 "\n", indent, "", values->tiler); } struct MALI_ZS_CRC_EXTENSION { uint64_t crc_base; uint32_t crc_row_stride; enum mali_zs_format zs_write_format; enum mali_block_format zs_block_format; enum mali_msaa zs_msaa; bool zs_big_endian; bool zs_clean_pixel_write_enable; enum mali_s_format s_write_format; enum mali_block_format s_block_format; enum mali_msaa s_msaa; uint64_t zs_writeback_base; uint32_t zs_writeback_row_stride; uint32_t zs_writeback_surface_stride; uint64_t s_writeback_base; uint32_t s_writeback_row_stride; uint32_t s_writeback_surface_stride; uint64_t zs_afbc_header; uint32_t zs_afbc_row_stride; uint64_t zs_afbc_body; }; #define MALI_ZS_CRC_EXTENSION_header \ .zs_msaa = MALI_MSAA_SINGLE, \ .s_msaa = MALI_MSAA_SINGLE static inline void MALI_ZS_CRC_EXTENSION_pack(uint32_t * restrict cl, const struct MALI_ZS_CRC_EXTENSION * restrict values) { cl[ 0] = __gen_uint(values->crc_base, 0, 63); cl[ 1] = __gen_uint(values->crc_base, 0, 63) >> 32; cl[ 2] = __gen_uint(values->crc_row_stride, 0, 31); cl[ 3] = __gen_uint(values->zs_write_format, 0, 3) | __gen_uint(values->zs_block_format, 4, 5) | __gen_uint(values->zs_msaa, 6, 7) | __gen_uint(values->zs_big_endian, 8, 8) | __gen_uint(values->zs_clean_pixel_write_enable, 10, 10) | __gen_uint(values->s_write_format, 16, 19) | __gen_uint(values->s_block_format, 20, 21) | __gen_uint(values->s_msaa, 22, 23); cl[ 4] = __gen_uint(values->zs_writeback_base, 0, 63) | __gen_uint(values->zs_afbc_header, 0, 63); cl[ 5] = __gen_uint(values->zs_writeback_base, 0, 63) >> 32 | __gen_uint(values->zs_afbc_header, 0, 63) >> 32; cl[ 6] = __gen_uint(values->zs_writeback_row_stride, 0, 31) | __gen_uint(values->zs_afbc_row_stride, 0, 12); cl[ 7] = __gen_uint(values->zs_writeback_surface_stride, 0, 31); cl[ 8] = __gen_uint(values->s_writeback_base, 0, 63) | __gen_uint(values->zs_afbc_body, 0, 63); cl[ 9] = __gen_uint(values->s_writeback_base, 0, 63) >> 32 | __gen_uint(values->zs_afbc_body, 0, 63) >> 32; cl[10] = __gen_uint(values->s_writeback_row_stride, 0, 31); cl[11] = __gen_uint(values->s_writeback_surface_stride, 0, 31); cl[12] = 0; cl[13] = 0; cl[14] = 0; cl[15] = 0; } #define MALI_ZS_CRC_EXTENSION_LENGTH 64 #define MALI_ZS_CRC_EXTENSION_ALIGN 64 struct mali_zs_crc_extension_packed { uint32_t opaque[16]; }; static inline void MALI_ZS_CRC_EXTENSION_unpack(const uint8_t * restrict cl, struct MALI_ZS_CRC_EXTENSION * restrict values) { if (((const uint32_t *) cl)[3] & 0xff00fa00) fprintf(stderr, "XXX: Invalid field of ZS CRC Extension unpacked at word 3\n"); if (((const uint32_t *) cl)[12] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of ZS CRC Extension unpacked at word 12\n"); if (((const uint32_t *) cl)[13] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of ZS CRC Extension unpacked at word 13\n"); if (((const uint32_t *) cl)[14] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of ZS CRC Extension unpacked at word 14\n"); if (((const uint32_t *) cl)[15] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of ZS CRC Extension unpacked at word 15\n"); values->crc_base = __gen_unpack_uint(cl, 0, 63); values->crc_row_stride = __gen_unpack_uint(cl, 64, 95); values->zs_write_format = (enum mali_zs_format)__gen_unpack_uint(cl, 96, 99); values->zs_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 100, 101); values->zs_msaa = (enum mali_msaa)__gen_unpack_uint(cl, 102, 103); values->zs_big_endian = __gen_unpack_uint(cl, 104, 104); values->zs_clean_pixel_write_enable = __gen_unpack_uint(cl, 106, 106); values->s_write_format = (enum mali_s_format)__gen_unpack_uint(cl, 112, 115); values->s_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 116, 117); values->s_msaa = (enum mali_msaa)__gen_unpack_uint(cl, 118, 119); values->zs_writeback_base = __gen_unpack_uint(cl, 128, 191); values->zs_writeback_row_stride = __gen_unpack_uint(cl, 192, 223); values->zs_writeback_surface_stride = __gen_unpack_uint(cl, 224, 255); values->s_writeback_base = __gen_unpack_uint(cl, 256, 319); values->s_writeback_row_stride = __gen_unpack_uint(cl, 320, 351); values->s_writeback_surface_stride = __gen_unpack_uint(cl, 352, 383); values->zs_afbc_header = __gen_unpack_uint(cl, 128, 191); values->zs_afbc_row_stride = __gen_unpack_uint(cl, 192, 204); values->zs_afbc_body = __gen_unpack_uint(cl, 256, 319); } static inline void MALI_ZS_CRC_EXTENSION_print(FILE *fp, const struct MALI_ZS_CRC_EXTENSION * values, unsigned indent) { fprintf(fp, "%*sCRC Base: 0x%" PRIx64 "\n", indent, "", values->crc_base); fprintf(fp, "%*sCRC Row Stride: %u\n", indent, "", values->crc_row_stride); fprintf(fp, "%*sZS Write Format: %s\n", indent, "", mali_zs_format_as_str(values->zs_write_format)); fprintf(fp, "%*sZS Block Format: %s\n", indent, "", mali_block_format_as_str(values->zs_block_format)); fprintf(fp, "%*sZS MSAA: %s\n", indent, "", mali_msaa_as_str(values->zs_msaa)); fprintf(fp, "%*sZS Big Endian: %s\n", indent, "", values->zs_big_endian ? "true" : "false"); fprintf(fp, "%*sZS Clean Pixel Write Enable: %s\n", indent, "", values->zs_clean_pixel_write_enable ? "true" : "false"); fprintf(fp, "%*sS Write Format: %s\n", indent, "", mali_s_format_as_str(values->s_write_format)); fprintf(fp, "%*sS Block Format: %s\n", indent, "", mali_block_format_as_str(values->s_block_format)); fprintf(fp, "%*sS MSAA: %s\n", indent, "", mali_msaa_as_str(values->s_msaa)); fprintf(fp, "%*sZS Writeback Base: 0x%" PRIx64 "\n", indent, "", values->zs_writeback_base); fprintf(fp, "%*sZS Writeback Row Stride: %u\n", indent, "", values->zs_writeback_row_stride); fprintf(fp, "%*sZS Writeback Surface Stride: %u\n", indent, "", values->zs_writeback_surface_stride); fprintf(fp, "%*sS Writeback Base: 0x%" PRIx64 "\n", indent, "", values->s_writeback_base); fprintf(fp, "%*sS Writeback Row Stride: %u\n", indent, "", values->s_writeback_row_stride); fprintf(fp, "%*sS Writeback Surface Stride: %u\n", indent, "", values->s_writeback_surface_stride); fprintf(fp, "%*sZS AFBC Header: 0x%" PRIx64 "\n", indent, "", values->zs_afbc_header); fprintf(fp, "%*sZS AFBC Row Stride: %u\n", indent, "", values->zs_afbc_row_stride); fprintf(fp, "%*sZS AFBC Body: 0x%" PRIx64 "\n", indent, "", values->zs_afbc_body); } enum mali_rt_endianness { MALI_RT_ENDIANNESS_LITTLE_ENDIAN = 0, MALI_RT_ENDIANNESS_BIG_ENDIAN_2B = 1, MALI_RT_ENDIANNESS_BIG_ENDIAN_4B = 2, MALI_RT_ENDIANNESS_BIG_ENDIAN_8B = 3, }; static inline const char * mali_rt_endianness_as_str(enum mali_rt_endianness imm) { switch (imm) { case MALI_RT_ENDIANNESS_LITTLE_ENDIAN: return "Little Endian"; case MALI_RT_ENDIANNESS_BIG_ENDIAN_2B: return "Big Endian 2B"; case MALI_RT_ENDIANNESS_BIG_ENDIAN_4B: return "Big Endian 4B"; case MALI_RT_ENDIANNESS_BIG_ENDIAN_8B: return "Big Endian 8B"; default: return "XXX: INVALID"; } } enum mali_yuv_conv_k6 { MALI_YUV_CONV_K6_0 = 0, MALI_YUV_CONV_K6_16 = 1, }; static inline const char * mali_yuv_conv_k6_as_str(enum mali_yuv_conv_k6 imm) { switch (imm) { case MALI_YUV_CONV_K6_0: return "0"; case MALI_YUV_CONV_K6_16: return "16"; default: return "XXX: INVALID"; } } enum mali_yuv_conv_k7_clamp { MALI_YUV_CONV_K7_CLAMP_MINUS_128_TO_127 = 0, MALI_YUV_CONV_K7_CLAMP_MINUS_112_TO_111 = 1, MALI_YUV_CONV_K7_CLAMP_0_TO_255 = 2, MALI_YUV_CONV_K7_CLAMP_16_TO_239 = 3, }; static inline const char * mali_yuv_conv_k7_clamp_as_str(enum mali_yuv_conv_k7_clamp imm) { switch (imm) { case MALI_YUV_CONV_K7_CLAMP_MINUS_128_TO_127: return "MINUS_128_TO_127"; case MALI_YUV_CONV_K7_CLAMP_MINUS_112_TO_111: return "MINUS_112_TO_111"; case MALI_YUV_CONV_K7_CLAMP_0_TO_255: return "0_TO_255"; case MALI_YUV_CONV_K7_CLAMP_16_TO_239: return "16_TO_239"; default: return "XXX: INVALID"; } } enum mali_yuv_conv_k8 { MALI_YUV_CONV_K8_220 = 0, MALI_YUV_CONV_K8_256 = 1, }; static inline const char * mali_yuv_conv_k8_as_str(enum mali_yuv_conv_k8 imm) { switch (imm) { case MALI_YUV_CONV_K8_220: return "220"; case MALI_YUV_CONV_K8_256: return "256"; default: return "XXX: INVALID"; } } struct MALI_RENDER_TARGET_YUV_OVERLAY { enum mali_yuv_swizzle swizzle; bool full_range; enum mali_yuv_conversion_mode conversion_mode; enum mali_yuv_cr_siting cr_siting; bool unsigned_cr_range; uint64_t plane_0_base; uint64_t plane_1_base; uint64_t plane_2_base; uint32_t plane_0_stride; uint32_t plane_1_2_stride; }; #define MALI_RENDER_TARGET_YUV_OVERLAY_header \ 0 static inline void MALI_RENDER_TARGET_YUV_OVERLAY_pack(uint32_t * restrict cl, const struct MALI_RENDER_TARGET_YUV_OVERLAY * restrict values) { cl[ 0] = 0; cl[ 1] = 0; cl[ 2] = __gen_uint(values->swizzle, 16, 18) | __gen_uint(values->full_range, 20, 20) | __gen_uint(values->conversion_mode, 21, 24) | __gen_uint(values->cr_siting, 25, 27) | __gen_uint(values->unsigned_cr_range, 28, 28); cl[ 3] = 0; cl[ 4] = __gen_uint(values->plane_0_base, 0, 63); cl[ 5] = __gen_uint(values->plane_0_base, 0, 63) >> 32; cl[ 6] = __gen_uint(values->plane_1_base, 0, 63); cl[ 7] = __gen_uint(values->plane_1_base, 0, 63) >> 32; cl[ 8] = __gen_uint(values->plane_2_base, 0, 63); cl[ 9] = __gen_uint(values->plane_2_base, 0, 63) >> 32; cl[10] = __gen_uint(values->plane_0_stride, 0, 31); cl[11] = __gen_uint(values->plane_1_2_stride, 0, 31); cl[12] = 0; cl[13] = 0; cl[14] = 0; cl[15] = 0; } #define MALI_RENDER_TARGET_YUV_OVERLAY_LENGTH 64 struct mali_render_target_yuv_overlay_packed { uint32_t opaque[16]; }; static inline void MALI_RENDER_TARGET_YUV_OVERLAY_unpack(const uint8_t * restrict cl, struct MALI_RENDER_TARGET_YUV_OVERLAY * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xe008ffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 3\n"); if (((const uint32_t *) cl)[12] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 12\n"); if (((const uint32_t *) cl)[13] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 13\n"); if (((const uint32_t *) cl)[14] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 14\n"); if (((const uint32_t *) cl)[15] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target YUV Overlay unpacked at word 15\n"); values->swizzle = (enum mali_yuv_swizzle)__gen_unpack_uint(cl, 80, 82); values->full_range = __gen_unpack_uint(cl, 84, 84); values->conversion_mode = (enum mali_yuv_conversion_mode)__gen_unpack_uint(cl, 85, 88); values->cr_siting = (enum mali_yuv_cr_siting)__gen_unpack_uint(cl, 89, 91); values->unsigned_cr_range = __gen_unpack_uint(cl, 92, 92); values->plane_0_base = __gen_unpack_uint(cl, 128, 191); values->plane_1_base = __gen_unpack_uint(cl, 192, 255); values->plane_2_base = __gen_unpack_uint(cl, 256, 319); values->plane_0_stride = __gen_unpack_uint(cl, 320, 351); values->plane_1_2_stride = __gen_unpack_uint(cl, 352, 383); } static inline void MALI_RENDER_TARGET_YUV_OVERLAY_print(FILE *fp, const struct MALI_RENDER_TARGET_YUV_OVERLAY * values, unsigned indent) { fprintf(fp, "%*sSwizzle: %s\n", indent, "", mali_yuv_swizzle_as_str(values->swizzle)); fprintf(fp, "%*sFull Range: %s\n", indent, "", values->full_range ? "true" : "false"); fprintf(fp, "%*sConversion Mode: %s\n", indent, "", mali_yuv_conversion_mode_as_str(values->conversion_mode)); fprintf(fp, "%*sCr Siting: %s\n", indent, "", mali_yuv_cr_siting_as_str(values->cr_siting)); fprintf(fp, "%*sUnsigned Cr Range: %s\n", indent, "", values->unsigned_cr_range ? "true" : "false"); fprintf(fp, "%*sPlane 0 Base: 0x%" PRIx64 "\n", indent, "", values->plane_0_base); fprintf(fp, "%*sPlane 1 Base: 0x%" PRIx64 "\n", indent, "", values->plane_1_base); fprintf(fp, "%*sPlane 2 Base: 0x%" PRIx64 "\n", indent, "", values->plane_2_base); fprintf(fp, "%*sPlane 0 Stride: %u\n", indent, "", values->plane_0_stride); fprintf(fp, "%*sPlane 1 2 Stride: %u\n", indent, "", values->plane_1_2_stride); } struct MALI_RENDER_TARGET_AFBC_OVERLAY { uint64_t header; uint32_t row_stride; uint32_t chunk_size; bool afbc_split_block_enable; bool afbc_wide_block_enable; bool reverse_issue_order; bool yuv_transform_enable; uint64_t body; uint32_t body_size; }; #define MALI_RENDER_TARGET_AFBC_OVERLAY_header \ 0 static inline void MALI_RENDER_TARGET_AFBC_OVERLAY_pack(uint32_t * restrict cl, const struct MALI_RENDER_TARGET_AFBC_OVERLAY * restrict values) { cl[ 0] = 0; cl[ 1] = 0; cl[ 2] = 0; cl[ 3] = 0; cl[ 4] = __gen_uint(values->header, 0, 63); cl[ 5] = __gen_uint(values->header, 0, 63) >> 32; cl[ 6] = __gen_uint(values->row_stride, 0, 12); cl[ 7] = __gen_uint(values->chunk_size, 0, 11) | __gen_uint(values->afbc_split_block_enable, 18, 18) | __gen_uint(values->afbc_wide_block_enable, 19, 19) | __gen_uint(values->reverse_issue_order, 20, 20) | __gen_uint(values->yuv_transform_enable, 17, 17); cl[ 8] = __gen_uint(values->body, 0, 63); cl[ 9] = __gen_uint(values->body, 0, 63) >> 32; cl[10] = __gen_uint(values->body_size, 0, 31); cl[11] = 0; cl[12] = 0; cl[13] = 0; cl[14] = 0; cl[15] = 0; } #define MALI_RENDER_TARGET_AFBC_OVERLAY_LENGTH 64 struct mali_render_target_afbc_overlay_packed { uint32_t opaque[16]; }; static inline void MALI_RENDER_TARGET_AFBC_OVERLAY_unpack(const uint8_t * restrict cl, struct MALI_RENDER_TARGET_AFBC_OVERLAY * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 3\n"); if (((const uint32_t *) cl)[6] & 0xffffe000) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffe1f000) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 7\n"); if (((const uint32_t *) cl)[11] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 11\n"); if (((const uint32_t *) cl)[12] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 12\n"); if (((const uint32_t *) cl)[13] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 13\n"); if (((const uint32_t *) cl)[14] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 14\n"); if (((const uint32_t *) cl)[15] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target AFBC Overlay unpacked at word 15\n"); values->header = __gen_unpack_uint(cl, 128, 191); values->row_stride = __gen_unpack_uint(cl, 192, 204); values->chunk_size = __gen_unpack_uint(cl, 224, 235); values->afbc_split_block_enable = __gen_unpack_uint(cl, 242, 242); values->afbc_wide_block_enable = __gen_unpack_uint(cl, 243, 243); values->reverse_issue_order = __gen_unpack_uint(cl, 244, 244); values->yuv_transform_enable = __gen_unpack_uint(cl, 241, 241); values->body = __gen_unpack_uint(cl, 256, 319); values->body_size = __gen_unpack_uint(cl, 320, 351); } static inline void MALI_RENDER_TARGET_AFBC_OVERLAY_print(FILE *fp, const struct MALI_RENDER_TARGET_AFBC_OVERLAY * values, unsigned indent) { fprintf(fp, "%*sHeader: 0x%" PRIx64 "\n", indent, "", values->header); fprintf(fp, "%*sRow Stride: %u\n", indent, "", values->row_stride); fprintf(fp, "%*sChunk Size: %u\n", indent, "", values->chunk_size); fprintf(fp, "%*sAFBC Split Block Enable: %s\n", indent, "", values->afbc_split_block_enable ? "true" : "false"); fprintf(fp, "%*sAFBC Wide Block Enable: %s\n", indent, "", values->afbc_wide_block_enable ? "true" : "false"); fprintf(fp, "%*sReverse Issue Order: %s\n", indent, "", values->reverse_issue_order ? "true" : "false"); fprintf(fp, "%*sYUV Transform Enable: %s\n", indent, "", values->yuv_transform_enable ? "true" : "false"); fprintf(fp, "%*sBody: 0x%" PRIx64 "\n", indent, "", values->body); fprintf(fp, "%*sBody Size: %u\n", indent, "", values->body_size); } struct MALI_RT_CLEAR { uint32_t color_0; uint32_t color_1; uint32_t color_2; uint32_t color_3; }; #define MALI_RT_CLEAR_header \ 0 static inline void MALI_RT_CLEAR_pack(uint32_t * restrict cl, const struct MALI_RT_CLEAR * restrict values) { cl[ 0] = __gen_uint(values->color_0, 0, 31); cl[ 1] = __gen_uint(values->color_1, 0, 31); cl[ 2] = __gen_uint(values->color_2, 0, 31); cl[ 3] = __gen_uint(values->color_3, 0, 31); } #define MALI_RT_CLEAR_LENGTH 16 struct mali_rt_clear_packed { uint32_t opaque[4]; }; static inline void MALI_RT_CLEAR_unpack(const uint8_t * restrict cl, struct MALI_RT_CLEAR * restrict values) { values->color_0 = __gen_unpack_uint(cl, 0, 31); values->color_1 = __gen_unpack_uint(cl, 32, 63); values->color_2 = __gen_unpack_uint(cl, 64, 95); values->color_3 = __gen_unpack_uint(cl, 96, 127); } static inline void MALI_RT_CLEAR_print(FILE *fp, const struct MALI_RT_CLEAR * values, unsigned indent) { fprintf(fp, "%*sColor 0: %u\n", indent, "", values->color_0); fprintf(fp, "%*sColor 1: %u\n", indent, "", values->color_1); fprintf(fp, "%*sColor 2: %u\n", indent, "", values->color_2); fprintf(fp, "%*sColor 3: %u\n", indent, "", values->color_3); } struct MALI_RENDER_TARGET { struct MALI_RENDER_TARGET_YUV_OVERLAY yuv; struct MALI_RENDER_TARGET_AFBC_OVERLAY afbc; uint32_t internal_buffer_offset; bool yuv_enable; bool dithered_clear; enum mali_color_buffer_internal_format internal_format; bool write_enable; enum mali_color_format writeback_format; enum mali_rt_endianness writeback_endianness; enum mali_block_format writeback_block_format; enum mali_msaa writeback_msaa; bool srgb; bool dithering_enable; uint32_t swizzle; bool clean_pixel_write_enable; struct MALI_RT_BUFFER rgb; struct MALI_RT_CLEAR clear; }; #define MALI_RENDER_TARGET_header \ .yuv = { MALI_RENDER_TARGET_YUV_OVERLAY_header }, \ .afbc = { MALI_RENDER_TARGET_AFBC_OVERLAY_header }, \ .rgb = { MALI_RT_BUFFER_header }, \ .clear = { MALI_RT_CLEAR_header } static inline void MALI_RENDER_TARGET_pack(uint32_t * restrict cl, const struct MALI_RENDER_TARGET * restrict values) { assert((values->internal_buffer_offset & 0xf) == 0); cl[ 0] = __gen_uint(values->internal_buffer_offset >> 4, 4, 15) | __gen_uint(values->yuv_enable, 24, 24) | __gen_uint(values->dithered_clear, 25, 25) | __gen_uint(values->internal_format, 26, 31); cl[ 1] = __gen_uint(values->write_enable, 0, 0) | __gen_uint(values->writeback_format, 3, 7) | __gen_uint(values->writeback_endianness, 8, 9) | __gen_uint(values->writeback_block_format, 10, 11) | __gen_uint(values->writeback_msaa, 12, 13) | __gen_uint(values->srgb, 14, 14) | __gen_uint(values->dithering_enable, 15, 15) | __gen_uint(values->swizzle, 16, 27) | __gen_uint(values->clean_pixel_write_enable, 31, 31); cl[ 2] = __gen_uint(values->yuv.swizzle, 16, 18) | __gen_uint(values->yuv.full_range, 20, 20) | __gen_uint(values->yuv.conversion_mode, 21, 24) | __gen_uint(values->yuv.cr_siting, 25, 27) | __gen_uint(values->yuv.unsigned_cr_range, 28, 28); cl[ 3] = 0; cl[ 4] = __gen_uint(values->yuv.plane_0_base, 0, 63) | __gen_uint(values->afbc.header, 0, 63); cl[ 5] = __gen_uint(values->yuv.plane_0_base, 0, 63) >> 32 | __gen_uint(values->afbc.header, 0, 63) >> 32; cl[ 6] = __gen_uint(values->yuv.plane_1_base, 0, 63) | __gen_uint(values->afbc.row_stride, 0, 12); cl[ 7] = __gen_uint(values->yuv.plane_1_base, 0, 63) >> 32 | __gen_uint(values->afbc.chunk_size, 0, 11) | __gen_uint(values->afbc.afbc_split_block_enable, 18, 18) | __gen_uint(values->afbc.afbc_wide_block_enable, 19, 19) | __gen_uint(values->afbc.reverse_issue_order, 20, 20) | __gen_uint(values->afbc.yuv_transform_enable, 17, 17); cl[ 8] = __gen_uint(values->yuv.plane_2_base, 0, 63) | __gen_uint(values->afbc.body, 0, 63) | __gen_uint(values->rgb.base, 0, 63); cl[ 9] = __gen_uint(values->yuv.plane_2_base, 0, 63) >> 32 | __gen_uint(values->afbc.body, 0, 63) >> 32 | __gen_uint(values->rgb.base, 0, 63) >> 32; cl[10] = __gen_uint(values->yuv.plane_0_stride, 0, 31) | __gen_uint(values->afbc.body_size, 0, 31) | __gen_uint(values->rgb.row_stride, 0, 31); cl[11] = __gen_uint(values->yuv.plane_1_2_stride, 0, 31) | __gen_uint(values->rgb.surface_stride, 0, 31); cl[12] = __gen_uint(values->clear.color_0, 0, 31); cl[13] = __gen_uint(values->clear.color_1, 0, 31); cl[14] = __gen_uint(values->clear.color_2, 0, 31); cl[15] = __gen_uint(values->clear.color_3, 0, 31); } #define MALI_RENDER_TARGET_LENGTH 64 #define MALI_RENDER_TARGET_ALIGN 64 struct mali_render_target_packed { uint32_t opaque[16]; }; static inline void MALI_RENDER_TARGET_unpack(const uint8_t * restrict cl, struct MALI_RENDER_TARGET * restrict values) { if (((const uint32_t *) cl)[0] & 0xff000f) fprintf(stderr, "XXX: Invalid field of Render Target unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0x70000006) fprintf(stderr, "XXX: Invalid field of Render Target unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xe008ffff) fprintf(stderr, "XXX: Invalid field of Render Target unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Render Target unpacked at word 3\n"); values->yuv.swizzle = (enum mali_yuv_swizzle)__gen_unpack_uint(cl, 80, 82); values->yuv.full_range = __gen_unpack_uint(cl, 84, 84); values->yuv.conversion_mode = (enum mali_yuv_conversion_mode)__gen_unpack_uint(cl, 85, 88); values->yuv.cr_siting = (enum mali_yuv_cr_siting)__gen_unpack_uint(cl, 89, 91); values->yuv.unsigned_cr_range = __gen_unpack_uint(cl, 92, 92); values->yuv.plane_0_base = __gen_unpack_uint(cl, 128, 191); values->yuv.plane_1_base = __gen_unpack_uint(cl, 192, 255); values->yuv.plane_2_base = __gen_unpack_uint(cl, 256, 319); values->yuv.plane_0_stride = __gen_unpack_uint(cl, 320, 351); values->yuv.plane_1_2_stride = __gen_unpack_uint(cl, 352, 383); values->afbc.header = __gen_unpack_uint(cl, 128, 191); values->afbc.row_stride = __gen_unpack_uint(cl, 192, 204); values->afbc.chunk_size = __gen_unpack_uint(cl, 224, 235); values->afbc.afbc_split_block_enable = __gen_unpack_uint(cl, 242, 242); values->afbc.afbc_wide_block_enable = __gen_unpack_uint(cl, 243, 243); values->afbc.reverse_issue_order = __gen_unpack_uint(cl, 244, 244); values->afbc.yuv_transform_enable = __gen_unpack_uint(cl, 241, 241); values->afbc.body = __gen_unpack_uint(cl, 256, 319); values->afbc.body_size = __gen_unpack_uint(cl, 320, 351); values->internal_buffer_offset = __gen_unpack_uint(cl, 4, 15) << 4; values->yuv_enable = __gen_unpack_uint(cl, 24, 24); values->dithered_clear = __gen_unpack_uint(cl, 25, 25); values->internal_format = (enum mali_color_buffer_internal_format)__gen_unpack_uint(cl, 26, 31); values->write_enable = __gen_unpack_uint(cl, 32, 32); values->writeback_format = (enum mali_color_format)__gen_unpack_uint(cl, 35, 39); values->writeback_endianness = (enum mali_rt_endianness)__gen_unpack_uint(cl, 40, 41); values->writeback_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 42, 43); values->writeback_msaa = (enum mali_msaa)__gen_unpack_uint(cl, 44, 45); values->srgb = __gen_unpack_uint(cl, 46, 46); values->dithering_enable = __gen_unpack_uint(cl, 47, 47); values->swizzle = __gen_unpack_uint(cl, 48, 59); values->clean_pixel_write_enable = __gen_unpack_uint(cl, 63, 63); values->rgb.base = __gen_unpack_uint(cl, 256, 319); values->rgb.row_stride = __gen_unpack_uint(cl, 320, 351); values->rgb.surface_stride = __gen_unpack_uint(cl, 352, 383); values->clear.color_0 = __gen_unpack_uint(cl, 384, 415); values->clear.color_1 = __gen_unpack_uint(cl, 416, 447); values->clear.color_2 = __gen_unpack_uint(cl, 448, 479); values->clear.color_3 = __gen_unpack_uint(cl, 480, 511); } static inline void MALI_RENDER_TARGET_print(FILE *fp, const struct MALI_RENDER_TARGET * values, unsigned indent) { fprintf(fp, "%*sYUV:\n", indent, ""); MALI_RENDER_TARGET_YUV_OVERLAY_print(fp, &values->yuv, indent + 2); fprintf(fp, "%*sAFBC:\n", indent, ""); MALI_RENDER_TARGET_AFBC_OVERLAY_print(fp, &values->afbc, indent + 2); fprintf(fp, "%*sInternal Buffer Offset: %u\n", indent, "", values->internal_buffer_offset); fprintf(fp, "%*sYUV Enable: %s\n", indent, "", values->yuv_enable ? "true" : "false"); fprintf(fp, "%*sDithered Clear: %s\n", indent, "", values->dithered_clear ? "true" : "false"); fprintf(fp, "%*sInternal Format: %s\n", indent, "", mali_color_buffer_internal_format_as_str(values->internal_format)); fprintf(fp, "%*sWrite Enable: %s\n", indent, "", values->write_enable ? "true" : "false"); fprintf(fp, "%*sWriteback Format: %s\n", indent, "", mali_color_format_as_str(values->writeback_format)); fprintf(fp, "%*sWriteback Endianness: %s\n", indent, "", mali_rt_endianness_as_str(values->writeback_endianness)); fprintf(fp, "%*sWriteback Block Format: %s\n", indent, "", mali_block_format_as_str(values->writeback_block_format)); fprintf(fp, "%*sWriteback MSAA: %s\n", indent, "", mali_msaa_as_str(values->writeback_msaa)); fprintf(fp, "%*ssRGB: %s\n", indent, "", values->srgb ? "true" : "false"); fprintf(fp, "%*sDithering Enable: %s\n", indent, "", values->dithering_enable ? "true" : "false"); fprintf(fp, "%*sSwizzle: %u\n", indent, "", values->swizzle); fprintf(fp, "%*sClean Pixel Write Enable: %s\n", indent, "", values->clean_pixel_write_enable ? "true" : "false"); fprintf(fp, "%*sRGB:\n", indent, ""); MALI_RT_BUFFER_print(fp, &values->rgb, indent + 2); fprintf(fp, "%*sClear:\n", indent, ""); MALI_RT_CLEAR_print(fp, &values->clear, indent + 2); } struct MALI_TILER_HEAP { uint32_t size; uint64_t base; uint64_t bottom; uint64_t top; }; #define MALI_TILER_HEAP_header \ 0 static inline void MALI_TILER_HEAP_pack(uint32_t * restrict cl, const struct MALI_TILER_HEAP * restrict values) { cl[ 0] = 0; cl[ 1] = __gen_uint(ALIGN_POT(values->size, 4096), 0, 31); cl[ 2] = __gen_uint(values->base, 0, 63); cl[ 3] = __gen_uint(values->base, 0, 63) >> 32; cl[ 4] = __gen_uint(values->bottom, 0, 63); cl[ 5] = __gen_uint(values->bottom, 0, 63) >> 32; cl[ 6] = __gen_uint(values->top, 0, 63); cl[ 7] = __gen_uint(values->top, 0, 63) >> 32; } #define MALI_TILER_HEAP_LENGTH 32 #define MALI_TILER_HEAP_ALIGN 64 struct mali_tiler_heap_packed { uint32_t opaque[8]; }; static inline void MALI_TILER_HEAP_unpack(const uint8_t * restrict cl, struct MALI_TILER_HEAP * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Heap unpacked at word 0\n"); values->size = __gen_unpack_uint(cl, 32, 63); assert(!(values->size & 0xfff)); values->base = __gen_unpack_uint(cl, 64, 127); values->bottom = __gen_unpack_uint(cl, 128, 191); values->top = __gen_unpack_uint(cl, 192, 255); } static inline void MALI_TILER_HEAP_print(FILE *fp, const struct MALI_TILER_HEAP * values, unsigned indent) { fprintf(fp, "%*sSize: %u\n", indent, "", values->size); fprintf(fp, "%*sBase: 0x%" PRIx64 "\n", indent, "", values->base); fprintf(fp, "%*sBottom: 0x%" PRIx64 "\n", indent, "", values->bottom); fprintf(fp, "%*sTop: 0x%" PRIx64 "\n", indent, "", values->top); } struct MALI_TILER_WEIGHTS { uint32_t weight0; uint32_t weight1; uint32_t weight2; uint32_t weight3; uint32_t weight4; uint32_t weight5; uint32_t weight6; uint32_t weight7; }; #define MALI_TILER_WEIGHTS_header \ 0 static inline void MALI_TILER_WEIGHTS_pack(uint32_t * restrict cl, const struct MALI_TILER_WEIGHTS * restrict values) { cl[ 0] = __gen_uint(values->weight0, 16, 31); cl[ 1] = __gen_uint(values->weight1, 16, 31); cl[ 2] = __gen_uint(values->weight2, 16, 31); cl[ 3] = __gen_uint(values->weight3, 16, 31); cl[ 4] = __gen_uint(values->weight4, 16, 31); cl[ 5] = __gen_uint(values->weight5, 16, 31); cl[ 6] = __gen_uint(values->weight6, 16, 31); cl[ 7] = __gen_uint(values->weight7, 16, 31); } #define MALI_TILER_WEIGHTS_LENGTH 32 struct mali_tiler_weights_packed { uint32_t opaque[8]; }; static inline void MALI_TILER_WEIGHTS_unpack(const uint8_t * restrict cl, struct MALI_TILER_WEIGHTS * restrict values) { if (((const uint32_t *) cl)[0] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 3\n"); if (((const uint32_t *) cl)[4] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 4\n"); if (((const uint32_t *) cl)[5] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 5\n"); if (((const uint32_t *) cl)[6] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Weights unpacked at word 7\n"); values->weight0 = __gen_unpack_uint(cl, 16, 31); values->weight1 = __gen_unpack_uint(cl, 48, 63); values->weight2 = __gen_unpack_uint(cl, 80, 95); values->weight3 = __gen_unpack_uint(cl, 112, 127); values->weight4 = __gen_unpack_uint(cl, 144, 159); values->weight5 = __gen_unpack_uint(cl, 176, 191); values->weight6 = __gen_unpack_uint(cl, 208, 223); values->weight7 = __gen_unpack_uint(cl, 240, 255); } static inline void MALI_TILER_WEIGHTS_print(FILE *fp, const struct MALI_TILER_WEIGHTS * values, unsigned indent) { fprintf(fp, "%*sWeight0: %u\n", indent, "", values->weight0); fprintf(fp, "%*sWeight1: %u\n", indent, "", values->weight1); fprintf(fp, "%*sWeight2: %u\n", indent, "", values->weight2); fprintf(fp, "%*sWeight3: %u\n", indent, "", values->weight3); fprintf(fp, "%*sWeight4: %u\n", indent, "", values->weight4); fprintf(fp, "%*sWeight5: %u\n", indent, "", values->weight5); fprintf(fp, "%*sWeight6: %u\n", indent, "", values->weight6); fprintf(fp, "%*sWeight7: %u\n", indent, "", values->weight7); } struct MALI_TILER_STATE { uint32_t word0; uint32_t word1; uint32_t word2; uint32_t word3; uint32_t word4; uint32_t word5; uint32_t word6; uint32_t word7; uint32_t word8; uint32_t word9; uint32_t word10; uint32_t word11; uint32_t word12; uint32_t word13; uint32_t word14; uint32_t word15; }; #define MALI_TILER_STATE_header \ 0 static inline void MALI_TILER_STATE_pack(uint32_t * restrict cl, const struct MALI_TILER_STATE * restrict values) { cl[ 0] = __gen_uint(values->word0, 0, 31); cl[ 1] = __gen_uint(values->word1, 0, 31); cl[ 2] = __gen_uint(values->word2, 0, 31); cl[ 3] = __gen_uint(values->word3, 0, 31); cl[ 4] = __gen_uint(values->word4, 0, 31); cl[ 5] = __gen_uint(values->word5, 0, 31); cl[ 6] = __gen_uint(values->word6, 0, 31); cl[ 7] = __gen_uint(values->word7, 0, 31); cl[ 8] = __gen_uint(values->word8, 0, 31); cl[ 9] = __gen_uint(values->word9, 0, 31); cl[10] = __gen_uint(values->word10, 0, 31); cl[11] = __gen_uint(values->word11, 0, 31); cl[12] = __gen_uint(values->word12, 0, 31); cl[13] = __gen_uint(values->word13, 0, 31); cl[14] = __gen_uint(values->word14, 0, 31); cl[15] = __gen_uint(values->word15, 0, 31); } #define MALI_TILER_STATE_LENGTH 64 struct mali_tiler_state_packed { uint32_t opaque[16]; }; static inline void MALI_TILER_STATE_unpack(const uint8_t * restrict cl, struct MALI_TILER_STATE * restrict values) { values->word0 = __gen_unpack_uint(cl, 0, 31); values->word1 = __gen_unpack_uint(cl, 32, 63); values->word2 = __gen_unpack_uint(cl, 64, 95); values->word3 = __gen_unpack_uint(cl, 96, 127); values->word4 = __gen_unpack_uint(cl, 128, 159); values->word5 = __gen_unpack_uint(cl, 160, 191); values->word6 = __gen_unpack_uint(cl, 192, 223); values->word7 = __gen_unpack_uint(cl, 224, 255); values->word8 = __gen_unpack_uint(cl, 256, 287); values->word9 = __gen_unpack_uint(cl, 288, 319); values->word10 = __gen_unpack_uint(cl, 320, 351); values->word11 = __gen_unpack_uint(cl, 352, 383); values->word12 = __gen_unpack_uint(cl, 384, 415); values->word13 = __gen_unpack_uint(cl, 416, 447); values->word14 = __gen_unpack_uint(cl, 448, 479); values->word15 = __gen_unpack_uint(cl, 480, 511); } static inline void MALI_TILER_STATE_print(FILE *fp, const struct MALI_TILER_STATE * values, unsigned indent) { fprintf(fp, "%*sWord0: %u\n", indent, "", values->word0); fprintf(fp, "%*sWord1: %u\n", indent, "", values->word1); fprintf(fp, "%*sWord2: %u\n", indent, "", values->word2); fprintf(fp, "%*sWord3: %u\n", indent, "", values->word3); fprintf(fp, "%*sWord4: %u\n", indent, "", values->word4); fprintf(fp, "%*sWord5: %u\n", indent, "", values->word5); fprintf(fp, "%*sWord6: %u\n", indent, "", values->word6); fprintf(fp, "%*sWord7: %u\n", indent, "", values->word7); fprintf(fp, "%*sWord8: %u\n", indent, "", values->word8); fprintf(fp, "%*sWord9: %u\n", indent, "", values->word9); fprintf(fp, "%*sWord10: %u\n", indent, "", values->word10); fprintf(fp, "%*sWord11: %u\n", indent, "", values->word11); fprintf(fp, "%*sWord12: %u\n", indent, "", values->word12); fprintf(fp, "%*sWord13: %u\n", indent, "", values->word13); fprintf(fp, "%*sWord14: %u\n", indent, "", values->word14); fprintf(fp, "%*sWord15: %u\n", indent, "", values->word15); } struct MALI_TILER_CONTEXT { uint64_t polygon_list; uint32_t hierarchy_mask; enum mali_sample_pattern sample_pattern; bool update_cost_table; uint32_t fb_width; uint32_t fb_height; uint64_t heap; struct MALI_TILER_WEIGHTS weights; struct MALI_TILER_STATE state; }; #define MALI_TILER_CONTEXT_header \ .weights = { MALI_TILER_WEIGHTS_header }, \ .state = { MALI_TILER_STATE_header } static inline void MALI_TILER_CONTEXT_pack(uint32_t * restrict cl, const struct MALI_TILER_CONTEXT * restrict values) { assert(values->fb_width >= 1); assert(values->fb_height >= 1); cl[ 0] = __gen_uint(values->polygon_list, 0, 63); cl[ 1] = __gen_uint(values->polygon_list, 0, 63) >> 32; cl[ 2] = __gen_uint(values->hierarchy_mask, 0, 12) | __gen_uint(values->sample_pattern, 13, 15) | __gen_uint(values->update_cost_table, 16, 16); cl[ 3] = __gen_uint(values->fb_width - 1, 0, 15) | __gen_uint(values->fb_height - 1, 16, 31); cl[ 4] = 0; cl[ 5] = 0; cl[ 6] = __gen_uint(values->heap, 0, 63); cl[ 7] = __gen_uint(values->heap, 0, 63) >> 32; cl[ 8] = __gen_uint(values->weights.weight0, 16, 31); cl[ 9] = __gen_uint(values->weights.weight1, 16, 31); cl[10] = __gen_uint(values->weights.weight2, 16, 31); cl[11] = __gen_uint(values->weights.weight3, 16, 31); cl[12] = __gen_uint(values->weights.weight4, 16, 31); cl[13] = __gen_uint(values->weights.weight5, 16, 31); cl[14] = __gen_uint(values->weights.weight6, 16, 31); cl[15] = __gen_uint(values->weights.weight7, 16, 31); cl[16] = 0; cl[17] = 0; cl[18] = 0; cl[19] = 0; cl[20] = 0; cl[21] = 0; cl[22] = 0; cl[23] = 0; cl[24] = 0; cl[25] = 0; cl[26] = 0; cl[27] = 0; cl[28] = 0; cl[29] = 0; cl[30] = 0; cl[31] = 0; cl[32] = __gen_uint(values->state.word0, 0, 31); cl[33] = __gen_uint(values->state.word1, 0, 31); cl[34] = __gen_uint(values->state.word2, 0, 31); cl[35] = __gen_uint(values->state.word3, 0, 31); cl[36] = __gen_uint(values->state.word4, 0, 31); cl[37] = __gen_uint(values->state.word5, 0, 31); cl[38] = __gen_uint(values->state.word6, 0, 31); cl[39] = __gen_uint(values->state.word7, 0, 31); cl[40] = __gen_uint(values->state.word8, 0, 31); cl[41] = __gen_uint(values->state.word9, 0, 31); cl[42] = __gen_uint(values->state.word10, 0, 31); cl[43] = __gen_uint(values->state.word11, 0, 31); cl[44] = __gen_uint(values->state.word12, 0, 31); cl[45] = __gen_uint(values->state.word13, 0, 31); cl[46] = __gen_uint(values->state.word14, 0, 31); cl[47] = __gen_uint(values->state.word15, 0, 31); } #define MALI_TILER_CONTEXT_LENGTH 192 #define MALI_TILER_CONTEXT_ALIGN 64 struct mali_tiler_context_packed { uint32_t opaque[48]; }; static inline void MALI_TILER_CONTEXT_unpack(const uint8_t * restrict cl, struct MALI_TILER_CONTEXT * restrict values) { if (((const uint32_t *) cl)[2] & 0xfffe0000) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 2\n"); if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 4\n"); if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 5\n"); if (((const uint32_t *) cl)[8] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 8\n"); if (((const uint32_t *) cl)[9] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 9\n"); if (((const uint32_t *) cl)[10] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 10\n"); if (((const uint32_t *) cl)[11] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 11\n"); if (((const uint32_t *) cl)[12] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 12\n"); if (((const uint32_t *) cl)[13] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 13\n"); if (((const uint32_t *) cl)[14] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 14\n"); if (((const uint32_t *) cl)[15] & 0xffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 15\n"); if (((const uint32_t *) cl)[16] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 16\n"); if (((const uint32_t *) cl)[17] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 17\n"); if (((const uint32_t *) cl)[18] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 18\n"); if (((const uint32_t *) cl)[19] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 19\n"); if (((const uint32_t *) cl)[20] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 20\n"); if (((const uint32_t *) cl)[21] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 21\n"); if (((const uint32_t *) cl)[22] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 22\n"); if (((const uint32_t *) cl)[23] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 23\n"); if (((const uint32_t *) cl)[24] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 24\n"); if (((const uint32_t *) cl)[25] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 25\n"); if (((const uint32_t *) cl)[26] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 26\n"); if (((const uint32_t *) cl)[27] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 27\n"); if (((const uint32_t *) cl)[28] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 28\n"); if (((const uint32_t *) cl)[29] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 29\n"); if (((const uint32_t *) cl)[30] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 30\n"); if (((const uint32_t *) cl)[31] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 31\n"); values->polygon_list = __gen_unpack_uint(cl, 0, 63); values->hierarchy_mask = __gen_unpack_uint(cl, 64, 76); values->sample_pattern = (enum mali_sample_pattern)__gen_unpack_uint(cl, 77, 79); values->update_cost_table = __gen_unpack_uint(cl, 80, 80); values->fb_width = __gen_unpack_uint(cl, 96, 111) + 1; values->fb_height = __gen_unpack_uint(cl, 112, 127) + 1; values->heap = __gen_unpack_uint(cl, 192, 255); values->weights.weight0 = __gen_unpack_uint(cl, 272, 287); values->weights.weight1 = __gen_unpack_uint(cl, 304, 319); values->weights.weight2 = __gen_unpack_uint(cl, 336, 351); values->weights.weight3 = __gen_unpack_uint(cl, 368, 383); values->weights.weight4 = __gen_unpack_uint(cl, 400, 415); values->weights.weight5 = __gen_unpack_uint(cl, 432, 447); values->weights.weight6 = __gen_unpack_uint(cl, 464, 479); values->weights.weight7 = __gen_unpack_uint(cl, 496, 511); values->state.word0 = __gen_unpack_uint(cl, 1024, 1055); values->state.word1 = __gen_unpack_uint(cl, 1056, 1087); values->state.word2 = __gen_unpack_uint(cl, 1088, 1119); values->state.word3 = __gen_unpack_uint(cl, 1120, 1151); values->state.word4 = __gen_unpack_uint(cl, 1152, 1183); values->state.word5 = __gen_unpack_uint(cl, 1184, 1215); values->state.word6 = __gen_unpack_uint(cl, 1216, 1247); values->state.word7 = __gen_unpack_uint(cl, 1248, 1279); values->state.word8 = __gen_unpack_uint(cl, 1280, 1311); values->state.word9 = __gen_unpack_uint(cl, 1312, 1343); values->state.word10 = __gen_unpack_uint(cl, 1344, 1375); values->state.word11 = __gen_unpack_uint(cl, 1376, 1407); values->state.word12 = __gen_unpack_uint(cl, 1408, 1439); values->state.word13 = __gen_unpack_uint(cl, 1440, 1471); values->state.word14 = __gen_unpack_uint(cl, 1472, 1503); values->state.word15 = __gen_unpack_uint(cl, 1504, 1535); } static inline void MALI_TILER_CONTEXT_print(FILE *fp, const struct MALI_TILER_CONTEXT * values, unsigned indent) { fprintf(fp, "%*sPolygon List: 0x%" PRIx64 "\n", indent, "", values->polygon_list); fprintf(fp, "%*sHierarchy Mask: %u\n", indent, "", values->hierarchy_mask); fprintf(fp, "%*sSample Pattern: %s\n", indent, "", mali_sample_pattern_as_str(values->sample_pattern)); fprintf(fp, "%*sUpdate Cost Table: %s\n", indent, "", values->update_cost_table ? "true" : "false"); fprintf(fp, "%*sFB Width: %u\n", indent, "", values->fb_width); fprintf(fp, "%*sFB Height: %u\n", indent, "", values->fb_height); fprintf(fp, "%*sHeap: 0x%" PRIx64 "\n", indent, "", values->heap); fprintf(fp, "%*sWeights:\n", indent, ""); MALI_TILER_WEIGHTS_print(fp, &values->weights, indent + 2); fprintf(fp, "%*sState:\n", indent, ""); MALI_TILER_STATE_print(fp, &values->state, indent + 2); } struct MALI_FRAMEBUFFER_PADDING { int dummy; }; #define MALI_FRAMEBUFFER_PADDING_header \ 0 static inline void MALI_FRAMEBUFFER_PADDING_pack(uint32_t * restrict cl, const struct MALI_FRAMEBUFFER_PADDING * restrict values) { cl[ 0] = 0; cl[ 1] = 0; cl[ 2] = 0; cl[ 3] = 0; cl[ 4] = 0; cl[ 5] = 0; cl[ 6] = 0; cl[ 7] = 0; cl[ 8] = 0; cl[ 9] = 0; cl[10] = 0; cl[11] = 0; cl[12] = 0; cl[13] = 0; cl[14] = 0; cl[15] = 0; } #define MALI_FRAMEBUFFER_PADDING_LENGTH 64 struct mali_framebuffer_padding_packed { uint32_t opaque[16]; }; static inline void MALI_FRAMEBUFFER_PADDING_unpack(const uint8_t * restrict cl, struct MALI_FRAMEBUFFER_PADDING * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 3\n"); if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 4\n"); if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 5\n"); if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 7\n"); if (((const uint32_t *) cl)[8] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 8\n"); if (((const uint32_t *) cl)[9] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 9\n"); if (((const uint32_t *) cl)[10] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 10\n"); if (((const uint32_t *) cl)[11] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 11\n"); if (((const uint32_t *) cl)[12] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 12\n"); if (((const uint32_t *) cl)[13] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 13\n"); if (((const uint32_t *) cl)[14] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 14\n"); if (((const uint32_t *) cl)[15] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding unpacked at word 15\n"); } static inline void MALI_FRAMEBUFFER_PADDING_print(FILE *fp, const struct MALI_FRAMEBUFFER_PADDING * values, unsigned indent) { } struct mali_framebuffer_packed { uint32_t opaque[32]; }; #define MALI_FRAMEBUFFER_LENGTH 128 #define MALI_FRAMEBUFFER_ALIGN 64 #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_TYPE struct MALI_FRAMEBUFFER_PARAMETERS #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_header MALI_FRAMEBUFFER_PARAMETERS_header #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_pack MALI_FRAMEBUFFER_PARAMETERS_pack #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_unpack MALI_FRAMEBUFFER_PARAMETERS_unpack #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_print MALI_FRAMEBUFFER_PARAMETERS_print #define MALI_FRAMEBUFFER_SECTION_PARAMETERS_OFFSET 0 #define MALI_FRAMEBUFFER_SECTION_PADDING_TYPE struct MALI_FRAMEBUFFER_PADDING #define MALI_FRAMEBUFFER_SECTION_PADDING_header MALI_FRAMEBUFFER_PADDING_header #define MALI_FRAMEBUFFER_SECTION_PADDING_pack MALI_FRAMEBUFFER_PADDING_pack #define MALI_FRAMEBUFFER_SECTION_PADDING_unpack MALI_FRAMEBUFFER_PADDING_unpack #define MALI_FRAMEBUFFER_SECTION_PADDING_print MALI_FRAMEBUFFER_PADDING_print #define MALI_FRAMEBUFFER_SECTION_PADDING_OFFSET 64 struct MALI_JOB_HEADER { uint32_t exception_status; uint32_t first_incomplete_task; uint64_t fault_pointer; bool is_64b; enum mali_job_type type; bool barrier; bool invalidate_cache; bool suppress_prefetch; bool enable_texture_mapper; bool relax_dependency_1; bool relax_dependency_2; uint32_t index; uint32_t dependency_1; uint32_t dependency_2; uint64_t next; }; #define MALI_JOB_HEADER_header \ .is_64b = true static inline void MALI_JOB_HEADER_pack(uint32_t * restrict cl, const struct MALI_JOB_HEADER * restrict values) { cl[ 0] = __gen_uint(values->exception_status, 0, 31); cl[ 1] = __gen_uint(values->first_incomplete_task, 0, 31); cl[ 2] = __gen_uint(values->fault_pointer, 0, 63); cl[ 3] = __gen_uint(values->fault_pointer, 0, 63) >> 32; cl[ 4] = __gen_uint(values->is_64b, 0, 0) | __gen_uint(values->type, 1, 7) | __gen_uint(values->barrier, 8, 8) | __gen_uint(values->invalidate_cache, 9, 9) | __gen_uint(values->suppress_prefetch, 11, 11) | __gen_uint(values->enable_texture_mapper, 12, 12) | __gen_uint(values->relax_dependency_1, 14, 14) | __gen_uint(values->relax_dependency_2, 15, 15) | __gen_uint(values->index, 16, 31); cl[ 5] = __gen_uint(values->dependency_1, 0, 15) | __gen_uint(values->dependency_2, 16, 31); cl[ 6] = __gen_uint(values->next, 0, 63); cl[ 7] = __gen_uint(values->next, 0, 63) >> 32; } #define MALI_JOB_HEADER_LENGTH 32 #define MALI_JOB_HEADER_ALIGN 64 struct mali_job_header_packed { uint32_t opaque[8]; }; static inline void MALI_JOB_HEADER_unpack(const uint8_t * restrict cl, struct MALI_JOB_HEADER * restrict values) { if (((const uint32_t *) cl)[4] & 0x2400) fprintf(stderr, "XXX: Invalid field of Job Header unpacked at word 4\n"); values->exception_status = __gen_unpack_uint(cl, 0, 31); values->first_incomplete_task = __gen_unpack_uint(cl, 32, 63); values->fault_pointer = __gen_unpack_uint(cl, 64, 127); values->is_64b = __gen_unpack_uint(cl, 128, 128); values->type = (enum mali_job_type)__gen_unpack_uint(cl, 129, 135); values->barrier = __gen_unpack_uint(cl, 136, 136); values->invalidate_cache = __gen_unpack_uint(cl, 137, 137); values->suppress_prefetch = __gen_unpack_uint(cl, 139, 139); values->enable_texture_mapper = __gen_unpack_uint(cl, 140, 140); values->relax_dependency_1 = __gen_unpack_uint(cl, 142, 142); values->relax_dependency_2 = __gen_unpack_uint(cl, 143, 143); values->index = __gen_unpack_uint(cl, 144, 159); values->dependency_1 = __gen_unpack_uint(cl, 160, 175); values->dependency_2 = __gen_unpack_uint(cl, 176, 191); values->next = __gen_unpack_uint(cl, 192, 255); } static inline void MALI_JOB_HEADER_print(FILE *fp, const struct MALI_JOB_HEADER * values, unsigned indent) { fprintf(fp, "%*sException Status: %u\n", indent, "", values->exception_status); fprintf(fp, "%*sFirst Incomplete Task: %u\n", indent, "", values->first_incomplete_task); fprintf(fp, "%*sFault Pointer: 0x%" PRIx64 "\n", indent, "", values->fault_pointer); fprintf(fp, "%*sIs 64b: %s\n", indent, "", values->is_64b ? "true" : "false"); fprintf(fp, "%*sType: %s\n", indent, "", mali_job_type_as_str(values->type)); fprintf(fp, "%*sBarrier: %s\n", indent, "", values->barrier ? "true" : "false"); fprintf(fp, "%*sInvalidate Cache: %s\n", indent, "", values->invalidate_cache ? "true" : "false"); fprintf(fp, "%*sSuppress Prefetch: %s\n", indent, "", values->suppress_prefetch ? "true" : "false"); fprintf(fp, "%*sEnable Texture Mapper: %s\n", indent, "", values->enable_texture_mapper ? "true" : "false"); fprintf(fp, "%*sRelax Dependency 1: %s\n", indent, "", values->relax_dependency_1 ? "true" : "false"); fprintf(fp, "%*sRelax Dependency 2: %s\n", indent, "", values->relax_dependency_2 ? "true" : "false"); fprintf(fp, "%*sIndex: %u\n", indent, "", values->index); fprintf(fp, "%*sDependency 1: %u\n", indent, "", values->dependency_1); fprintf(fp, "%*sDependency 2: %u\n", indent, "", values->dependency_2); fprintf(fp, "%*sNext: 0x%" PRIx64 "\n", indent, "", values->next); } struct MALI_FRAGMENT_JOB_PAYLOAD { uint32_t bound_min_x; uint32_t bound_min_y; uint32_t bound_max_x; uint32_t bound_max_y; bool has_tile_enable_map; uint64_t framebuffer; uint64_t tile_enable_map; uint32_t tile_enable_map_row_stride; }; #define MALI_FRAGMENT_JOB_PAYLOAD_header \ 0 static inline void MALI_FRAGMENT_JOB_PAYLOAD_pack(uint32_t * restrict cl, const struct MALI_FRAGMENT_JOB_PAYLOAD * restrict values) { cl[ 0] = __gen_uint(values->bound_min_x, 0, 11) | __gen_uint(values->bound_min_y, 16, 27); cl[ 1] = __gen_uint(values->bound_max_x, 0, 11) | __gen_uint(values->bound_max_y, 16, 27) | __gen_uint(values->has_tile_enable_map, 31, 31); cl[ 2] = __gen_uint(values->framebuffer, 0, 63); cl[ 3] = __gen_uint(values->framebuffer, 0, 63) >> 32; cl[ 4] = __gen_uint(values->tile_enable_map, 0, 63); cl[ 5] = __gen_uint(values->tile_enable_map, 0, 63) >> 32; cl[ 6] = __gen_uint(values->tile_enable_map_row_stride, 0, 7); cl[ 7] = 0; } #define MALI_FRAGMENT_JOB_PAYLOAD_LENGTH 32 struct mali_fragment_job_payload_packed { uint32_t opaque[8]; }; static inline void MALI_FRAGMENT_JOB_PAYLOAD_unpack(const uint8_t * restrict cl, struct MALI_FRAGMENT_JOB_PAYLOAD * restrict values) { if (((const uint32_t *) cl)[0] & 0xf000f000) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0x7000f000) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 1\n"); if (((const uint32_t *) cl)[6] & 0xffffff00) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 7\n"); values->bound_min_x = __gen_unpack_uint(cl, 0, 11); values->bound_min_y = __gen_unpack_uint(cl, 16, 27); values->bound_max_x = __gen_unpack_uint(cl, 32, 43); values->bound_max_y = __gen_unpack_uint(cl, 48, 59); values->has_tile_enable_map = __gen_unpack_uint(cl, 63, 63); values->framebuffer = __gen_unpack_uint(cl, 64, 127); values->tile_enable_map = __gen_unpack_uint(cl, 128, 191); values->tile_enable_map_row_stride = __gen_unpack_uint(cl, 192, 199); } static inline void MALI_FRAGMENT_JOB_PAYLOAD_print(FILE *fp, const struct MALI_FRAGMENT_JOB_PAYLOAD * values, unsigned indent) { fprintf(fp, "%*sBound Min X: %u\n", indent, "", values->bound_min_x); fprintf(fp, "%*sBound Min Y: %u\n", indent, "", values->bound_min_y); fprintf(fp, "%*sBound Max X: %u\n", indent, "", values->bound_max_x); fprintf(fp, "%*sBound Max Y: %u\n", indent, "", values->bound_max_y); fprintf(fp, "%*sHas Tile Enable Map: %s\n", indent, "", values->has_tile_enable_map ? "true" : "false"); fprintf(fp, "%*sFramebuffer: 0x%" PRIx64 "\n", indent, "", values->framebuffer); fprintf(fp, "%*sTile Enable Map: 0x%" PRIx64 "\n", indent, "", values->tile_enable_map); fprintf(fp, "%*sTile Enable Map Row Stride: %u\n", indent, "", values->tile_enable_map_row_stride); } struct mali_fragment_job_packed { uint32_t opaque[16]; }; #define MALI_FRAGMENT_JOB_LENGTH 64 #define MALI_FRAGMENT_JOB_ALIGN 64 #define MALI_FRAGMENT_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_FRAGMENT_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_FRAGMENT_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_FRAGMENT_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_FRAGMENT_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_FRAGMENT_JOB_SECTION_HEADER_OFFSET 0 #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_TYPE struct MALI_FRAGMENT_JOB_PAYLOAD #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_header MALI_FRAGMENT_JOB_PAYLOAD_header #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_pack MALI_FRAGMENT_JOB_PAYLOAD_pack #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_unpack MALI_FRAGMENT_JOB_PAYLOAD_unpack #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_print MALI_FRAGMENT_JOB_PAYLOAD_print #define MALI_FRAGMENT_JOB_SECTION_PAYLOAD_OFFSET 32 enum mali_write_value_type { MALI_WRITE_VALUE_TYPE_CYCLE_COUNTER = 1, MALI_WRITE_VALUE_TYPE_SYSTEM_TIMESTAMP = 2, MALI_WRITE_VALUE_TYPE_ZERO = 3, MALI_WRITE_VALUE_TYPE_IMMEDIATE_8 = 4, MALI_WRITE_VALUE_TYPE_IMMEDIATE_16 = 5, MALI_WRITE_VALUE_TYPE_IMMEDIATE_32 = 6, MALI_WRITE_VALUE_TYPE_IMMEDIATE_64 = 7, }; static inline const char * mali_write_value_type_as_str(enum mali_write_value_type imm) { switch (imm) { case MALI_WRITE_VALUE_TYPE_CYCLE_COUNTER: return "Cycle Counter"; case MALI_WRITE_VALUE_TYPE_SYSTEM_TIMESTAMP: return "System Timestamp"; case MALI_WRITE_VALUE_TYPE_ZERO: return "Zero"; case MALI_WRITE_VALUE_TYPE_IMMEDIATE_8: return "Immediate 8"; case MALI_WRITE_VALUE_TYPE_IMMEDIATE_16: return "Immediate 16"; case MALI_WRITE_VALUE_TYPE_IMMEDIATE_32: return "Immediate 32"; case MALI_WRITE_VALUE_TYPE_IMMEDIATE_64: return "Immediate 64"; default: return "XXX: INVALID"; } } struct MALI_WRITE_VALUE_JOB_PAYLOAD { uint64_t address; enum mali_write_value_type type; uint64_t immediate_value; }; #define MALI_WRITE_VALUE_JOB_PAYLOAD_header \ 0 static inline void MALI_WRITE_VALUE_JOB_PAYLOAD_pack(uint32_t * restrict cl, const struct MALI_WRITE_VALUE_JOB_PAYLOAD * restrict values) { cl[ 0] = __gen_uint(values->address, 0, 63); cl[ 1] = __gen_uint(values->address, 0, 63) >> 32; cl[ 2] = __gen_uint(values->type, 0, 31); cl[ 3] = 0; cl[ 4] = __gen_uint(values->immediate_value, 0, 63); cl[ 5] = __gen_uint(values->immediate_value, 0, 63) >> 32; } #define MALI_WRITE_VALUE_JOB_PAYLOAD_LENGTH 24 struct mali_write_value_job_payload_packed { uint32_t opaque[6]; }; static inline void MALI_WRITE_VALUE_JOB_PAYLOAD_unpack(const uint8_t * restrict cl, struct MALI_WRITE_VALUE_JOB_PAYLOAD * restrict values) { if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Write Value Job Payload unpacked at word 3\n"); values->address = __gen_unpack_uint(cl, 0, 63); values->type = (enum mali_write_value_type)__gen_unpack_uint(cl, 64, 95); values->immediate_value = __gen_unpack_uint(cl, 128, 191); } static inline void MALI_WRITE_VALUE_JOB_PAYLOAD_print(FILE *fp, const struct MALI_WRITE_VALUE_JOB_PAYLOAD * values, unsigned indent) { fprintf(fp, "%*sAddress: 0x%" PRIx64 "\n", indent, "", values->address); fprintf(fp, "%*sType: %s\n", indent, "", mali_write_value_type_as_str(values->type)); fprintf(fp, "%*sImmediate Value: 0x%" PRIx64 "\n", indent, "", values->immediate_value); } struct MALI_CACHE_FLUSH_JOB_PAYLOAD { bool clean_shader_core_ls; bool invalidate_shader_core_ls; bool invalidate_shader_core_other; bool job_manager_clean; bool job_manager_invalidate; bool tiler_clean; bool tiler_invalidate; bool l2_clean; bool l2_invalidate; }; #define MALI_CACHE_FLUSH_JOB_PAYLOAD_header \ 0 static inline void MALI_CACHE_FLUSH_JOB_PAYLOAD_pack(uint32_t * restrict cl, const struct MALI_CACHE_FLUSH_JOB_PAYLOAD * restrict values) { cl[ 0] = __gen_uint(values->clean_shader_core_ls, 0, 0) | __gen_uint(values->invalidate_shader_core_ls, 1, 1) | __gen_uint(values->invalidate_shader_core_other, 2, 2) | __gen_uint(values->job_manager_clean, 16, 16) | __gen_uint(values->job_manager_invalidate, 17, 17) | __gen_uint(values->tiler_clean, 24, 24) | __gen_uint(values->tiler_invalidate, 25, 25); cl[ 1] = __gen_uint(values->l2_clean, 0, 0) | __gen_uint(values->l2_invalidate, 1, 1); } #define MALI_CACHE_FLUSH_JOB_PAYLOAD_LENGTH 8 struct mali_cache_flush_job_payload_packed { uint32_t opaque[2]; }; static inline void MALI_CACHE_FLUSH_JOB_PAYLOAD_unpack(const uint8_t * restrict cl, struct MALI_CACHE_FLUSH_JOB_PAYLOAD * restrict values) { if (((const uint32_t *) cl)[0] & 0xfcfcfff8) fprintf(stderr, "XXX: Invalid field of Cache Flush Job Payload unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xfffffffc) fprintf(stderr, "XXX: Invalid field of Cache Flush Job Payload unpacked at word 1\n"); values->clean_shader_core_ls = __gen_unpack_uint(cl, 0, 0); values->invalidate_shader_core_ls = __gen_unpack_uint(cl, 1, 1); values->invalidate_shader_core_other = __gen_unpack_uint(cl, 2, 2); values->job_manager_clean = __gen_unpack_uint(cl, 16, 16); values->job_manager_invalidate = __gen_unpack_uint(cl, 17, 17); values->tiler_clean = __gen_unpack_uint(cl, 24, 24); values->tiler_invalidate = __gen_unpack_uint(cl, 25, 25); values->l2_clean = __gen_unpack_uint(cl, 32, 32); values->l2_invalidate = __gen_unpack_uint(cl, 33, 33); } static inline void MALI_CACHE_FLUSH_JOB_PAYLOAD_print(FILE *fp, const struct MALI_CACHE_FLUSH_JOB_PAYLOAD * values, unsigned indent) { fprintf(fp, "%*sClean Shader Core LS: %s\n", indent, "", values->clean_shader_core_ls ? "true" : "false"); fprintf(fp, "%*sInvalidate Shader Core LS: %s\n", indent, "", values->invalidate_shader_core_ls ? "true" : "false"); fprintf(fp, "%*sInvalidate Shader Core Other: %s\n", indent, "", values->invalidate_shader_core_other ? "true" : "false"); fprintf(fp, "%*sJob Manager Clean: %s\n", indent, "", values->job_manager_clean ? "true" : "false"); fprintf(fp, "%*sJob Manager Invalidate: %s\n", indent, "", values->job_manager_invalidate ? "true" : "false"); fprintf(fp, "%*sTiler Clean: %s\n", indent, "", values->tiler_clean ? "true" : "false"); fprintf(fp, "%*sTiler Invalidate: %s\n", indent, "", values->tiler_invalidate ? "true" : "false"); fprintf(fp, "%*sL2 Clean: %s\n", indent, "", values->l2_clean ? "true" : "false"); fprintf(fp, "%*sL2 Invalidate: %s\n", indent, "", values->l2_invalidate ? "true" : "false"); } struct mali_write_value_job_packed { uint32_t opaque[14]; }; #define MALI_WRITE_VALUE_JOB_LENGTH 56 #define MALI_WRITE_VALUE_JOB_ALIGN 64 #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_WRITE_VALUE_JOB_SECTION_HEADER_OFFSET 0 #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_TYPE struct MALI_WRITE_VALUE_JOB_PAYLOAD #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_header MALI_WRITE_VALUE_JOB_PAYLOAD_header #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_pack MALI_WRITE_VALUE_JOB_PAYLOAD_pack #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_unpack MALI_WRITE_VALUE_JOB_PAYLOAD_unpack #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_print MALI_WRITE_VALUE_JOB_PAYLOAD_print #define MALI_WRITE_VALUE_JOB_SECTION_PAYLOAD_OFFSET 32 struct mali_cache_flush_job_packed { uint32_t opaque[10]; }; #define MALI_CACHE_FLUSH_JOB_LENGTH 40 #define MALI_CACHE_FLUSH_JOB_ALIGN 64 #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_CACHE_FLUSH_JOB_SECTION_HEADER_OFFSET 0 #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_TYPE struct MALI_CACHE_FLUSH_JOB_PAYLOAD #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_header MALI_CACHE_FLUSH_JOB_PAYLOAD_header #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_pack MALI_CACHE_FLUSH_JOB_PAYLOAD_pack #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_unpack MALI_CACHE_FLUSH_JOB_PAYLOAD_unpack #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_print MALI_CACHE_FLUSH_JOB_PAYLOAD_print #define MALI_CACHE_FLUSH_JOB_SECTION_PAYLOAD_OFFSET 32 struct MALI_COMPUTE_JOB_PARAMETERS { uint32_t job_task_split; }; #define MALI_COMPUTE_JOB_PARAMETERS_header \ 0 static inline void MALI_COMPUTE_JOB_PARAMETERS_pack(uint32_t * restrict cl, const struct MALI_COMPUTE_JOB_PARAMETERS * restrict values) { cl[ 0] = __gen_uint(values->job_task_split, 26, 29); cl[ 1] = 0; cl[ 2] = 0; cl[ 3] = 0; cl[ 4] = 0; cl[ 5] = 0; } #define MALI_COMPUTE_JOB_PARAMETERS_LENGTH 24 struct mali_compute_job_parameters_packed { uint32_t opaque[6]; }; static inline void MALI_COMPUTE_JOB_PARAMETERS_unpack(const uint8_t * restrict cl, struct MALI_COMPUTE_JOB_PARAMETERS * restrict values) { if (((const uint32_t *) cl)[0] & 0xc3ffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 3\n"); if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 4\n"); if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 5\n"); values->job_task_split = __gen_unpack_uint(cl, 26, 29); } static inline void MALI_COMPUTE_JOB_PARAMETERS_print(FILE *fp, const struct MALI_COMPUTE_JOB_PARAMETERS * values, unsigned indent) { fprintf(fp, "%*sJob Task Split: %u\n", indent, "", values->job_task_split); } struct mali_compute_job_packed { uint32_t opaque[48]; }; #define MALI_COMPUTE_JOB_LENGTH 192 #define MALI_COMPUTE_JOB_ALIGN 64 #define MALI_COMPUTE_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_COMPUTE_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_COMPUTE_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_COMPUTE_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_COMPUTE_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_COMPUTE_JOB_SECTION_HEADER_OFFSET 0 #define MALI_COMPUTE_JOB_SECTION_INVOCATION_TYPE struct MALI_INVOCATION #define MALI_COMPUTE_JOB_SECTION_INVOCATION_header MALI_INVOCATION_header #define MALI_COMPUTE_JOB_SECTION_INVOCATION_pack MALI_INVOCATION_pack #define MALI_COMPUTE_JOB_SECTION_INVOCATION_unpack MALI_INVOCATION_unpack #define MALI_COMPUTE_JOB_SECTION_INVOCATION_print MALI_INVOCATION_print #define MALI_COMPUTE_JOB_SECTION_INVOCATION_OFFSET 32 #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_TYPE struct MALI_COMPUTE_JOB_PARAMETERS #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_header MALI_COMPUTE_JOB_PARAMETERS_header #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_pack MALI_COMPUTE_JOB_PARAMETERS_pack #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_unpack MALI_COMPUTE_JOB_PARAMETERS_unpack #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_print MALI_COMPUTE_JOB_PARAMETERS_print #define MALI_COMPUTE_JOB_SECTION_PARAMETERS_OFFSET 40 #define MALI_COMPUTE_JOB_SECTION_DRAW_TYPE struct MALI_DRAW #define MALI_COMPUTE_JOB_SECTION_DRAW_header MALI_DRAW_header #define MALI_COMPUTE_JOB_SECTION_DRAW_pack MALI_DRAW_pack #define MALI_COMPUTE_JOB_SECTION_DRAW_unpack MALI_DRAW_unpack #define MALI_COMPUTE_JOB_SECTION_DRAW_print MALI_DRAW_print #define MALI_COMPUTE_JOB_SECTION_DRAW_OFFSET 64 struct MALI_PRIMITIVE_SIZE { float constant; uint64_t size_array; }; #define MALI_PRIMITIVE_SIZE_header \ 0 static inline void MALI_PRIMITIVE_SIZE_pack(uint32_t * restrict cl, const struct MALI_PRIMITIVE_SIZE * restrict values) { cl[ 0] = __gen_uint(fui(values->constant), 0, 32) | __gen_uint(values->size_array, 0, 63); cl[ 1] = __gen_uint(values->size_array, 0, 63) >> 32; } #define MALI_PRIMITIVE_SIZE_LENGTH 8 struct mali_primitive_size_packed { uint32_t opaque[2]; }; static inline void MALI_PRIMITIVE_SIZE_unpack(const uint8_t * restrict cl, struct MALI_PRIMITIVE_SIZE * restrict values) { values->constant = __gen_unpack_float(cl, 0, 31); values->size_array = __gen_unpack_uint(cl, 0, 63); } static inline void MALI_PRIMITIVE_SIZE_print(FILE *fp, const struct MALI_PRIMITIVE_SIZE * values, unsigned indent) { fprintf(fp, "%*sConstant: %f\n", indent, "", values->constant); fprintf(fp, "%*sSize Array: 0x%" PRIx64 "\n", indent, "", values->size_array); } struct MALI_TILER_POINTER { uint64_t address; }; #define MALI_TILER_POINTER_header \ 0 static inline void MALI_TILER_POINTER_pack(uint32_t * restrict cl, const struct MALI_TILER_POINTER * restrict values) { cl[ 0] = __gen_uint(values->address, 0, 63); cl[ 1] = __gen_uint(values->address, 0, 63) >> 32; } #define MALI_TILER_POINTER_LENGTH 8 struct mali_tiler_pointer_packed { uint32_t opaque[2]; }; static inline void MALI_TILER_POINTER_unpack(const uint8_t * restrict cl, struct MALI_TILER_POINTER * restrict values) { values->address = __gen_unpack_uint(cl, 0, 63); } static inline void MALI_TILER_POINTER_print(FILE *fp, const struct MALI_TILER_POINTER * values, unsigned indent) { fprintf(fp, "%*sAddress: 0x%" PRIx64 "\n", indent, "", values->address); } struct MALI_TILER_JOB_PADDING { int dummy; }; #define MALI_TILER_JOB_PADDING_header \ 0 static inline void MALI_TILER_JOB_PADDING_pack(uint32_t * restrict cl, const struct MALI_TILER_JOB_PADDING * restrict values) { cl[ 0] = 0; cl[ 1] = 0; cl[ 2] = 0; cl[ 3] = 0; cl[ 4] = 0; cl[ 5] = 0; cl[ 6] = 0; cl[ 7] = 0; cl[ 8] = 0; cl[ 9] = 0; cl[10] = 0; cl[11] = 0; } #define MALI_TILER_JOB_PADDING_LENGTH 48 struct mali_tiler_job_padding_packed { uint32_t opaque[12]; }; static inline void MALI_TILER_JOB_PADDING_unpack(const uint8_t * restrict cl, struct MALI_TILER_JOB_PADDING * restrict values) { if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 0\n"); if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 1\n"); if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 2\n"); if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 3\n"); if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 4\n"); if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 5\n"); if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 6\n"); if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 7\n"); if (((const uint32_t *) cl)[8] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 8\n"); if (((const uint32_t *) cl)[9] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 9\n"); if (((const uint32_t *) cl)[10] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 10\n"); if (((const uint32_t *) cl)[11] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Tiler Job Padding unpacked at word 11\n"); } static inline void MALI_TILER_JOB_PADDING_print(FILE *fp, const struct MALI_TILER_JOB_PADDING * values, unsigned indent) { } struct mali_tiler_job_packed { uint32_t opaque[64]; }; #define MALI_TILER_JOB_LENGTH 256 #define MALI_TILER_JOB_ALIGN 64 #define MALI_TILER_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_TILER_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_TILER_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_TILER_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_TILER_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_TILER_JOB_SECTION_HEADER_OFFSET 0 #define MALI_TILER_JOB_SECTION_INVOCATION_TYPE struct MALI_INVOCATION #define MALI_TILER_JOB_SECTION_INVOCATION_header MALI_INVOCATION_header #define MALI_TILER_JOB_SECTION_INVOCATION_pack MALI_INVOCATION_pack #define MALI_TILER_JOB_SECTION_INVOCATION_unpack MALI_INVOCATION_unpack #define MALI_TILER_JOB_SECTION_INVOCATION_print MALI_INVOCATION_print #define MALI_TILER_JOB_SECTION_INVOCATION_OFFSET 32 #define MALI_TILER_JOB_SECTION_PRIMITIVE_TYPE struct MALI_PRIMITIVE #define MALI_TILER_JOB_SECTION_PRIMITIVE_header MALI_PRIMITIVE_header #define MALI_TILER_JOB_SECTION_PRIMITIVE_pack MALI_PRIMITIVE_pack #define MALI_TILER_JOB_SECTION_PRIMITIVE_unpack MALI_PRIMITIVE_unpack #define MALI_TILER_JOB_SECTION_PRIMITIVE_print MALI_PRIMITIVE_print #define MALI_TILER_JOB_SECTION_PRIMITIVE_OFFSET 40 #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_TYPE struct MALI_PRIMITIVE_SIZE #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_header MALI_PRIMITIVE_SIZE_header #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_pack MALI_PRIMITIVE_SIZE_pack #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_unpack MALI_PRIMITIVE_SIZE_unpack #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_print MALI_PRIMITIVE_SIZE_print #define MALI_TILER_JOB_SECTION_PRIMITIVE_SIZE_OFFSET 64 #define MALI_TILER_JOB_SECTION_TILER_TYPE struct MALI_TILER_POINTER #define MALI_TILER_JOB_SECTION_TILER_header MALI_TILER_POINTER_header #define MALI_TILER_JOB_SECTION_TILER_pack MALI_TILER_POINTER_pack #define MALI_TILER_JOB_SECTION_TILER_unpack MALI_TILER_POINTER_unpack #define MALI_TILER_JOB_SECTION_TILER_print MALI_TILER_POINTER_print #define MALI_TILER_JOB_SECTION_TILER_OFFSET 72 #define MALI_TILER_JOB_SECTION_PADDING_TYPE struct MALI_TILER_JOB_PADDING #define MALI_TILER_JOB_SECTION_PADDING_header MALI_TILER_JOB_PADDING_header #define MALI_TILER_JOB_SECTION_PADDING_pack MALI_TILER_JOB_PADDING_pack #define MALI_TILER_JOB_SECTION_PADDING_unpack MALI_TILER_JOB_PADDING_unpack #define MALI_TILER_JOB_SECTION_PADDING_print MALI_TILER_JOB_PADDING_print #define MALI_TILER_JOB_SECTION_PADDING_OFFSET 80 #define MALI_TILER_JOB_SECTION_DRAW_TYPE struct MALI_DRAW #define MALI_TILER_JOB_SECTION_DRAW_header MALI_DRAW_header #define MALI_TILER_JOB_SECTION_DRAW_pack MALI_DRAW_pack #define MALI_TILER_JOB_SECTION_DRAW_unpack MALI_DRAW_unpack #define MALI_TILER_JOB_SECTION_DRAW_print MALI_DRAW_print #define MALI_TILER_JOB_SECTION_DRAW_OFFSET 128 struct mali_indexed_vertex_job_packed { uint32_t opaque[96]; }; #define MALI_INDEXED_VERTEX_JOB_LENGTH 384 #define MALI_INDEXED_VERTEX_JOB_ALIGN 64 #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_TYPE struct MALI_JOB_HEADER #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_header MALI_JOB_HEADER_header #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_pack MALI_JOB_HEADER_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_unpack MALI_JOB_HEADER_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_print MALI_JOB_HEADER_print #define MALI_INDEXED_VERTEX_JOB_SECTION_HEADER_OFFSET 0 #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_TYPE struct MALI_INVOCATION #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_header MALI_INVOCATION_header #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_pack MALI_INVOCATION_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_unpack MALI_INVOCATION_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_print MALI_INVOCATION_print #define MALI_INDEXED_VERTEX_JOB_SECTION_INVOCATION_OFFSET 32 #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_TYPE struct MALI_PRIMITIVE #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_header MALI_PRIMITIVE_header #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_pack MALI_PRIMITIVE_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_unpack MALI_PRIMITIVE_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_print MALI_PRIMITIVE_print #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_OFFSET 40 #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_TYPE struct MALI_PRIMITIVE_SIZE #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_header MALI_PRIMITIVE_SIZE_header #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_pack MALI_PRIMITIVE_SIZE_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_unpack MALI_PRIMITIVE_SIZE_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_print MALI_PRIMITIVE_SIZE_print #define MALI_INDEXED_VERTEX_JOB_SECTION_PRIMITIVE_SIZE_OFFSET 64 #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_TYPE struct MALI_TILER_POINTER #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_header MALI_TILER_POINTER_header #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_pack MALI_TILER_POINTER_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_unpack MALI_TILER_POINTER_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_print MALI_TILER_POINTER_print #define MALI_INDEXED_VERTEX_JOB_SECTION_TILER_OFFSET 72 #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_TYPE struct MALI_TILER_JOB_PADDING #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_header MALI_TILER_JOB_PADDING_header #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_pack MALI_TILER_JOB_PADDING_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_unpack MALI_TILER_JOB_PADDING_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_print MALI_TILER_JOB_PADDING_print #define MALI_INDEXED_VERTEX_JOB_SECTION_PADDING_OFFSET 80 #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_TYPE struct MALI_DRAW #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_header MALI_DRAW_header #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_pack MALI_DRAW_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_unpack MALI_DRAW_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_print MALI_DRAW_print #define MALI_INDEXED_VERTEX_JOB_SECTION_FRAGMENT_DRAW_OFFSET 128 #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_TYPE struct MALI_DRAW #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_header MALI_DRAW_header #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_pack MALI_DRAW_pack #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_unpack MALI_DRAW_unpack #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_print MALI_DRAW_print #define MALI_INDEXED_VERTEX_JOB_SECTION_VERTEX_DRAW_OFFSET 256 #include "panfrost-job.h" #endif