2 * Copyright (c) 2019 Andreas Baierl <ichgeh@imkreisrum.de>
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sub license,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the
12 * next paragraph) shall be included in all copies or substantial portions
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 #include "util/u_math.h"
31 #include "lima_context.h"
32 #include "lima_parser.h"
33 #include "lima_texture.h"
39 static render_state_info render_state_infos
[] = {
40 { .info
= "BLEND_COLOR_BG", },
41 { .info
= "BLEND_COLOR_RA", },
42 { .info
= "ALPHA_BLEND", },
43 { .info
= "DEPTH_TEST", },
44 { .info
= "DEPTH_RANGE", },
45 { .info
= "STENCIL_FRONT", },
46 { .info
= "STENCIL_BACK", },
47 { .info
= "STENCIL_TEST", },
48 { .info
= "MULTI_SAMPLE", },
49 { .info
= "SHADER_ADDRESS (FS)", },
50 { .info
= "VARYING_TYPES", },
51 { .info
= "UNIFORMS_ADDRESS (PP)", },
52 { .info
= "TEXTURES_ADDRESS", },
55 { .info
= "VARYINGS_ADDRESS", },
58 /* VS CMD stream parser functions */
61 parse_vs_draw(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
63 if ((*value1
== 0x00000000) && (*value2
== 0x00000000))
64 fprintf(fp
, "\t/* ---EMPTY CMD */\n");
66 fprintf(fp
, "\t/* DRAW: num: %d, index_draw: %s */\n",
67 (*value1
& 0xff000000) >> 24 | (*value2
& 0x000000ff) << 8,
68 (*value1
& 0x00000001) ? "true" : "false");
72 parse_vs_shader_info(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
74 fprintf(fp
, "\t/* SHADER_INFO: prefetch: %d, size: %d */\n",
75 (*value1
& 0xfff00000) >> 20,
76 (((*value1
& 0x000fffff) >> 10) + 1) << 4);
80 parse_vs_unknown1(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
82 fprintf(fp
, "\t/* UNKNOWN_1 */\n");
86 parse_vs_varying_attribute_count(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
88 fprintf(fp
, "\t/* VARYING_ATTRIBUTE_COUNT: nr_vary: %d, nr_attr: %d */\n",
89 ((*value1
& 0x00ffffff) >> 8) + 1, (*value1
>> 24) + 1);
93 parse_vs_attributes_address(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
95 fprintf(fp
, "\t/* ATTRIBUTES_ADDRESS: address: 0x%08x, size: %d */\n",
96 *value1
, (*value2
& 0x0fffffff) >> 17);
100 parse_vs_varyings_address(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
102 fprintf(fp
, "\t/* VARYINGS_ADDRESS: varying info @ 0x%08x, size: %d */\n",
103 *value1
, (*value2
& 0x0fffffff) >> 17);
107 parse_vs_uniforms_address(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
109 fprintf(fp
, "\t/* UNIFORMS_ADDRESS (GP): address: 0x%08x, size: %d */\n",
110 *value1
, (*value2
& 0x0fffffff) >> 12);
114 parse_vs_shader_address(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
116 fprintf(fp
, "\t/* SHADER_ADDRESS (VS): address: 0x%08x, size: %d */\n",
117 *value1
, (*value2
& 0x0fffffff) >> 12);
121 parse_vs_semaphore(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
123 if (*value1
== 0x00028000)
124 fprintf(fp
, "\t/* SEMAPHORE_BEGIN_1 */\n");
125 else if (*value1
== 0x00000001)
126 fprintf(fp
, "\t/* SEMAPHORE_BEGIN_2 */\n");
127 else if (*value1
== 0x00000000)
128 fprintf(fp
, "\t/* SEMAPHORE_END: index_draw disabled */\n");
129 else if (*value1
== 0x00018000)
130 fprintf(fp
, "\t/* SEMAPHORE_END: index_draw enabled */\n");
132 fprintf(fp
, "\t/* SEMAPHORE - cmd unknown! */\n");
136 parse_vs_unknown2(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
138 fprintf(fp
, "\t/* UNKNOWN_2 */\n");
142 parse_vs_continue(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
144 fprintf(fp
, "\t/* CONTINUE: at 0x%08x */\n", *value1
);
148 lima_parse_vs(FILE *fp
, uint32_t *data
, int size
, uint32_t start
)
154 fprintf(fp
, "/* ============ VS CMD STREAM BEGIN ============= */\n");
155 for (int i
= 0; i
* 4 < size
; i
+= 2) {
157 value2
= &data
[i
+ 1];
158 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
159 start
+ i
* 4, i
* 4, *value1
, *value2
);
161 if ((*value2
& 0xffff0000) == 0x00000000)
162 parse_vs_draw(fp
, value1
, value2
);
163 else if ((*value2
& 0xff0000ff) == 0x10000040)
164 parse_vs_shader_info(fp
, value1
, value2
);
165 else if ((*value2
& 0xff0000ff) == 0x10000041)
166 parse_vs_unknown1(fp
, value1
, value2
);
167 else if ((*value2
& 0xff0000ff) == 0x10000042)
168 parse_vs_varying_attribute_count(fp
, value1
, value2
);
169 else if ((*value2
& 0xff0000ff) == 0x20000000)
170 parse_vs_attributes_address(fp
, value1
, value2
);
171 else if ((*value2
& 0xff0000ff) == 0x20000008)
172 parse_vs_varyings_address(fp
, value1
, value2
);
173 else if ((*value2
& 0xff000000) == 0x30000000)
174 parse_vs_uniforms_address(fp
, value1
, value2
);
175 else if ((*value2
& 0xff000000) == 0x40000000)
176 parse_vs_shader_address(fp
, value1
, value2
);
177 else if ((*value2
& 0xff000000)== 0x50000000)
178 parse_vs_semaphore(fp
, value1
, value2
);
179 else if ((*value2
& 0xff000000) == 0x60000000)
180 parse_vs_unknown2(fp
, value1
, value2
);
181 else if ((*value2
& 0xff000000) == 0xf0000000)
182 parse_vs_continue(fp
, value1
, value2
);
184 fprintf(fp
, "\t/* --- unknown cmd --- */\n");
186 fprintf(fp
, "/* ============ VS CMD STREAM END =============== */\n");
190 /* PLBU CMD stream parser functions */
193 parse_plbu_block_step(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
195 fprintf(fp
, "\t/* BLOCK_STEP: shift_min: %d, shift_h: %d, shift_w: %d */\n",
196 (*value1
& 0xf0000000) >> 28,
197 (*value1
& 0x0fff0000) >> 16,
198 *value1
& 0x0000ffff);
202 parse_plbu_tiled_dimensions(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
204 fprintf(fp
, "\t/* TILED_DIMENSIONS: tiled_w: %d, tiled_h: %d */\n",
205 ((*value1
& 0xff000000) >> 24) + 1,
206 ((*value1
& 0x00ffff00) >> 8) + 1);
210 parse_plbu_block_stride(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
212 fprintf(fp
, "\t/* BLOCK_STRIDE: block_w: %d */\n", *value1
& 0x000000ff);
216 parse_plbu_array_address(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
218 fprintf(fp
, "\t/* ARRAY_ADDRESS: gp_stream: 0x%08x, block_num (block_w * block_h): %d */\n",
219 *value1
, (*value2
& 0x00ffffff) + 1);
223 parse_plbu_viewport_left(FILE *fp
, float *value1
, uint32_t *value2
)
225 fprintf(fp
, "\t/* VIEWPORT_LEFT: viewport_left: %f */\n", *value1
);
229 parse_plbu_viewport_right(FILE *fp
, float *value1
, uint32_t *value2
)
231 fprintf(fp
, "\t/* VIEWPORT_RIGHT: viewport_right: %f */\n", *value1
);
235 parse_plbu_viewport_bottom(FILE *fp
, float *value1
, uint32_t *value2
)
237 fprintf(fp
, "\t/* VIEWPORT_BOTTOM: viewport_bottom: %f */\n", *value1
);
241 parse_plbu_viewport_top(FILE *fp
, float *value1
, uint32_t *value2
)
243 fprintf(fp
, "\t/* VIEWPORT_TOP: viewport_top: %f */\n", *value1
);
247 parse_plbu_semaphore(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
249 if (*value1
== 0x00010002)
250 fprintf(fp
, "\t/* ARRAYS_SEMAPHORE_BEGIN */\n");
251 else if (*value1
== 0x00010001)
252 fprintf(fp
, "\t/* ARRAYS_SEMAPHORE_END */\n");
254 fprintf(fp
, "\t/* SEMAPHORE - cmd unknown! */\n");
258 parse_plbu_primitive_setup(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
260 if (*value1
== 0x00000200)
261 fprintf(fp
, "\t/* UNKNOWN_2 (PRIMITIVE_SETUP INIT?) */\n");
263 fprintf(fp
, "\t/* PRIMITIVE_SETUP: %scull: %d (0x%x), index_size: %d */\n",
264 (*value1
& 0x1000) ? "force point size, " : "",
265 (*value1
& 0x000f0000) >> 16, (*value1
& 0x000f0000) >> 16,
266 (*value1
& 0x00000e00) >> 9);
270 parse_plbu_rsw_vertex_array(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
272 fprintf(fp
, "\t/* RSW_VERTEX_ARRAY: rsw: 0x%08x, gl_pos: 0x%08x */\n",
274 (*value2
& 0x0fffffff) << 4);
278 parse_plbu_scissors(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
280 float minx
= (*value1
& 0xc0000000) >> 30 | (*value2
& 0x00001fff) << 2;
281 float maxx
= ((*value2
& 0x0fffe000) >> 13) + 1;
282 float miny
= *value1
& 0x00003fff;
283 float maxy
= ((*value1
& 0x3fff8000) >> 15) + 1;
285 fprintf(fp
, "\t/* SCISSORS: minx: %f, maxx: %f, miny: %f, maxy: %f */\n",
286 minx
, maxx
, miny
, maxy
);
290 parse_plbu_unknown_1(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
292 fprintf(fp
, "\t/* UNKNOWN_1 */\n");
296 parse_plbu_low_prim_size(FILE *fp
, float *value1
, uint32_t *value2
)
298 fprintf(fp
, "\t/* LOW_PRIM_SIZE: size: %f */\n", *value1
);
302 parse_plbu_depth_range_near(FILE *fp
, float *value1
, uint32_t *value2
)
304 fprintf(fp
, "\t/* DEPTH_RANG_NEAR: depth_range: %f */\n", *value1
);
308 parse_plbu_depth_range_far(FILE *fp
, float *value1
, uint32_t *value2
)
310 fprintf(fp
, "\t/* DEPTH_RANGE_FAR: depth_range: %f */\n", *value1
);
314 parse_plbu_indexed_dest(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
316 fprintf(fp
, "\t/* INDEXED_DEST: gl_pos: 0x%08x */\n", *value1
);
320 parse_plbu_indexed_pt_size(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
322 fprintf(fp
, "\t/* INDEXED_PT_SIZE: pt_size: 0x%08x */\n", *value1
);
326 parse_plbu_indices(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
328 fprintf(fp
, "\t/* INDICES: indices: 0x%08x */\n", *value1
);
332 parse_plbu_draw_arrays(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
334 if ((*value1
== 0x00000000) && (*value2
== 0x00000000)) {
335 fprintf(fp
, "\t/* ---EMPTY CMD */\n");
339 uint32_t count
= (*value1
& 0xff000000) >> 24 | (*value2
& 0x000000ff) << 8;
340 uint32_t start
= *value1
& 0x00ffffff;
341 uint32_t mode
= (*value2
& 0x001f0000) >> 16;
343 fprintf(fp
, "\t/* DRAW_ARRAYS: count: %d, start: %d, mode: %d (0x%x) */\n",
344 count
, start
, mode
, mode
);
348 parse_plbu_draw_elements(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
350 uint32_t count
= (*value1
& 0xff000000) >> 24 | (*value2
& 0x000000ff) << 8;
351 uint32_t start
= *value1
& 0x00ffffff;
352 uint32_t mode
= (*value2
& 0x001f0000) >> 16;
354 fprintf(fp
, "\t/* DRAW_ELEMENTS: count: %d, start: %d, mode: %d (0x%x) */\n",
355 count
, start
, mode
, mode
);
359 parse_plbu_continue(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
361 fprintf(fp
, "\t/* CONTINUE: continue at 0x%08x */\n", *value1
);
365 parse_plbu_end(FILE *fp
, uint32_t *value1
, uint32_t *value2
)
367 fprintf(fp
, "\t/* END (FINISH/FLUSH) */\n");
371 lima_parse_plbu(FILE *fp
, uint32_t *data
, int size
, uint32_t start
)
376 fprintf(fp
, "/* ============ PLBU CMD STREAM BEGIN ============= */\n");
377 for (int i
= 0; i
* 4 < size
; i
+= 2) {
379 value2
= &data
[i
+ 1];
380 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
381 start
+ i
* 4, i
* 4, *value1
, *value2
);
383 if ((*value2
& 0xffe00000) == 0x00000000)
384 parse_plbu_draw_arrays(fp
, value1
, value2
);
385 else if ((*value2
& 0xffe00000) == 0x00200000)
386 parse_plbu_draw_elements(fp
, value1
, value2
);
387 else if ((*value2
& 0xff000fff) == 0x10000100)
388 parse_plbu_indexed_dest(fp
, value1
, value2
);
389 else if ((*value2
& 0xff000fff) == 0x10000101)
390 parse_plbu_indices(fp
, value1
, value2
);
391 else if ((*value2
& 0xff000fff) == 0x10000102)
392 parse_plbu_indexed_pt_size(fp
, value1
, value2
);
393 else if ((*value2
& 0xff000fff) == 0x10000105)
394 parse_plbu_viewport_bottom(fp
, (float *)value1
, value2
);
395 else if ((*value2
& 0xff000fff) == 0x10000106)
396 parse_plbu_viewport_top(fp
, (float *)value1
, value2
);
397 else if ((*value2
& 0xff000fff) == 0x10000107)
398 parse_plbu_viewport_left(fp
, (float *)value1
, value2
);
399 else if ((*value2
& 0xff000fff) == 0x10000108)
400 parse_plbu_viewport_right(fp
, (float *)value1
, value2
);
401 else if ((*value2
& 0xff000fff) == 0x10000109)
402 parse_plbu_tiled_dimensions(fp
, value1
, value2
);
403 else if ((*value2
& 0xff000fff) == 0x1000010a)
404 parse_plbu_unknown_1(fp
, value1
, value2
);
405 else if ((*value2
& 0xff000fff) == 0x1000010b) /* also unknown_2 */
406 parse_plbu_primitive_setup(fp
, value1
, value2
);
407 else if ((*value2
& 0xff000fff) == 0x1000010c)
408 parse_plbu_block_step(fp
, value1
, value2
);
409 else if ((*value2
& 0xff000fff) == 0x1000010d)
410 parse_plbu_low_prim_size(fp
, (float *)value1
, value2
);
411 else if ((*value2
& 0xff000fff) == 0x1000010e)
412 parse_plbu_depth_range_near(fp
, (float *)value1
, value2
);
413 else if ((*value2
& 0xff000fff) == 0x1000010f)
414 parse_plbu_depth_range_far(fp
, (float *)value1
, value2
);
415 else if ((*value2
& 0xff000000) == 0x28000000)
416 parse_plbu_array_address(fp
, value1
, value2
);
417 else if ((*value2
& 0xf0000000) == 0x30000000)
418 parse_plbu_block_stride(fp
, value1
, value2
);
419 else if (*value2
== 0x50000000)
420 parse_plbu_end(fp
, value1
, value2
);
421 else if ((*value2
& 0xf0000000)== 0x60000000)
422 parse_plbu_semaphore(fp
, value1
, value2
);
423 else if ((*value2
& 0xf0000000)== 0x70000000)
424 parse_plbu_scissors(fp
, value1
, value2
);
425 else if ((*value2
& 0xf0000000)== 0x80000000)
426 parse_plbu_rsw_vertex_array(fp
, value1
, value2
);
427 else if ((*value2
& 0xf0000000)== 0xf0000000)
428 parse_plbu_continue(fp
, value1
, value2
);
430 fprintf(fp
, "\t/* --- unknown cmd --- */\n");
432 fprintf(fp
, "/* ============ PLBU CMD STREAM END =============== */\n");
437 parse_rsw(FILE *fp
, uint32_t *value
, int i
, uint32_t *helper
)
439 fprintf(fp
, "\t/* %s", render_state_infos
[i
].info
);
442 case 0: /* BLEND COLOR BG */
443 fprintf(fp
, ": blend_color.color[1] = %f, blend_color.color[2] = %f */\n",
444 (float)(ubyte_to_float((*value
& 0xffff0000) >> 16)),
445 (float)(ubyte_to_float(*value
& 0x0000ffff)));
447 case 1: /* BLEND COLOR RA */
448 fprintf(fp
, ": blend_color.color[3] = %f, blend_color.color[0] = %f */\n",
449 (float)(ubyte_to_float((*value
& 0xffff0000) >> 16)),
450 (float)(ubyte_to_float(*value
& 0x0000ffff)));
452 case 2: /* ALPHA BLEND */
453 fprintf(fp
, "(1): colormask 0x%02x, rgb_func %d, alpha_func %d */\n",
454 (*value
& 0xf0000000) >> 28, /* colormask */
455 (*value
& 0x00000007), /* rgb_func */
456 (*value
& 0x00000038) >> 3); /* alpha_func */
457 /* add a few tabs for alignment */
458 fprintf(fp
, "\t\t\t\t\t\t/* %s(2)", render_state_infos
[i
].info
);
459 fprintf(fp
, ": rgb_src_factor %d, rbg_dst_factor %d */\n",
460 (*value
& 0x000007c0) >> 6, /* rgb_src_factor */
461 (*value
& 0x0000f800) >> 11); /* rgb_dst_factor */
462 fprintf(fp
, "\t\t\t\t\t\t/* %s(3)", render_state_infos
[i
].info
);
463 fprintf(fp
, ": alpha_src_factor %d, alpha_dst_factor %d, bits 24-27 0x%02x */\n",
464 (*value
& 0x000f0000) >> 16, /* alpha_src_factor */
465 (*value
& 0x00f00000) >> 20, /* alpha_dst_factor */
466 (*value
& 0x0f000000) >> 24); /* bits 24-27 */
468 case 3: /* DEPTH TEST */
469 if ((*value
& 0x00000001) == 0x00000001)
470 fprintf(fp
, "(1): depth test enabled && writes allowed");
472 fprintf(fp
, "(1): depth test disabled || writes not allowed");
474 fprintf(fp
, "\n\t\t\t\t\t\t/* %s(2)", render_state_infos
[i
].info
);
475 fprintf(fp
, ": PIPE_FUNC_%d", (*value
& 0x0000000e) >> 1);
476 fprintf(fp
, ", offset_scale: %d", (*value
& 0x00ff0000) >> 16);
477 fprintf(fp
, ", offset_units: %d", (*value
& 0xff000000) >> 24);
478 fprintf(fp
, ", unknown bits 4-15: 0x%08x */\n", *value
& 0x0000fff0);
480 case 4: /* DEPTH RANGE */
481 fprintf(fp
, ": viewport.far = %f, viewport.near = %f */\n",
482 (float)(ushort_to_float((*value
& 0xffff0000) >> 16)),
483 (float)(ushort_to_float(*value
& 0x0000ffff)));
485 case 5: /* STENCIL FRONT */
486 fprintf(fp
, "(1): valuemask 0x%02x, ref value %d (0x%02x), stencil_func %d */\n",
487 (*value
& 0xff000000) >> 24, /* valuemask */
488 (*value
& 0x00ff0000) >> 16, (*value
& 0x00ff0000) >> 16, /* ref value */
489 (*value
& 0x00000007)); /* stencil_func */
490 /* add a few tabs for alignment */
491 fprintf(fp
, "\t\t\t\t\t\t/* %s(2)", render_state_infos
[i
].info
);
492 fprintf(fp
, ": fail_op %d, zfail_op %d, zpass_op %d, unknown (12-15) 0x%02x */\n",
493 (*value
& 0x00000038) >> 3, /* fail_op */
494 (*value
& 0x000001c0) >> 6, /* zfail_op */
495 (*value
& 0x00000e00) >> 9, /* zpass_op */
496 (*value
& 0x0000f000) >> 12); /* unknown */
498 case 6: /* STENCIL BACK */
499 fprintf(fp
, "(1): valuemask 0x%02x, ref value %d (0x%02x), stencil_func %d */\n",
500 (*value
& 0xff000000) >> 24, /* valuemask */
501 (*value
& 0x00ff0000) >> 16, (*value
& 0x00ff0000) >> 16, /* ref value */
502 (*value
& 0x00000007)); /* stencil_func */
503 /* add a few tabs for alignment */
504 fprintf(fp
, "\t\t\t\t\t\t/* %s(2)", render_state_infos
[i
].info
);
505 fprintf(fp
, ": fail_op %d, zfail_op %d, zpass_op %d, unknown (12-15) 0x%02x */\n",
506 (*value
& 0x00000038) >> 3, /* fail_op */
507 (*value
& 0x000001c0) >> 6, /* zfail_op */
508 (*value
& 0x00000e00) >> 9, /* zpass_op */
509 (*value
& 0x0000f000) >> 12); /* unknown */
511 case 7: /* STENCIL TEST */
512 fprintf(fp
, "(1): stencil_front writemask 0x%02x, stencil_back writemask 0x%02x */\n",
513 (*value
& 0x000000ff), /* front writemask */
514 (*value
& 0x0000ff00) >> 8); /* back writemask */
515 /* add a few tabs for alignment */
516 fprintf(fp
, "\t\t\t\t\t\t/* %s(2)", render_state_infos
[i
].info
);
517 fprintf(fp
, ": unknown (bits 16-31) 0x%04x */\n",
518 (*value
& 0xffff0000) >> 16); /* unknown, alpha ref_value? */
520 case 8: /* MULTI SAMPLE */
521 if ((*value
& 0x00000f00) == 0x00000000)
522 fprintf(fp
, ": points");
523 else if ((*value
& 0x00000f00) == 0x00000400)
524 fprintf(fp
, ": lines");
525 else if ((*value
& 0x00000f00) == 0x00000800)
526 fprintf(fp
, ": triangles");
528 fprintf(fp
, ": unknown");
530 if ((*value
& 0x00000078) == 0x00000068)
531 fprintf(fp
, ", fb_samples */\n");
532 else if ((*value
& 0x00000078) == 0x00000000)
533 fprintf(fp
, " */\n");
535 fprintf(fp
, ", UNKNOWN\n");
537 case 9: /* SHADER ADDRESS */
538 fprintf(fp
, ": fs shader @ 0x%08x, first instr length %d */\n",
539 *value
& 0xffffffe0, *value
& 0x0000001f);
541 case 10: /* VARYING TYPES */
542 fprintf(fp
, "(1): ");
545 for (j
= 0; j
< 6; j
++) {
546 val
= *value
& (0x07 << (j
* 3));
547 fprintf(fp
, "val %d-%d, ", j
, val
);
550 /* add a few tabs for alignment */
551 fprintf(fp
, "\n\t\t\t\t\t\t/* %s(2): ", render_state_infos
[i
].info
);
552 for (j
= 6; j
< 10; j
++) {
553 val
= *value
& (0x07 << (j
* 3));
554 fprintf(fp
, "val %d-%d, ", j
, val
);
557 val
= ((*value
& 0x0c000000) >> 30) | ((*helper
& 0x00000001) << 2);
558 fprintf(fp
, "val %d-%d, ", j
, val
);
561 val
= (*helper
& 0x0000000e) >> 1;
562 fprintf(fp
, "val %d-%d */\n", j
, val
);
564 case 11: /* UNIFORMS ADDRESS */
565 fprintf(fp
, ": pp uniform info @ 0x%08x, bits: 0x%01x */\n",
566 *value
& 0xfffffff0, *value
& 0x0000000f);
568 case 12: /* TEXTURES ADDRESS */
569 fprintf(fp
, ": address: 0x%08x */\n", *value
);
572 fprintf(fp
, "(1): varying_stride: %d", /* bits 0 - 4 varying stride, 8 aligned */
573 (*value
& 0x0000001f) << 3);
574 if ((*value
& 0x00000020) == 0x00000020) /* bit 5 has num_samplers */
575 fprintf(fp
, ", num_samplers %d",
576 (*value
& 0xffffc000) >> 14); /* bits 14 - 31 num_samplers */
578 if ((*value
& 0x00000080) == 0x00000080) /* bit 7 has_fs_uniforms */
579 fprintf(fp
, ", has_fs_uniforms */");
583 fprintf(fp
, "\n\t\t\t\t\t\t/* %s(2):", render_state_infos
[i
].info
);
584 if ((*value
& 0x00000200) == 0x00000200) /* bit 9 early-z */
585 fprintf(fp
, " early-z enabled");
587 fprintf(fp
, " early-z disabled");
589 if ((*value
& 0x00001000) == 0x00001000) /* bit 12 pixel-kill */
590 fprintf(fp
, ", pixel kill enabled");
592 fprintf(fp
, ", pixel kill disabled");
594 if ((*value
& 0x00000040) == 0x00000040) /* bit 6 unknown */
595 fprintf(fp
, ", bit 6 set");
597 if ((*value
& 0x00000100) == 0x00000100) /* bit 8 unknown */
598 fprintf(fp
, ", bit 8 set");
600 if (((*value
& 0x00000c00) >> 10) > 0) /* bit 10 - 11 unknown */
601 fprintf(fp
, ", bit 10 - 11: %d", ((*value
& 0x00000c00) >> 10));
603 if ((*value
& 0x00002000) == 0x00002000) /* bit 13 unknown */
604 fprintf(fp
, ", bit 13 set");
605 fprintf(fp
, " */\n");
609 if ((*value
& 0x00002000) == 0x00002000)
610 fprintf(fp
, "blend->base.dither true, ");
611 if ((*value
& 0x00010000) == 0x00010000)
612 fprintf(fp
, "ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer true ");
615 case 15: /* VARYINGS ADDRESS */
616 fprintf(fp
, ": varyings @ 0x%08x */\n", *value
& 0xfffffff0);
618 default: /* should never be executed! */
619 fprintf(fp
, ": something went wrong!!! */\n");
625 lima_parse_render_state(FILE *fp
, uint32_t *data
, int size
, uint32_t start
)
629 fprintf(fp
, "/* ============ RSW BEGIN ========================= */\n");
630 for (int i
= 0; i
* 4 < size
; i
++) {
632 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x",
633 start
+ i
* 4, i
* 4, *value
);
635 parse_rsw(fp
, value
, i
, &data
[15]);
637 parse_rsw(fp
, value
, i
, NULL
);
639 fprintf(fp
, "/* ============ RSW END =========================== */\n");
643 parse_texture(FILE *fp
, uint32_t *data
, uint32_t start
, uint32_t offset
)
647 lima_tex_desc
*desc
= (lima_tex_desc
*)&data
[offset
];
650 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x\n",
651 start
+ i
* 4, i
* 4, *(&data
[i
+ offset
]));
653 fprintf(fp
, "\t format: 0x%x (%d)\n", desc
->format
, desc
->format
);
654 fprintf(fp
, "\t flag1: 0x%x (%d)\n", desc
->flag1
, desc
->flag1
);
655 fprintf(fp
, "\t swap_r_b: 0x%x (%d)\n", desc
->swap_r_b
, desc
->swap_r_b
);
656 fprintf(fp
, "\t unknown_0_1: 0x%x (%d)\n", desc
->unknown_0_1
, desc
->unknown_0_1
);
657 fprintf(fp
, "\t stride: 0x%x (%d)\n", desc
->stride
, desc
->stride
);
658 fprintf(fp
, "\t unknown_0_2: 0x%x (%d)\n", desc
->unknown_0_2
, desc
->unknown_0_2
);
661 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x 0x%08x\n",
662 start
+ i
* 4, i
* 4, *(&data
[i
+ offset
]), *(&data
[i
+ 1 + offset
]), *(&data
[i
+ 2 + offset
]));
664 fprintf(fp
, "\t unknown_1_1: 0x%x (%d)\n", desc
->unknown_1_1
, desc
->unknown_1_1
);
665 fprintf(fp
, "\t unnorm_coords: 0x%x (%d)\n", desc
->unnorm_coords
, desc
->unnorm_coords
);
666 fprintf(fp
, "\t unknown_1_2: 0x%x (%d)\n", desc
->unknown_1_2
, desc
->unknown_1_2
);
667 fprintf(fp
, "\t texture_type: 0x%x (%d)\n", desc
->texture_type
, desc
->texture_type
);
668 fprintf(fp
, "\t min_lod: 0x%x (%d) (%f)\n", desc
->min_lod
, desc
->min_lod
, lima_fixed8_to_float(desc
->min_lod
));
669 fprintf(fp
, "\t max_lod: 0x%x (%d) (%f)\n", desc
->max_lod
, desc
->max_lod
, lima_fixed8_to_float(desc
->max_lod
));
670 fprintf(fp
, "\t lod_bias: 0x%x (%d) (%f)\n", desc
->lod_bias
, desc
->lod_bias
, lima_fixed8_to_float(desc
->lod_bias
));
671 fprintf(fp
, "\t unknown_2_1: 0x%x (%d)\n", desc
->unknown_2_1
, desc
->unknown_2_1
);
672 fprintf(fp
, "\t has_stride: 0x%x (%d)\n", desc
->has_stride
, desc
->has_stride
);
673 fprintf(fp
, "\t min_mipfilter_2: 0x%x (%d)\n", desc
->min_mipfilter_2
, desc
->min_mipfilter_2
);
674 fprintf(fp
, "\t min_img_filter_nearest: 0x%x (%d)\n", desc
->min_img_filter_nearest
, desc
->min_img_filter_nearest
);
675 fprintf(fp
, "\t mag_img_filter_nearest: 0x%x (%d)\n", desc
->mag_img_filter_nearest
, desc
->mag_img_filter_nearest
);
676 fprintf(fp
, "\t wrap_s_clamp_to_edge: 0x%x (%d)\n", desc
->wrap_s_clamp_to_edge
, desc
->wrap_s_clamp_to_edge
);
677 fprintf(fp
, "\t wrap_s_clamp: 0x%x (%d)\n", desc
->wrap_s_clamp
, desc
->wrap_s_clamp
);
678 fprintf(fp
, "\t wrap_s_mirror_repeat: 0x%x (%d)\n", desc
->wrap_s_mirror_repeat
, desc
->wrap_s_mirror_repeat
);
679 fprintf(fp
, "\t wrap_t_clamp_to_edge: 0x%x (%d)\n", desc
->wrap_t_clamp_to_edge
, desc
->wrap_t_clamp_to_edge
);
680 fprintf(fp
, "\t wrap_t_clamp: 0x%x (%d)\n", desc
->wrap_t_clamp
, desc
->wrap_t_clamp
);
681 fprintf(fp
, "\t wrap_t_mirror_repeat: 0x%x (%d)\n", desc
->wrap_t_mirror_repeat
, desc
->wrap_t_mirror_repeat
);
682 fprintf(fp
, "\t unknown_2_2: 0x%x (%d)\n", desc
->unknown_2_2
, desc
->unknown_2_2
);
683 fprintf(fp
, "\t width: 0x%x (%d)\n", desc
->width
, desc
->width
);
684 fprintf(fp
, "\t height: 0x%x (%d)\n", desc
->height
, desc
->height
);
685 fprintf(fp
, "\t unknown_3_1: 0x%x (%d)\n", desc
->unknown_3_1
, desc
->unknown_3_1
);
686 fprintf(fp
, "\t unknown_3_2: 0x%x (%d)\n", desc
->unknown_3_2
, desc
->unknown_3_2
);
689 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x\n",
690 start
+ i
* 4, i
* 4, *(&data
[i
+ offset
]));
692 fprintf(fp
, "\t unknown_4: 0x%x (%d)\n", desc
->unknown_4
, desc
->unknown_4
);
695 fprintf(fp
, "/* 0x%08x (0x%08x) */\t0x%08x\n",
696 start
+ i
* 4, i
* 4, *(&data
[i
+ offset
]));
698 fprintf(fp
, "\t unknown_5: 0x%x (%d)\n", desc
->unknown_5
, desc
->unknown_5
);
701 fprintf(fp
, "/* 0x%08x (0x%08x) */",
702 start
+ i
* 4, i
* 4);
705 int miplevels
= (int)lima_fixed8_to_float(desc
->max_lod
);
706 for (int k
= 0; k
< ((((miplevels
+ 1) * 26) + 64) / 32); k
++)
707 fprintf(fp
, "0x%08x ", *(&data
[i
+ offset
+ k
]));
711 fprintf(fp
, "\t unknown_6_1: 0x%x (%d)\n", desc
->va_s
.unknown_6_1
, desc
->va_s
.unknown_6_1
);
712 fprintf(fp
, "\t layout: 0x%x (%d)\n", desc
->va_s
.layout
, desc
->va_s
.layout
);
713 fprintf(fp
, "\t unknown_6_2: 0x%x (%d)\n", desc
->va_s
.unknown_6_2
, desc
->va_s
.unknown_6_2
);
714 fprintf(fp
, "\t unknown_6_3: 0x%x (%d)\n", desc
->va_s
.unknown_6_3
, desc
->va_s
.unknown_6_3
);
717 fprintf(fp
, "\t va_0: 0x%x \n", desc
->va_s
.va_0
<< 6);
719 /* second level up to desc->miplevels */
726 for (j
= 1; j
<= miplevels
; j
++) {
731 va_bit_idx
= VA_BIT_OFFSET
+ (VA_BIT_SIZE
* j
);
732 va_idx
= va_bit_idx
/ 32;
735 /* the first (32 - va_bit_idx) bits */
736 va_1
|= (*(&data
[i
+ offset
+ va_idx
- 1]) >> va_bit_idx
);
738 /* do we need some bits from the following word? */
739 if (va_bit_idx
> 6) {
740 /* shift left and right again to erase the unneeded bits, keep space for va1 */
741 va_2
|= (*(&data
[i
+ offset
+ va_idx
]) << (2 * 32 - VA_BIT_SIZE
- va_bit_idx
));
742 va_2
>>= ((2 * 32 - VA_BIT_SIZE
- va_bit_idx
) - (32 - va_bit_idx
));
747 fprintf(fp
, "\t va_%d: 0x%x \n", j
, va
);
752 lima_parse_texture_descriptor(FILE *fp
, uint32_t *data
, int size
, uint32_t start
, uint32_t offset
)
754 fprintf(fp
, "/* ============ TEXTURE BEGIN ===================== */\n");
755 parse_texture(fp
, data
, start
, offset
);
756 fprintf(fp
, "/* ============ TEXTURE END ======================= */\n");