Lines Matching refs:cl
70 __gen_unpack_uint(const uint8_t *restrict cl, uint32_t start, uint32_t end)
77 val |= ((uint64_t) cl[byte]) << ((byte - start / 8) * 8);
84 __gen_unpack_sint(const uint8_t *restrict cl, uint32_t start, uint32_t end)
87 int64_t val = __gen_unpack_uint(cl, start, end);
94 __gen_unpack_padded(const uint8_t *restrict cl, uint32_t start, uint32_t end)
96 unsigned val = __gen_unpack_uint(cl, start, end);
1010 MALI_ATTRIBUTE_pack(uint32_t * restrict cl,
1013 cl[ 0] = __gen_uint(values->buffer_index, 0, 8) |
1016 cl[ 1] = __gen_sint(values->offset, 0, 31);
1024 MALI_ATTRIBUTE_unpack(const uint8_t * restrict cl,
1027 values->buffer_index = __gen_unpack_uint(cl, 0, 8);
1028 values->offset_enable = __gen_unpack_uint(cl, 9, 9);
1029 values->format = __gen_unpack_uint(cl, 10, 31);
1030 values->offset = __gen_unpack_sint(cl, 32, 63);
1053 MALI_ATTRIBUTE_VERTEX_ID_pack(uint32_t * restrict cl,
1056 cl[ 0] = __gen_uint(values->type, 0, 7);
1057 cl[ 1] = __gen_uint(values->divisor_r, 24, 28) |
1059 cl[ 2] = 0;
1060 cl[ 3] = __gen_sint(values->offset, 0, 31);
1068 MALI_ATTRIBUTE_VERTEX_ID_unpack(const uint8_t * restrict cl,
1071 if (((const uint32_t *) cl)[0] & 0xffffff00) fprintf(stderr, "XXX: Invalid field of Attribute Vertex ID unpacked at word 0\n");
1072 if (((const uint32_t *) cl)[1] & 0xffffff) fprintf(stderr, "XXX: Invalid field of Attribute Vertex ID unpacked at word 1\n");
1073 if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Attribute Vertex ID unpacked at word 2\n");
1074 values->type = (enum mali_attribute_special)__gen_unpack_uint(cl, 0, 7);
1075 values->divisor_r = __gen_unpack_uint(cl, 56, 60);
1076 values->divisor_p = __gen_unpack_uint(cl, 61, 63);
1077 values->offset = __gen_unpack_sint(cl, 96, 127);
1101 MALI_ATTRIBUTE_INSTANCE_ID_pack(uint32_t * restrict cl,
1104 cl[ 0] = __gen_uint(values->type, 0, 7);
1105 cl[ 1] = __gen_uint(values->divisor_r, 24, 28) |
1107 cl[ 2] = __gen_uint(values->divisor_p, 0, 31);
1108 cl[ 3] = __gen_sint(values->offset, 0, 31);
1116 MALI_ATTRIBUTE_INSTANCE_ID_unpack(const uint8_t * restrict cl,
1119 if (((const uint32_t *) cl)[0] & 0xffffff00) fprintf(stderr, "XXX: Invalid field of Attribute Instance ID unpacked at word 0\n");
1120 if (((const uint32_t *) cl)[1] & 0xc0ffffff) fprintf(stderr, "XXX: Invalid field of Attribute Instance ID unpacked at word 1\n");
1121 values->type = (enum mali_attribute_special)__gen_unpack_uint(cl, 0, 7);
1122 values->divisor_r = __gen_unpack_uint(cl, 56, 60);
1123 values->divisor_e = __gen_unpack_uint(cl, 61, 61);
1124 values->divisor_p = __gen_unpack_uint(cl, 64, 95);
1125 values->offset = __gen_unpack_sint(cl, 96, 127);
1155 MALI_ATTRIBUTE_BUFFER_pack(uint32_t * restrict cl,
1159 cl[ 0] = __gen_uint(values->special, 0, 7) |
1162 cl[ 1] = __gen_uint(values->pointer >> 6, 6, 55) >> 32 |
1167 cl[ 2] = __gen_uint(values->stride, 0, 31);
1168 cl[ 3] = __gen_uint(values->size, 0, 31);
1176 MALI_ATTRIBUTE_BUFFER_unpack(const uint8_t * restrict cl,
1179 values->special = (enum mali_attribute_special)__gen_unpack_uint(cl, 0, 7);
1180 values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5);
1181 values->pointer = __gen_unpack_uint(cl, 6, 55) << 6;
1182 values->stride = __gen_unpack_uint(cl, 64, 95);
1183 values->size = __gen_unpack_uint(cl, 96, 127);
1184 values->divisor = __gen_unpack_padded(cl, 56, 63);
1185 values->divisor_r = __gen_unpack_uint(cl, 56, 60);
1186 values->divisor_p = __gen_unpack_uint(cl, 61, 63);
1187 values->divisor_e = __gen_unpack_uint(cl, 61, 61);
1214 MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_pack(uint32_t * restrict cl,
1217 cl[ 0] = __gen_uint(values->type, 0, 5);
1218 cl[ 1] = __gen_uint(values->divisor_numerator, 0, 31);
1219 cl[ 2] = 0;
1220 cl
1227 MALI_ATTRIBUTE_BUFFER_CONTINUATION_NPOT_unpack(const uint8_t * restrict cl,
1230 if (((const uint32_t *) cl)[0] & 0xffffffc0) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation NPOT unpacked at word 0\n");
1231 if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation NPOT unpacked at word 2\n");
1232 values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5);
1233 values->divisor_numerator = __gen_unpack_uint(cl, 32, 63);
1234 values->divisor = __gen_unpack_uint(cl, 96, 127);
1258 MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_pack(uint32_t * restrict cl,
1264 cl[ 0] = __gen_uint(values->type, 0, 5) |
1266 cl[ 1] = __gen_uint(values->t_dimension - 1, 0, 15) |
1268 cl[ 2] = __gen_uint(values->row_stride, 0, 31);
1269 cl[ 3] = __gen_uint(values->slice_stride, 0, 31);
1276 MALI_ATTRIBUTE_BUFFER_CONTINUATION_3D_unpack(const uint8_t * restrict cl,
1279 if (((const uint32_t *) cl)[0] & 0xffc0) fprintf(stderr, "XXX: Invalid field of Attribute Buffer Continuation 3D unpacked at word 0\n");
1280 values->type = (enum mali_attribute_type)__gen_unpack_uint(cl, 0, 5);
1281 values->s_dimension = __gen_unpack_uint(cl, 16, 31) + 1;
1282 values->t_dimension = __gen_unpack_uint(cl, 32, 47) + 1;
1283 values->r_dimension = __gen_unpack_uint(cl, 48, 63) + 1;
1284 values->row_stride = __gen_unpack_uint(cl, 64, 95);
1285 values->slice_stride = __gen_unpack_uint(cl, 96, 127);
1394 MALI_BLEND_EQUATION_pack(uint32_t * restrict cl,
1397 cl[ 0] = __gen_uint(values->rgb.a, 0, 1) |
1416 MALI_BLEND_EQUATION_unpack(const uint8_t * restrict cl,
1419 if (((const uint32_t *) cl)[0] & 0xf044044) fprintf(stderr, "XXX: Invalid field of Blend Equation unpacked at word 0\n");
1420 values->rgb.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 0, 1);
1421 values->rgb.negate_a = __gen_unpack_uint(cl, 3, 3);
1422 values->rgb.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 4, 5);
1423 values->rgb.negate_b = __gen_unpack_uint(cl, 7, 7);
1424 values->rgb.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 8, 10);
1425 values->rgb.invert_c = __gen_unpack_uint(cl, 11, 11);
1426 values->alpha.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 12, 13);
1427 values->alpha.negate_a = __gen_unpack_uint(cl, 15, 15);
1428 values->alpha.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 16, 17);
1429 values->alpha.negate_b = __gen_unpack_uint(cl, 19, 19);
1430 values->alpha.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 20, 22);
1431 values->alpha.invert_c = __gen_unpack_uint(cl, 23, 23);
1432 values->color_mask = __gen_unpack_uint(cl, 28, 31);
1468 MALI_BLEND_pack(uint32_t * restrict cl,
1471 cl[ 0] = __gen_uint(values->load_destination, 0, 0) |
1478 cl[ 1] = 0;
1479 cl[ 2] = __gen_uint(values->shader_pc, 0, 63) |
1493 cl[ 3] = __gen_uint(values->shader_pc, 0, 63) >> 32 |
1502 MALI_BLEND_unpack(const uint8_t * restrict cl,
1505 if (((const uint32_t *) cl)[0] & 0xfffff0f8) fprintf(stderr, "XXX: Invalid field of Blend unpacked at word 0\n");
1506 if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Blend unpacked at word 1\n");
1507 values->load_destination = __gen_unpack_uint(cl, 0, 0);
1508 values->blend_shader = __gen_unpack_uint(cl, 1, 1);
1509 values->blend_shader_contains_discard = __gen_unpack_uint(cl, 2, 2);
1510 values->alpha_to_one = __gen_unpack_uint(cl, 8, 8);
1511 values->enable = __gen_unpack_uint(cl, 9, 9);
1512 values->srgb = __gen_unpack_uint(cl, 10, 10);
1513 values->round_to_fb_precision = __gen_unpack_uint(cl, 11, 11);
1514 values->shader_pc = __gen_unpack_uint(cl, 64, 127);
1515 values->equation.rgb.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 64, 65);
1516 values->equation.rgb.negate_a = __gen_unpack_uint(cl, 67, 67);
1517 values->equation.rgb.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 68, 69);
1518 values->equation.rgb.negate_b = __gen_unpack_uint(cl, 71, 71);
1519 values->equation.rgb.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 72, 74);
1520 values->equation.rgb.invert_c = __gen_unpack_uint(cl, 75, 75);
1521 values->equation.alpha.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 76, 77);
1522 values->equation.alpha.negate_a = __gen_unpack_uint(cl, 79, 79);
1523 values->equation.alpha.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 80, 81);
1524 values->equation.alpha.negate_b = __gen_unpack_uint(cl, 83, 83);
1525 values->equation.alpha.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 84, 86);
1526 values->equation.alpha.invert_c = __gen_unpack_uint(cl, 87, 87);
1527 values->equation.color_mask = __gen_unpack_uint(cl, 92, 95);
1528 values->constant = __gen_unpack_float(cl, 96, 127);
1562 MALI_INVOCATION_pack(uint32_t * restrict cl,
1565 cl[ 0] = __gen_uint(values->invocations, 0, 31);
1566 cl[ 1] = __gen_uint(values->size_y_shift, 0, 4) |
1578 MALI_INVOCATION_unpack(const uint8_t * restrict cl,
1581 values->invocations = __gen_unpack_uint(cl
1582 values->size_y_shift = __gen_unpack_uint(cl, 32, 36);
1583 values->size_z_shift = __gen_unpack_uint(cl, 37, 41);
1584 values->workgroups_x_shift = __gen_unpack_uint(cl, 42, 47);
1585 values->workgroups_y_shift = __gen_unpack_uint(cl, 48, 53);
1586 values->workgroups_z_shift = __gen_unpack_uint(cl, 54, 59);
1587 values->thread_group_split = __gen_unpack_uint(cl, 60, 63);
1660 MALI_PRIMITIVE_pack(uint32_t * restrict cl,
1664 cl[ 0] = __gen_uint(values->draw_mode, 0, 7) |
1674 cl[ 1] = __gen_uint(values->base_vertex_offset, 0, 31);
1675 cl[ 2] = __gen_uint(values->primitive_restart_index, 0, 31);
1676 cl[ 3] = __gen_uint(values->index_count - 1, 0, 31);
1677 cl[ 4] = __gen_uint(values->indices, 0, 63);
1678 cl[ 5] = __gen_uint(values->indices, 0, 63) >> 32;
1685 MALI_PRIMITIVE_unpack(const uint8_t * restrict cl,
1688 if (((const uint32_t *) cl)[0] & 0x3e40000) fprintf(stderr, "XXX: Invalid field of Primitive unpacked at word 0\n");
1689 values->draw_mode = (enum mali_draw_mode)__gen_unpack_uint(cl, 0, 7);
1690 values->index_type = (enum mali_index_type)__gen_unpack_uint(cl, 8, 10);
1691 values->point_size_array_format = (enum mali_point_size_array_format)__gen_unpack_uint(cl, 11, 12);
1692 values->primitive_index_enable = __gen_unpack_uint(cl, 13, 13);
1693 values->primitive_index_writeback = __gen_unpack_uint(cl, 14, 14);
1694 values->first_provoking_vertex = __gen_unpack_uint(cl, 15, 15);
1695 values->low_depth_cull = __gen_unpack_uint(cl, 16, 16);
1696 values->high_depth_cull = __gen_unpack_uint(cl, 17, 17);
1697 values->primitive_restart = (enum mali_primitive_restart)__gen_unpack_uint(cl, 19, 20);
1698 values->job_task_split = __gen_unpack_uint(cl, 26, 31);
1699 values->base_vertex_offset = __gen_unpack_uint(cl, 32, 63);
1700 values->primitive_restart_index = __gen_unpack_uint(cl, 64, 95);
1701 values->index_count = __gen_unpack_uint(cl, 96, 127) + 1;
1702 values->indices = __gen_unpack_uint(cl, 128, 191);
1762 MALI_DRAW_pack(uint32_t * restrict cl,
1765 cl[ 0] = __gen_uint(values->four_components_per_vertex, 0, 0) |
1777 cl[ 1] = __gen_uint(values->offset_start, 0, 31);
1778 cl[ 2] = __gen_uint(values->primitive_index_base, 0, 31);
1779 cl[ 3] = 0;
1780 cl[ 4] = __gen_uint(values->position, 0, 63);
1781 cl[ 5] = __gen_uint(values->position, 0, 63) >> 32;
1782 cl[ 6] = __gen_uint(values->uniform_buffers, 0, 63);
1783 cl[ 7] = __gen_uint(values->uniform_buffers, 0, 63) >> 32;
1784 cl[ 8] = __gen_uint(values->textures, 0, 63);
1785 cl[ 9] = __gen_uint(values->textures, 0, 63) >> 32;
1786 cl[10] = __gen_uint(values->samplers, 0, 63);
1787 cl[11] = __gen_uint(values->samplers, 0, 63) >> 32;
1788 cl[12] = __gen_uint(values->push_uniforms, 0, 63);
1789 cl[13] = __gen_uint(values->push_uniforms, 0, 63) >> 32;
1790 cl[14] = __gen_uint(values->state, 0, 63);
1791 cl[15] = __gen_uint(values->state, 0, 63) >> 32;
1792 cl[16] = __gen_uint(values->attribute_buffers, 0, 63);
1793 cl[17] = __gen_uint(values->attribute_buffers, 0, 63) >> 32;
1794 cl[18] = __gen_uint(values->attributes, 0, 63);
1795 cl[19] = __gen_uint(values->attributes, 0, 63) >> 32;
1796 cl[20] = __gen_uint(values->varying_buffers, 0, 63);
1797 cl[21] = __gen_uint(values->varying_buffers, 0, 63) >> 32;
1798 cl[22] = __gen_uint(values->varyings, 0, 63);
1799 cl[23] = __gen_uint(values->varyings, 0, 63) >> 32;
1800 cl[24] = __gen_uint(values->viewport, 0, 63);
1801 cl[25] = __gen_uint(values->viewport, 0, 63) >> 32;
1802 cl[26] = __gen_uint(values->occlusion, 0, 63);
1803 cl[27] = __gen_uint(values->occlusion, 0, 63) >> 32;
1804 cl[28] = __gen_uint(values->thread_storage, 0, 63) |
1806 cl[29] = __gen_uint(values->thread_storage, 0, 63) >> 32 |
1815 MALI_DRAW_unpack(const uint8_t * restrict cl,
1818 if (((const uint32_t *) cl)[0] & 0xf200) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 0\n");
1819 if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Draw unpacked at word 3\n");
1820 values->four_components_per_vertex = __gen_unpack_uint(cl, 0, 0);
1821 values->draw_descriptor_is_64b = __gen_unpack_uint(cl, 1, 1);
1822 values->texture_descriptor_is_64b = __gen_unpack_uint(cl, 2, 2);
1823 values->occlusion_query = (enum mali_occlusion_mode)__gen_unpack_uint(cl, 3, 4);
1824 values->front_face_ccw = __gen_unpack_uint(cl, 5, 5);
1825 values->cull_front_face = __gen_unpack_uint(cl, 6, 6);
1826 values->cull_back_face = __gen_unpack_uint(cl, 7, 7);
1827 values->flat_shading_vertex = __gen_unpack_uint(cl, 8, 8);
1828 values->primitive_barrier = __gen_unpack_uint(cl, 10, 10);
1829 values->clean_fragment_write = __gen_unpack_uint(cl, 11, 11);
1830 values->instance_size = __gen_unpack_padded(cl, 16, 23);
1831 values->instance_primitive_size = __gen_unpack_padded(cl, 24, 31);
1832 values->offset_start = __gen_unpack_uint(cl, 32, 63);
1833 values->primitive_index_base = __gen_unpack_uint(cl, 64, 95);
1834 values->position = __gen_unpack_uint(cl, 128, 191);
1835 values->uniform_buffers = __gen_unpack_uint(cl, 192, 255);
1836 values->textures = __gen_unpack_uint(cl, 256, 319);
1837 values->samplers = __gen_unpack_uint(cl, 320, 383);
1838 values->push_uniforms = __gen_unpack_uint(cl, 384, 447);
1839 values->state = __gen_unpack_uint(cl, 448, 511);
1840 values->attribute_buffers = __gen_unpack_uint(cl, 512, 575);
1841 values->attributes = __gen_unpack_uint(cl, 576, 639);
1842 values->varying_buffers = __gen_unpack_uint(cl, 640, 703);
1843 values->varyings = __gen_unpack_uint(cl, 704, 767);
1844 values->viewport = __gen_unpack_uint(cl, 768, 831);
1845 values->occlusion = __gen_unpack_uint(cl, 832, 895);
1846 values->thread_storage = __gen_unpack_uint(cl, 896, 959);
1847 values->fbd = __gen_unpack_uint(cl, 896, 959);
1891 MALI_SURFACE_pack(uint32_t * restrict cl,
1894 cl[ 0] = __gen_uint(values->pointer, 0, 63);
1895 cl[ 1] = __gen_uint(values->pointer, 0, 63) >> 32;
1903 MALI_SURFACE_unpack(const uint8_t * restrict cl,
1906 values->pointer = __gen_unpack_uint(cl, 0, 63);
1925 MALI_SURFACE_WITH_STRIDE_pack(uint32_t * restrict cl,
1928 cl[ 0] = __gen_uint(values->pointer, 0, 63);
1929 cl[ 1] = __gen_uint(values->pointer, 0, 63) >> 32;
1930 cl[ 2] = __gen_sint(values->row_stride, 0, 31);
1931 cl[ 3] = __gen_sint(values->surface_stride, 0, 31);
1939 MALI_SURFACE_WITH_STRIDE_unpack(const uint8_t * restrict cl,
1942 values->pointer = __gen_unpack_uint(cl, 0, 63);
1943 values->row_stride = __gen_unpack_sint(cl, 64, 95);
1944 values->surface_stride = __gen_unpack_sint(cl, 96, 127);
1994 MALI_SAMPLER_pack(uint32_t * restrict cl,
1997 cl[ 0] = __gen_uint(values->magnify_nearest, 0, 0) |
2003 cl[ 1] = __gen_uint(values->minimum_lod, 0, 15) |
2005 cl[ 2] = __gen_uint(values->wrap_mode_s, 0, 3) |
2010 cl[ 3] = 0;
2011 cl[ 4] = __gen_uint(values->border_color_r, 0, 31);
2012 cl[ 5] = __gen_uint(values->border_color_g, 0, 31);
2013 cl[ 6] = __gen_uint(values->border_color_b, 0, 31);
2014 cl[ 7] = __gen_uint(values->border_color_a, 0, 31);
2022 MALI_SAMPLER_unpack(const uint8_t * restrict cl,
2025 if (((const uint32_t *) cl)[0] & 0xff84) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 0\n");
2026 if (((const uint32_t *) cl)[2] & 0xffff0000) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 2\n");
2027 if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Sampler unpacked at word 3\n");
2028 values->magnify_nearest = __gen_unpack_uint(cl, 0, 0);
2029 values->minify_nearest = __gen_unpack_uint(cl, 1, 1);
2030 values->mipmap_mode = (enum mali_mipmap_mode)__gen_unpack_uint(cl, 3, 4);
2031 values->normalized_coordinates = __gen_unpack_uint(cl, 5, 5);
2032 values->isotropic_lod = __gen_unpack_uint(cl, 6, 6);
2033 values->lod_bias = __gen_unpack_sint(cl, 16, 31);
2034 values->minimum_lod = __gen_unpack_uint(cl, 32, 47);
2035 values->maximum_lod = __gen_unpack_uint(cl, 48, 63);
2036 values->wrap_mode_s = (enum mali_wrap_mode)__gen_unpack_uint(cl, 64, 67);
2037 values->wrap_mode_t = (enum mali_wrap_mode)__gen_unpack_uint(cl, 68, 71);
2038 values->wrap_mode_r = (enum mali_wrap_mode)__gen_unpack_uint(cl, 72, 75);
2039 values->compare_function = (enum mali_func)__gen_unpack_uint(cl, 76, 78);
2040 values->seamless_cube_map = __gen_unpack_uint(cl, 79, 79);
2041 values->border_color_r = __gen_unpack_uint(cl, 128, 159);
2042 values->border_color_g = __gen_unpack_uint(cl, 160, 191);
2043 values->border_color_b = __gen_unpack_uint(cl, 192, 223);
2044 values->border_color_a = __gen_unpack_uint(cl, 224, 255);
2092 MALI_TEXTURE_pack(uint32_t * restrict cl,
2101 cl[ 0] = __gen_uint(values->width - 1, 0, 15) |
2103 cl[ 1] = __gen_uint(values->depth - 1, 0, 15) |
2106 cl[ 2] = __gen_uint(values->format, 0, 21) |
2111 cl[ 3] = __gen_uint(values->levels - 1, 24, 31);
2112 cl[ 4] = __gen_uint(values->swizzle, 0, 11);
2113 cl[ 5] = 0;
2114 cl[ 6] = 0;
2115 cl[ 7] = 0;
2123 MALI_TEXTURE_unpack(const uint8_t * restrict cl,
2126 if (((const uint32_t *) cl)[2] & 0xc0000000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 2\n");
2127 if (((const uint32_t *) cl)[3] & 0xffffff) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 3\n");
2128 if (((const uint32_t *) cl)[4] & 0xfffff000) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 4\n");
2129 if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 5\n");
2130 if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 6\n");
2131 if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Texture unpacked at word 7\n");
2132 values->width = __gen_unpack_uint(cl, 0, 15) + 1;
2133 values->height = __gen_unpack_uint(cl, 16, 31) + 1;
2134 values->depth = __gen_unpack_uint(cl, 32, 47) + 1;
2135 values->sample_count = __gen_unpack_uint(cl, 32, 47) + 1;
2136 values->array_size = __gen_unpack_uint(cl, 48, 63) + 1;
2137 values->format = __gen_unpack_uint(cl, 64, 85);
2138 values->dimension = (enum mali_texture_dimension)__gen_unpack_uint(cl, 86, 87);
2139 values->texel_ordering = (enum mali_texture_layout)__gen_unpack_uint(cl, 88, 91);
2140 values->surface_pointer_is_64b = __gen_unpack_uint(cl, 92, 92);
2141 values->manual_stride = __gen_unpack_uint(cl, 93, 93);
2142 values->levels = __gen_unpack_uint(cl, 120, 127) + 1;
2143 values->swizzle = __gen_unpack_uint(cl, 128, 139);
2176 case MALI_FP_MODE_CL: return "CL";
2201 MALI_RENDERER_PROPERTIES_pack(uint32_t * restrict cl,
2204 cl[ 0] = __gen_uint(values->uniform_buffer_count, 0, 7) |
2222 MALI_RENDERER_PROPERTIES_unpack(const uint8_t * restrict cl,
2225 if (((const uint32_t *) cl)[0] & 0xc000000) fprintf(stderr, "XXX: Invalid field of Renderer Properties unpacked at word 0\n");
2226 values->uniform_buffer_count = __gen_unpack_uint(cl, 0, 7);
2227 values->depth_source = (enum mali_depth_source)__gen_unpack_uint(cl, 8, 9);
2228 values->shader_contains_barrier = __gen_unpack_uint(cl, 11, 11);
2229 values->force_early_z = __gen_unpack_uint(cl, 10, 10);
2230 values->shader_contains_discard = __gen_unpack_uint(cl, 12, 12);
2231 values->shader_has_side_effects = __gen_unpack_uint(cl, 13, 13);
2232 values->shader_reads_tilebuffer = __gen_unpack_uint(cl, 14, 14);
2233 values->forward_pixel_kill = __gen_unpack_uint(cl, 15, 15);
2234 values->work_register_count = __gen_unpack_uint(cl, 16, 20);
2235 values->uniform_count = __gen_unpack_uint(cl, 21, 25);
2236 values->stencil_from_shader = __gen_unpack_uint(cl, 28, 28);
2237 values->fp_mode = (enum mali_fp_mode)__gen_unpack_uint(cl, 29, 31);
2269 MALI_SHADER_pack(uint32_t * restrict cl,
2272 cl[ 0] = __gen_uint(values->shader, 0, 63);
2273 cl[ 1] = __gen_uint(values->shader, 0, 63) >> 32;
2274 cl[ 2] = __gen_uint(values->sampler_count, 0, 15) |
2276 cl[ 3] = __gen_uint(values->attribute_count, 0, 15) |
2284 MALI_SHADER_unpack(const uint8_t * restrict cl,
2287 values->shader = __gen_unpack_uint(cl, 0, 63);
2288 values->sampler_count = __gen_unpack_uint(cl, 64, 79);
2289 values->texture_count = __gen_unpack_uint(cl, 80, 95);
2290 values->attribute_count = __gen_unpack_uint(cl, 96, 111);
2291 values->varying_count = __gen_unpack_uint(cl, 112, 127);
2326 MALI_MULTISAMPLE_MISC_pack(uint32_t * restrict cl,
2329 cl[ 0] = __gen_uint(values->sample_mask, 0, 15) |
2350 MALI_MULTISAMPLE_MISC_unpack(const uint8_t * restrict cl,
2353 values->sample_mask = __gen_unpack_uint(cl, 0, 15);
2354 values->multisample_enable = __gen_unpack_uint(cl, 16, 16);
2355 values->multisample_late_coverage = __gen_unpack_uint(cl, 17, 17);
2356 values->evaluate_per_sample = __gen_unpack_uint(cl, 18, 18);
2357 values->fixed_function_depth_range_fixed = __gen_unpack_uint(cl, 19, 19);
2358 values->shader_depth_range_fixed = __gen_unpack_uint(cl, 20, 20);
2359 values->load_destination = __gen_unpack_uint(cl, 21, 21);
2360 values->blend_shader = __gen_unpack_uint(cl, 22, 22);
2361 values->blend_shader_discard = __gen_unpack_uint(cl, 23, 23);
2362 values->depth_function = (enum mali_func)__gen_unpack_uint(cl, 24, 26);
2363 values->depth_write_mask = __gen_unpack_uint(cl, 27, 27);
2364 values->fixed_function_near_discard = __gen_unpack_uint(cl, 28, 28);
2365 values->fixed_function_far_discard = __gen_unpack_uint(cl, 29, 29);
2366 values->fragment_near_discard = __gen_unpack_uint(cl, 30, 30);
2367 values->fragment_far_discard = __gen_unpack_uint(cl, 31, 31);
2412 MALI_STENCIL_MASK_MISC_pack(uint32_t * restrict cl,
2415 cl[ 0] = __gen_uint(values->stencil_mask_front, 0, 7) |
2436 MALI_STENCIL_MASK_MISC_unpack(const uint8_t * restrict cl,
2439 if (((const uint32_t *) cl)[0] & 0x8000000) fprintf(stderr, "XXX: Invalid field of Stencil Mask, Misc unpacked at word 0\n");
2440 values->stencil_mask_front = __gen_unpack_uint(cl, 0, 7);
2441 values->stencil_mask_back = __gen_unpack_uint(cl, 8, 15);
2442 values->stencil_enable = __gen_unpack_uint(cl, 16, 16);
2443 values->alpha_to_coverage = __gen_unpack_uint(cl, 17, 17);
2444 values->alpha_to_coverage_invert = __gen_unpack_uint(cl, 18, 18);
2445 values->alpha_to_one = __gen_unpack_uint(cl, 19, 19);
2446 values->write_enable = __gen_unpack_uint(cl, 20, 20);
2447 values->alpha_test_compare_function = (enum mali_func)__gen_unpack_uint(cl, 21, 23);
2448 values->srgb = __gen_unpack_uint(cl, 24, 24);
2449 values->dither_disable = __gen_unpack_uint(cl, 25, 25);
2450 values->force_seamless_cubemaps = __gen_unpack_uint(cl, 26, 26);
2451 values->depth_range_1 = __gen_unpack_uint(cl, 28, 28);
2452 values->depth_range_2 = __gen_unpack_uint(cl, 29, 29);
2453 values->single_sampled_lines = __gen_unpack_uint(cl, 30, 30);
2454 values->point_snap = __gen_unpack_uint(cl, 31, 31);
2490 MALI_STENCIL_pack(uint32_t * restrict cl,
2493 cl[ 0] = __gen_uint(values->reference_value, 0, 7) |
2505 MALI_STENCIL_unpack(const uint8_t * restrict cl,
2508 if (((const uint32_t *) cl)[0] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Stencil unpacked at word 0\n");
2509 values->reference_value = __gen_unpack_uint(cl, 0, 7);
2510 values->mask = __gen_unpack_uint(cl, 8, 15);
2511 values->compare_function = (enum mali_func)__gen_unpack_uint(cl, 16, 18);
2512 values->stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 19, 21);
2513 values->depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 22, 24);
2514 values->depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 25, 27);
2555 MALI_RENDERER_STATE_pack(uint32_t * restrict cl,
2558 cl[ 0] = __gen_uint(values->shader.shader, 0, 63);
2559 cl[ 1] = __gen_uint(values->shader.shader, 0, 63) >> 32;
2560 cl[ 2] = __gen_uint(values->shader.sampler_count, 0, 15) |
2562 cl[ 3] = __gen_uint(values->shader.attribute_count, 0, 15) |
2564 cl[ 4] = __gen_uint(values->properties.uniform_buffer_count, 0, 7) |
2576 cl[ 5] = __gen_uint(fui(values->depth_units), 0, 32);
2577 cl[ 6] = __gen_uint(fui(values->depth_factor), 0, 32);
2578 cl[ 7] = __gen_uint(fui(values->depth_bias_clamp), 0, 32);
2579 cl[ 8] = __gen_uint(values->multisample_misc.sample_mask, 0, 15) |
2594 cl[ 9] = __gen_uint(values->stencil_mask_misc.stencil_mask_front, 0, 7) |
2609 cl[10] = __gen_uint(values->stencil_front.reference_value, 0, 7) |
2615 cl[11] = __gen_uint(values->stencil_back.reference_value, 0, 7) |
2621 cl[12] = __gen_uint(fui(values->alpha_reference), 0, 32);
2622 cl[13] = __gen_uint(values->thread_balancing, 0, 15);
2623 cl[14] = __gen_uint(values->blend_shader, 0, 63) |
2637 cl[15] = __gen_uint(values->blend_shader, 0, 63) >> 32 |
2646 MALI_RENDERER_STATE_unpack(const uint8_t * restrict cl,
2649 if (((const uint32_t *) cl)[4] & 0xc000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 4\n");
2650 if (((const uint32_t *) cl)[9] & 0x8000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 9\n");
2651 if (((const uint32_t *) cl)[10] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 10\n");
2652 if (((const uint32_t *) cl)[11] & 0xf0000000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 11\n");
2653 if (((const uint32_t *) cl)[13] & 0xffff0000) fprintf(stderr, "XXX: Invalid field of Renderer State unpacked at word 13\n");
2654 values->shader.shader = __gen_unpack_uint(cl, 0, 63);
2655 values->shader.sampler_count = __gen_unpack_uint(cl, 64, 79);
2656 values->shader.texture_count = __gen_unpack_uint(cl, 80, 95);
2657 values->shader.attribute_count = __gen_unpack_uint(cl, 96, 111);
2658 values->shader.varying_count = __gen_unpack_uint(cl, 112, 127);
2659 values->properties.uniform_buffer_count = __gen_unpack_uint(cl, 128, 135);
2660 values->properties.depth_source = (enum mali_depth_source)__gen_unpack_uint(cl, 136, 137);
2661 values->properties.shader_contains_barrier = __gen_unpack_uint(cl, 139, 139);
2662 values->properties.force_early_z = __gen_unpack_uint(cl, 138, 138);
2663 values->properties.shader_contains_discard = __gen_unpack_uint(cl, 140, 140);
2664 values->properties.shader_has_side_effects = __gen_unpack_uint(cl, 141, 141);
2665 values->properties.shader_reads_tilebuffer = __gen_unpack_uint(cl, 142, 142);
2666 values->properties.forward_pixel_kill = __gen_unpack_uint(cl, 143, 143);
2667 values->properties.work_register_count = __gen_unpack_uint(cl, 144, 148);
2668 values->properties.uniform_count = __gen_unpack_uint(cl, 149, 153);
2669 values->properties.stencil_from_shader = __gen_unpack_uint(cl, 156, 156);
2670 values->properties.fp_mode = (enum mali_fp_mode)__gen_unpack_uint(cl, 157, 159);
2671 values->depth_units = __gen_unpack_float(cl, 160, 191);
2672 values->depth_factor = __gen_unpack_float(cl, 192, 223);
2673 values->depth_bias_clamp = __gen_unpack_float(cl, 224, 255);
2674 values->multisample_misc.sample_mask = __gen_unpack_uint(cl, 256, 271);
2675 values->multisample_misc.multisample_enable = __gen_unpack_uint(cl, 272, 272);
2676 values->multisample_misc.multisample_late_coverage = __gen_unpack_uint(cl, 273, 273);
2677 values->multisample_misc.evaluate_per_sample = __gen_unpack_uint(cl, 274, 274);
2678 values->multisample_misc.fixed_function_depth_range_fixed = __gen_unpack_uint(cl, 275, 275);
2679 values->multisample_misc.shader_depth_range_fixed = __gen_unpack_uint(cl, 276, 276);
2680 values->multisample_misc.load_destination = __gen_unpack_uint(cl, 277, 277);
2681 values->multisample_misc.blend_shader = __gen_unpack_uint(cl, 278, 278);
2682 values->multisample_misc.blend_shader_discard = __gen_unpack_uint(cl, 279, 279);
2683 values->multisample_misc.depth_function = (enum mali_func)__gen_unpack_uint(cl, 280, 282);
2684 values->multisample_misc.depth_write_mask = __gen_unpack_uint(cl, 283, 283);
2685 values->multisample_misc.fixed_function_near_discard = __gen_unpack_uint(cl, 284, 284);
2686 values->multisample_misc.fixed_function_far_discard = __gen_unpack_uint(cl, 285, 285);
2687 values->multisample_misc.fragment_near_discard = __gen_unpack_uint(cl, 286, 286);
2688 values->multisample_misc.fragment_far_discard = __gen_unpack_uint(cl, 287, 287);
2689 values->stencil_mask_misc.stencil_mask_front = __gen_unpack_uint(cl, 288, 295);
2690 values->stencil_mask_misc.stencil_mask_back = __gen_unpack_uint(cl, 296, 303);
2691 values->stencil_mask_misc.stencil_enable = __gen_unpack_uint(cl, 304, 304);
2692 values->stencil_mask_misc.alpha_to_coverage = __gen_unpack_uint(cl, 305, 305);
2693 values->stencil_mask_misc.alpha_to_coverage_invert = __gen_unpack_uint(cl, 306, 306);
2694 values->stencil_mask_misc.alpha_to_one = __gen_unpack_uint(cl, 307, 307);
2695 values->stencil_mask_misc.write_enable = __gen_unpack_uint(cl, 308, 308);
2696 values->stencil_mask_misc.alpha_test_compare_function = (enum mali_func)__gen_unpack_uint(cl, 309, 311);
2697 values->stencil_mask_misc.srgb = __gen_unpack_uint(cl, 312, 312);
2698 values->stencil_mask_misc.dither_disable = __gen_unpack_uint(cl, 313, 313);
2699 values->stencil_mask_misc.force_seamless_cubemaps = __gen_unpack_uint(cl, 314, 314);
2700 values->stencil_mask_misc.depth_range_1 = __gen_unpack_uint(cl, 316, 316);
2701 values->stencil_mask_misc.depth_range_2 = __gen_unpack_uint(cl, 317, 317);
2702 values->stencil_mask_misc.single_sampled_lines = __gen_unpack_uint(cl, 318, 318);
2703 values->stencil_mask_misc.point_snap = __gen_unpack_uint(cl, 319, 319);
2704 values->stencil_front.reference_value = __gen_unpack_uint(cl, 320, 327);
2705 values->stencil_front.mask = __gen_unpack_uint(cl, 328, 335);
2706 values->stencil_front.compare_function = (enum mali_func)__gen_unpack_uint(cl, 336, 338);
2707 values->stencil_front.stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 339, 341);
2708 values->stencil_front.depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 342, 344);
2709 values->stencil_front.depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 345, 347);
2710 values->stencil_back.reference_value = __gen_unpack_uint(cl, 352, 359);
2711 values->stencil_back.mask = __gen_unpack_uint(cl, 360, 367);
2712 values->stencil_back.compare_function = (enum mali_func)__gen_unpack_uint(cl, 368, 370);
2713 values->stencil_back.stencil_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 371, 373);
2714 values->stencil_back.depth_fail = (enum mali_stencil_op)__gen_unpack_uint(cl, 374, 376);
2715 values->stencil_back.depth_pass = (enum mali_stencil_op)__gen_unpack_uint(cl, 377, 379);
2716 values->alpha_reference = __gen_unpack_float(cl, 384, 415);
2717 values->thread_balancing = __gen_unpack_uint(cl, 416, 431);
2718 values->blend_shader = __gen_unpack_uint(cl, 448, 511);
2719 values->blend_equation.rgb.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 448, 449);
2720 values->blend_equation.rgb.negate_a = __gen_unpack_uint(cl, 451, 451);
2721 values->blend_equation.rgb.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 452, 453);
2722 values->blend_equation.rgb.negate_b = __gen_unpack_uint(cl, 455, 455);
2723 values->blend_equation.rgb.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 456, 458);
2724 values->blend_equation.rgb.invert_c = __gen_unpack_uint(cl, 459, 459);
2725 values->blend_equation.alpha.a = (enum mali_blend_operand_a)__gen_unpack_uint(cl, 460, 461);
2726 values->blend_equation.alpha.negate_a = __gen_unpack_uint(cl, 463, 463);
2727 values->blend_equation.alpha.b = (enum mali_blend_operand_b)__gen_unpack_uint(cl, 464, 465);
2728 values->blend_equation.alpha.negate_b = __gen_unpack_uint(cl, 467, 467);
2729 values->blend_equation.alpha.c = (enum mali_blend_operand_c)__gen_unpack_uint(cl, 468, 470);
2730 values->blend_equation.alpha.invert_c = __gen_unpack_uint(cl, 471, 471);
2731 values->blend_equation.color_mask = __gen_unpack_uint(cl, 476, 479);
2732 values->blend_constant = __gen_unpack_float(cl, 480, 511);
2770 MALI_UNIFORM_BUFFER_pack(uint32_t * restrict cl,
2775 cl[ 0] = __gen_uint(values->entries - 1, 0, 11) |
2777 cl[ 1] = __gen_uint(values->pointer >> 4, 12, 63) >> 32;
2785 MALI_UNIFORM_BUFFER_unpack(const uint8_t * restrict cl,
2788 values->entries = __gen_unpack_uint(cl, 0, 11) + 1;
2789 values->pointer = __gen_unpack_uint(cl, 12, 63) << 4;
2823 MALI_VIEWPORT_pack(uint32_t * restrict cl,
2826 cl[ 0] = __gen_uint(fui(values->minimum_x), 0, 32);
2827 cl[ 1] = __gen_uint(fui(values->minimum_y), 0, 32);
2828 cl[ 2] = __gen_uint(fui(values->maximum_x), 0, 32);
2829 cl[ 3] = __gen_uint(fui(values->maximum_y), 0, 32);
2830 cl[ 4] = __gen_uint(fui(values->minimum_z), 0, 32);
2831 cl[ 5] = __gen_uint(fui(values->maximum_z), 0, 32);
2832 cl[ 6] = __gen_uint(values->scissor_minimum_x, 0, 15) |
2834 cl[ 7] = __gen_uint(values->scissor_maximum_x, 0, 15) |
2843 MALI_VIEWPORT_unpack(const uint8_t * restrict cl,
2846 values->minimum_x = __gen_unpack_float(cl, 0, 31);
2847 values->minimum_y = __gen_unpack_float(cl, 32, 63);
2848 values->maximum_x = __gen_unpack_float(cl, 64, 95);
2849 values->maximum_y = __gen_unpack_float(cl, 96, 127);
2850 values->minimum_z = __gen_unpack_float(cl, 128, 159);
2851 values->maximum_z = __gen_unpack_float(cl, 160, 191);
2852 values->scissor_minimum_x = __gen_unpack_uint(cl, 192, 207);
2853 values->scissor_minimum_y = __gen_unpack_uint(cl, 208, 223);
2854 values->scissor_maximum_x = __gen_unpack_uint(cl, 224, 239);
2855 values->scissor_maximum_y = __gen_unpack_uint(cl, 240, 255);
2888 MALI_LOCAL_STORAGE_pack(uint32_t * restrict cl,
2892 cl[ 0] = __gen_uint(values->tls_size, 0, 4) |
2894 cl[ 1] = __gen_uint(util_logbase2(values->wls_instances), 0, 4) |
2897 cl[ 2] = __gen_uint(values->tls_base_pointer, 0, 63);
2898 cl[ 3] = __gen_uint(values->tls_base_pointer, 0, 63) >> 32;
2899 cl[ 4] = __gen_uint(values->wls_base_pointer, 0, 63);
2900 cl[ 5] = __gen_uint(values->wls_base_pointer, 0, 63) >> 32;
2901 cl[ 6] = 0;
2902 cl[ 7] = 0;
2910 MALI_LOCAL_STORAGE_unpack(const uint8_t * restrict cl,
2913 if (((const uint32_t *) cl)[1] & 0xffffe080) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 1\n");
2914 if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 6\n");
2915 if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Local Storage unpacked at word 7\n");
2916 values->tls_size = __gen_unpack_uint(cl, 0, 4);
2917 values->tls_initial_stack_pointer_offset = __gen_unpack_uint(cl, 5, 31);
2918 values->wls_instances = 1U << __gen_unpack_uint(cl, 32, 36);
2919 values->wls_size_base = __gen_unpack_uint(cl, 37, 38);
2920 values->wls_size_scale = __gen_unpack_uint(cl, 40, 44);
2921 values->tls_base_pointer = __gen_unpack_uint(cl, 64, 127);
2922 values->wls_base_pointer = __gen_unpack_uint(cl, 128, 191);
2954 MALI_TILER_CONTEXT_pack(uint32_t * restrict cl,
2957 cl[ 0] = __gen_uint(values->polygon_list_size, 0, 31);
2958 cl[ 1] = __gen_uint(values->hierarchy_mask, 0, 15);
2959 cl[ 2] = __gen_uint(values->polygon_list, 0, 63);
2960 cl[ 3] = __gen_uint(values->polygon_list, 0, 63) >> 32;
2961 cl[ 4] = __gen_uint(values->polygon_list_body, 0, 63);
2962 cl[ 5] = __gen_uint(values->polygon_list_body, 0, 63) >> 32;
2963 cl[ 6] = __gen_uint(values->heap_start, 0, 63);
2964 cl[ 7] = __gen_uint(values->heap_start, 0, 63) >> 32;
2965 cl[ 8] = __gen_uint(values->heap_end, 0, 63);
2966 cl[ 9] = __gen_uint(values->heap_end, 0, 63) >> 32;
2973 MALI_TILER_CONTEXT_unpack(const uint8_t * restrict cl,
2976 if (((const uint32_t *) cl)[1] & 0xffff0000) fprintf(stderr, "XXX: Invalid field of Tiler Context unpacked at word 1\n");
2977 values->polygon_list_size = __gen_unpack_uint(cl, 0, 31);
2978 values->hierarchy_mask = __gen_unpack_uint(cl, 32, 47);
2979 values->polygon_list = __gen_unpack_uint(cl, 64, 127);
2980 values->polygon_list_body = __gen_unpack_uint(cl, 128, 191);
2981 values->heap_start = __gen_unpack_uint(cl, 192, 255);
2982 values->heap_end = __gen_unpack_uint(cl, 256, 319);
3011 MALI_TILER_WEIGHTS_pack(uint32_t * restrict cl,
3014 cl[ 0] = __gen_uint(values->weight0, 0, 31);
3015 cl[ 1] = __gen_uint(values->weight1, 0, 31);
3016 cl[ 2] = __gen_uint(values->weight2, 0, 31);
3017 cl[ 3] = __gen_uint(values->weight3, 0, 31);
3018 cl[ 4] = __gen_uint(values->weight4, 0, 31);
3019 cl[ 5] = __gen_uint(values->weight5, 0, 31);
3020 cl[ 6] = __gen_uint(values->weight6, 0, 31);
3021 cl[ 7] = __gen_uint(values->weight7, 0, 31);
3028 MALI_TILER_WEIGHTS_unpack(const uint8_t * restrict cl,
3031 values->weight0 = __gen_unpack_uint(cl, 0, 31);
3032 values->weight1 = __gen_unpack_uint(cl, 32, 63);
3033 values->weight2 = __gen_unpack_uint(cl, 64, 95);
3034 values->weight3 = __gen_unpack_uint(cl, 96, 127);
3035 values->weight4 = __gen_unpack_uint(cl, 128, 159);
3036 values->weight5 = __gen_unpack_uint(cl, 160, 191);
3037 values->weight6 = __gen_unpack_uint(cl, 192, 223);
3038 values->weight7 = __gen_unpack_uint(cl, 224, 255);
3268 MALI_RT_BUFFER_pack(uint32_t * restrict cl,
3271 cl[ 0] = __gen_uint(values->base, 0, 63);
3272 cl[ 1] = __gen_uint(values->base, 0, 63) >> 32;
3273 cl[ 2] = __gen_uint(values->row_stride, 0, 31);
3274 cl[ 3] = __gen_uint(values->surface_stride, 0, 31);
3281 MALI_RT_BUFFER_unpack(const uint8_t * restrict cl,
3284 values->base = __gen_unpack_uint(cl, 0, 63);
3285 values->row_stride = __gen_unpack_uint(cl, 64, 95);
3286 values->surface_stride = __gen_unpack_uint(cl, 96, 127);
3359 MALI_FRAMEBUFFER_PARAMETERS_pack(uint32_t * restrict cl,
3363 cl[ 0] = __gen_uint(values->internal_format, 0, 2) |
3374 cl[ 1] = __gen_uint(values->x_downsampling_scale, 0, 2) |
3389 cl[ 2] = __gen_uint(values->bound_min_x, 0, 15) |
3391 cl[ 3] = __gen_uint(values->bound_max_x, 0, 15) |
3393 cl[ 4] = __gen_uint(values->dcd_offset, 0, 31);
3394 cl[ 5] = 0;
3395 cl[ 6] = 0;
3396 cl[ 7] = 0;
3397 cl[ 8] = __gen_uint(values->crc_buffer.base, 0, 63);
3398 cl[ 9] = __gen_uint(values->crc_buffer.base, 0, 63) >> 32;
3399 cl[10] = __gen_uint(values->crc_buffer.row_stride, 0, 31);
3400 cl[11] = __gen_uint(values->crc_buffer.surface_stride, 0, 31);
3401 cl[12] = __gen_uint(values->color_writeback.base, 0, 63);
3402 cl[13] = __gen_uint(values->color_writeback.base, 0, 63) >> 32;
3403 cl[14] = __gen_uint(values->color_writeback.row_stride, 0, 31);
3404 cl[15] = __gen_uint(values->color_writeback.surface_stride, 0, 31);
3405 cl[16] = __gen_uint(values->zs_writeback.base, 0, 63);
3406 cl[17] = __gen_uint(values->zs_writeback.base, 0, 63) >> 32;
3407 cl[18] = __gen_uint(values->zs_writeback.row_stride, 0, 31);
3408 cl[19] = __gen_uint(values->zs_writeback.surface_stride, 0, 31);
3409 cl[20] = __gen_uint(values->s_writeback.base, 0, 63);
3410 cl[21] = __gen_uint(values->s_writeback.base, 0, 63) >> 32;
3411 cl[22] = __gen_uint(values->s_writeback.row_stride, 0, 31);
3412 cl[23] = __gen_uint(values->s_writeback.surface_stride, 0, 31);
3413 cl[24] = __gen_uint(values->color_load_address, 0, 63) |
3415 cl[25] = __gen_uint(values->color_load_address, 0, 63) >> 32 |
3417 cl[26] = __gen_uint(values->color_load_row_stride, 0, 31) |
3419 cl[27] = __gen_uint(values->color_load_surface_stride, 0, 31) |
3421 cl[28] = __gen_uint(values->zs_load_address, 0, 63) |
3423 cl[29] = __gen_uint(values->zs_load_address, 0, 63) >> 32;
3424 cl[30] = __gen_uint(values->zs_load_row_stride, 0, 31);
3425 cl[31] = __gen_uint(values->zs_load_surface_stride, 0, 31);
3426 cl[32] = __gen_uint(values->s_clear, 0, 7);
3427 cl[33] = 0;
3428 cl[34] = 0;
3429 cl[35] = 0;
3430 cl[36] = 0;
3431 cl[37] = 0;
3432 cl[38] = 0;
3433 cl[39] = 0;
3440 MALI_FRAMEBUFFER_PARAMETERS_unpack(const uint8_t * restrict cl,
3443 if (((const uint32_t *) cl)[1] & 0x40000000) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 1\n");
3444 if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 5\n");
3445 if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 6\n");
3446 if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 7\n");
3447 if (((const uint32_t *) cl)[32] & 0xffffff00) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 32\n");
3448 if (((const uint32_t *) cl)[33] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 33\n");
3449 if (((const uint32_t *) cl)[34] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 34\n");
3450 if (((const uint32_t *) cl)[35] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 35\n");
3451 if (((const uint32_t *) cl)[36] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 36\n");
3452 if (((const uint32_t *) cl)[37] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 37\n");
3453 if (((const uint32_t *) cl)[38] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 38\n");
3454 if (((const uint32_t *) cl)[39] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Parameters unpacked at word 39\n");
3455 values->internal_format = (enum mali_color_buffer_internal_format)__gen_unpack_uint(cl, 0, 2);
3456 values->sample_count = 1U << __gen_unpack_uint(cl, 3, 5);
3457 values->swizzle = __gen_unpack_uint(cl, 6, 17);
3458 values->color_writeback_format = (enum mali_color_format)__gen_unpack_uint(cl, 18, 22);
3459 values->msaa = (enum mali_msaa)__gen_unpack_uint(cl, 23, 24);
3460 values->srgb = __gen_unpack_uint(cl, 25, 25);
3461 values->color_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 26, 27);
3462 values->dithering_enable = __gen_unpack_uint(cl, 28, 28);
3463 values->clean_pixel_write_enable = __gen_unpack_uint(cl, 29, 29);
3464 values->color_preload_enable = __gen_unpack_uint(cl, 30, 30);
3465 values->color_write_enable = __gen_unpack_uint(cl, 31, 31);
3466 values->x_downsampling_scale = __gen_unpack_uint(cl, 32, 34);
3467 values->y_downsampling_scale = __gen_unpack_uint(cl, 35, 37);
3468 values->downsampling_accumulation_mode = (enum mali_downsampling_accumulation_mode)__gen_unpack_uint(cl, 38, 39);
3469 values->sample_layout = (enum mali_sample_layout)__gen_unpack_uint(cl, 40, 41);
3470 values->big_endian = __gen_unpack_uint(cl, 42, 42);
3471 values->tie_break_rule = (enum mali_tie_break_rule)__gen_unpack_uint(cl, 43, 45);
3472 values->crc_read_enable = __gen_unpack_uint(cl, 46, 46);
3473 values->crc_write_enable = __gen_unpack_uint(cl, 47, 47);
3474 values->zs_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 48, 49);
3475 values->zs_format = (enum mali_zs_format)__gen_unpack_uint(cl, 50, 53);
3476 values->zs_preload_enable = __gen_unpack_uint(cl, 54, 54);
3477 values->zs_write_enable = __gen_unpack_uint(cl, 55, 55);
3478 values->s_block_format = (enum mali_block_format)__gen_unpack_uint(cl, 56, 57);
3479 values->s_format = (enum mali_s_format)__gen_unpack_uint(cl, 58, 61);
3480 values->s_write_enable = __gen_unpack_uint(cl, 63, 63);
3481 values->bound_min_x = __gen_unpack_uint(cl, 64, 79);
3482 values->bound_min_y = __gen_unpack_uint(cl, 80, 95);
3483 values->bound_max_x = __gen_unpack_uint(cl, 96, 111);
3484 values->bound_max_y = __gen_unpack_uint(cl, 112, 127);
3485 values->dcd_offset = __gen_unpack_uint(cl, 128, 159);
3486 values->crc_buffer.base = __gen_unpack_uint(cl, 256, 319);
3487 values->crc_buffer.row_stride = __gen_unpack_uint(cl, 320, 351);
3488 values->crc_buffer.surface_stride = __gen_unpack_uint(cl, 352, 383);
3489 values->color_writeback.base = __gen_unpack_uint(cl, 384, 447);
3490 values->color_writeback.row_stride = __gen_unpack_uint(cl, 448, 479);
3491 values->color_writeback.surface_stride = __gen_unpack_uint(cl, 480, 511);
3492 values->zs_writeback.base = __gen_unpack_uint(cl, 512, 575);
3493 values->zs_writeback.row_stride = __gen_unpack_uint(cl, 576, 607);
3494 values->zs_writeback.surface_stride = __gen_unpack_uint(cl, 608, 639);
3495 cl, 640, 703);
3496 values->s_writeback.row_stride = __gen_unpack_uint(cl, 704, 735);
3497 values->s_writeback.surface_stride = __gen_unpack_uint(cl, 736, 767);
3498 values->color_load_address = __gen_unpack_uint(cl, 768, 831);
3499 values->color_load_row_stride = __gen_unpack_uint(cl, 832, 863);
3500 values->color_load_surface_stride = __gen_unpack_uint(cl, 864, 895);
3501 values->clear_color_0 = __gen_unpack_uint(cl, 768, 799);
3502 values->clear_color_1 = __gen_unpack_uint(cl, 800, 831);
3503 values->clear_color_2 = __gen_unpack_uint(cl, 832, 863);
3504 values->clear_color_3 = __gen_unpack_uint(cl, 864, 895);
3505 values->zs_load_address = __gen_unpack_uint(cl, 896, 959);
3506 values->zs_load_row_stride = __gen_unpack_uint(cl, 960, 991);
3507 values->zs_load_surface_stride = __gen_unpack_uint(cl, 992, 1023);
3508 values->z_clear = __gen_unpack_float(cl, 896, 927);
3509 values->s_clear = __gen_unpack_uint(cl, 1024, 1031);
3576 MALI_FRAMEBUFFER_PADDING_1_pack(uint32_t * restrict cl,
3579 cl[ 0] = 0;
3580 cl[ 1] = 0;
3581 cl[ 2] = 0;
3582 cl[ 3] = 0;
3583 cl[ 4] = 0;
3584 cl[ 5] = 0;
3591 MALI_FRAMEBUFFER_PADDING_1_unpack(const uint8_t * restrict cl,
3594 if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 0\n");
3595 if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 1\n");
3596 if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 2\n");
3597 if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 3\n");
3598 if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 4\n");
3599 if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 1 unpacked at word 5\n");
3615 MALI_FRAMEBUFFER_PADDING_2_pack(uint32_t * restrict cl,
3618 cl[ 0] = 0;
3619 cl[ 1] = 0;
3620 cl[ 2] = 0;
3621 cl[ 3] = 0;
3622 cl[ 4] = 0;
3623 cl[ 5] = 0;
3624 cl[ 6] = 0;
3625 cl[ 7] = 0;
3632 MALI_FRAMEBUFFER_PADDING_2_unpack(const uint8_t * restrict cl,
3635 if (((const uint32_t *) cl)[0] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 0\n");
3636 if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 1\n");
3637 if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 2\n");
3638 if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 3\n");
3639 if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 4\n");
3640 if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 5\n");
3641 if (((const uint32_t *) cl)[6] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 6\n");
3642 if (((const uint32_t *) cl)[7] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Framebuffer Padding 2 unpacked at word 7\n");
3736 MALI_JOB_HEADER_pack(uint32_t * restrict cl,
3739 cl[ 0] = __gen_uint(values->exception_status, 0, 31);
3740 cl[ 1] = __gen_uint(values->first_incomplete_task, 0, 31);
3741 cl[ 2] = __gen_uint(values->fault_pointer, 0, 63);
3742 cl[ 3] = __gen_uint(values->fault_pointer, 0, 63) >> 32;
3743 cl[ 4] = __gen_uint(values->is_64b, 0, 0) |
3752 cl[ 5] = __gen_uint(values->dependency_1, 0, 15) |
3754 cl[ 6] = __gen_uint(values->next, 0, 63);
3755 cl[ 7] = __gen_uint(values->next, 0, 63) >> 32;
3763 MALI_JOB_HEADER_unpack(const uint8_t * restrict cl,
3766 if (((const uint32_t *) cl)[4] & 0x2400) fprintf(stderr, "XXX: Invalid field of Job Header unpacked at word 4\n");
3767 values->exception_status = __gen_unpack_uint(cl, 0, 31);
3768 values->first_incomplete_task = __gen_unpack_uint(cl, 32, 63);
3769 values->fault_pointer = __gen_unpack_uint(cl, 64, 127);
3770 values->is_64b = __gen_unpack_uint(cl, 128, 128);
3771 values->type = (enum mali_job_type)__gen_unpack_uint(cl, 129, 135);
3772 values->barrier = __gen_unpack_uint(cl, 136, 136);
3773 values->invalidate_cache = __gen_unpack_uint(cl, 137, 137);
3774 values->suppress_prefetch = __gen_unpack_uint(cl, 139, 139);
3775 values->enable_texture_mapper = __gen_unpack_uint(cl, 140, 140);
3776 values->relax_dependency_1 = __gen_unpack_uint(cl, 142, 142);
3777 values->relax_dependency_2 = __gen_unpack_uint(cl, 143, 143);
3778 values->index = __gen_unpack_uint(cl, 144, 159);
3779 values->dependency_1 = __gen_unpack_uint(cl, 160, 175);
3780 values->dependency_2 = __gen_unpack_uint(cl, 176, 191);
3781 values->next = __gen_unpack_uint(cl, 192, 255);
3816 MALI_FRAGMENT_JOB_PAYLOAD_pack(uint32_t * restrict cl,
3819 cl[ 0] = __gen_uint(values->bound_min_x, 0, 11) |
3821 cl[ 1] = __gen_uint(values->bound_max_x, 0, 11) |
3823 cl[ 2] = __gen_uint(values->framebuffer, 0, 63);
3824 cl[ 3] = __gen_uint(values->framebuffer, 0, 63) >> 32;
3831 MALI_FRAGMENT_JOB_PAYLOAD_unpack(const uint8_t * restrict cl,
3834 if (((const uint32_t *) cl)[0] & 0xf000f000) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 0\n");
3835 if (((const uint32_t *) cl)[1] & 0xf000f000) fprintf(stderr, "XXX: Invalid field of Fragment Job Payload unpacked at word 1\n");
3836 values->bound_min_x = __gen_unpack_uint(cl, 0, 11);
3837 values->bound_min_y = __gen_unpack_uint(cl, 16, 27);
3838 values->bound_max_x = __gen_unpack_uint(cl, 32, 43);
3839 values->bound_max_y = __gen_unpack_uint(cl, 48, 59);
3840 values->framebuffer = __gen_unpack_uint(cl, 64, 127);
3898 MALI_WRITE_VALUE_JOB_PAYLOAD_pack(uint32_t * restrict cl,
3901 cl[ 0] = __gen_uint(values->address, 0, 63);
3902 cl[ 1] = __gen_uint(values->address, 0, 63) >> 32;
3903 cl[ 2] = __gen_uint(values->type, 0, 31);
3910 MALI_WRITE_VALUE_JOB_PAYLOAD_unpack(const uint8_t * restrict cl,
3913 values->address = __gen_unpack_uint(cl, 0, 63);
3914 values->type = (enum mali_write_value_type)__gen_unpack_uint(cl, 64, 95);
3940 MALI_CACHE_FLUSH_JOB_PAYLOAD_pack(uint32_t * restrict cl,
3943 cl[ 0] = __gen_uint(values->clean_shader_core_ls, 0, 0) |
3950 cl[ 1] = __gen_uint(values->l2_clean, 0, 0) |
3958 MALI_CACHE_FLUSH_JOB_PAYLOAD_unpack(const uint8_t * restrict cl,
3961 if (((const uint32_t *) cl)[0] & 0xfcfcfff8) fprintf(stderr, "XXX: Invalid field of Cache Flush Job Payload unpacked at word 0\n");
3962 if (((const uint32_t *) cl)[1] & 0xfffffffc) fprintf(stderr, "XXX: Invalid field of Cache Flush Job Payload unpacked at word 1\n");
3963 values->clean_shader_core_ls = __gen_unpack_uint(cl, 0, 0);
3964 values->invalidate_shader_core_ls = __gen_unpack_uint(cl, 1, 1);
3965 values->invalidate_shader_core_other = __gen_unpack_uint(cl, 2, 2);
3966 values->job_manager_clean = __gen_unpack_uint(cl, 16, 16);
3967 values->job_manager_invalidate = __gen_unpack_uint(cl, 17, 17);
3968 values->tiler_clean = __gen_unpack_uint(cl, 24, 24);
3969 values->tiler_invalidate = __gen_unpack_uint(cl, 25, 25);
3970 values->l2_clean = __gen_unpack_uint(cl, 32, 32);
3971 values->l2_invalidate = __gen_unpack_uint(cl, 33, 33);
4034 MALI_COMPUTE_JOB_PARAMETERS_pack(uint32_t * restrict cl,
4037 cl[ 0] = __gen_uint(values->job_task_split, 26, 29);
4038 cl[ 1] = 0;
4039 cl[ 2] = 0;
4040 cl[ 3] = 0;
4041 cl[ 4] = 0;
4042 cl[ 5] = 0;
4049 MALI_COMPUTE_JOB_PARAMETERS_unpack(const uint8_t * restrict cl,
4052 if (((const uint32_t *) cl)[0] & 0xc3ffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 0\n");
4053 if (((const uint32_t *) cl)[1] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 1\n");
4054 if (((const uint32_t *) cl)[2] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 2\n");
4055 if (((const uint32_t *) cl)[3] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 3\n");
4056 if (((const uint32_t *) cl)[4] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 4\n");
4057 if (((const uint32_t *) cl)[5] & 0xffffffff) fprintf(stderr, "XXX: Invalid field of Compute Job Parameters unpacked at word 5\n");
4058 values->job_task_split = __gen_unpack_uint(cl, 26, 29);
4107 MALI_PRIMITIVE_SIZE_pack(uint32_t * restrict cl,
4110 cl[ 0] = __gen_uint(fui(values->constant), 0, 32) |
4112 cl[ 1] = __gen_uint(values->size_array, 0, 63) >> 32;
4119 MALI_PRIMITIVE_SIZE_unpack(const uint8_t * restrict cl,
4122 values->constant = __gen_unpack_float(cl, 0, 31);
4123 values->size_array = __gen_unpack_uint(cl, 0, 63);
Indexes created Tue Oct 20 00:27:02 UTC 2026