src/gallium/drivers/lima/lima_parser.c

   1 /*
   2  * Copyright (c) 2019 Andreas Baierl <ichgeh@imkreisrum.de>
   3  *
   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:
  10  *
  11  * The above copyright notice and this permission notice (including the
  12  * next paragraph) shall be included in all copies or substantial portions
  13  * of the Software.
  14  *
  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.
  22  *
  23  */
  24
  25 #include "util/u_math.h"
  26
  27 #include <assert.h>
  28 #include <stdio.h>
  29 #include <stdint.h>
  30 #include <string.h>
  31
  32 #include "lima_context.h"
  33 #include "lima_parser.h"
  34 #include "lima_texture.h"
  35
  36 typedef struct {
  37    char *info;
  38 } render_state_info;
  39
  40 static render_state_info render_state_infos[] = {
  41    { .info = "BLEND_COLOR_BG", },
  42    { .info = "BLEND_COLOR_RA", },
  43    { .info = "ALPHA_BLEND", },
  44    { .info = "DEPTH_TEST", },
  45    { .info = "DEPTH_RANGE", },
  46    { .info = "STENCIL_FRONT", },
  47    { .info = "STENCIL_BACK", },
  48    { .info = "STENCIL_TEST", },
  49    { .info = "MULTI_SAMPLE", },
  50    { .info = "SHADER_ADDRESS (FS)", },
  51    { .info = "VARYING_TYPES", },
  52    { .info = "UNIFORMS_ADDRESS (PP)", },
  53    { .info = "TEXTURES_ADDRESS", },
  54    { .info = "AUX0", },
  55    { .info = "AUX1", },
  56    { .info = "VARYINGS_ADDRESS", },
  57 };
  58
  59 /* VS CMD stream parser functions */
  60
  61 static void
  62 parse_vs_draw(FILE *fp, uint32_t *value1, uint32_t *value2)
  63 {
  64    if ((*value1 == 0x00000000) && (*value2 == 0x00000000))
  65       fprintf(fp, "\t/* ---EMPTY CMD */\n");
  66    else
  67       fprintf(fp, "\t/* DRAW: num: %d, index_draw: %s */\n",
  68               (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8,
  69               (*value1 & 0x00000001) ? "true" : "false");
  70 }
  71
  72 static void
  73 parse_vs_shader_info(FILE *fp, uint32_t *value1, uint32_t *value2)
  74 {
  75    fprintf(fp, "\t/* SHADER_INFO: prefetch: %s, size: %d */\n",
  76            (*value1 & 0x00100000) ? "enabled" : "disabled",
  77            (((*value1 & 0x000fffff) >> 10) + 1) << 4);
  78 }
  79
  80 static void
  81 parse_vs_unknown1(FILE *fp, uint32_t *value1, uint32_t *value2)
  82 {
  83    fprintf(fp, "\t/* UNKNOWN_1 */\n");
  84 }
  85
  86 static void
  87 parse_vs_varying_attribute_count(FILE *fp, uint32_t *value1, uint32_t *value2)
  88 {
  89    fprintf(fp, "\t/* VARYING_ATTRIBUTE_COUNT: nr_vary: %d, nr_attr: %d */\n",
  90            ((*value1 & 0x00ffffff) >> 8) + 1, (*value1 >> 24) + 1);
  91 }
  92
  93 static void
  94 parse_vs_attributes_address(FILE *fp, uint32_t *value1, uint32_t *value2)
  95 {
  96    fprintf(fp, "\t/* ATTRIBUTES_ADDRESS: address: 0x%08x, size: %d */\n",
  97            *value1, (*value2 & 0x0fffffff) >> 17);
  98 }
  99
 100 static void
 101 parse_vs_varyings_address(FILE *fp, uint32_t *value1, uint32_t *value2)
 102 {
 103    fprintf(fp, "\t/* VARYINGS_ADDRESS: varying info @ 0x%08x, size: %d */\n",
 104            *value1, (*value2 & 0x0fffffff) >> 17);
 105 }
 106
 107 static void
 108 parse_vs_uniforms_address(FILE *fp, uint32_t *value1, uint32_t *value2)
 109 {
 110    fprintf(fp, "\t/* UNIFORMS_ADDRESS (GP): address: 0x%08x, size: %d */\n",
 111            *value1, (*value2 & 0x0fffffff) >> 12);
 112 }
 113
 114 static void
 115 parse_vs_shader_address(FILE *fp, uint32_t *value1, uint32_t *value2)
 116 {
 117    fprintf(fp, "\t/* SHADER_ADDRESS (VS): address: 0x%08x, size: %d */\n",
 118            *value1, (*value2 & 0x0fffffff) >> 12);
 119 }
 120
 121 static void
 122 parse_vs_semaphore(FILE *fp, uint32_t *value1, uint32_t *value2)
 123 {
 124    if (*value1 == 0x00028000)
 125       fprintf(fp, "\t/* SEMAPHORE_BEGIN_1 */\n");
 126    else if (*value1 == 0x00000001)
 127       fprintf(fp, "\t/* SEMAPHORE_BEGIN_2 */\n");
 128    else if (*value1 == 0x00000000)
 129       fprintf(fp, "\t/* SEMAPHORE_END: index_draw disabled */\n");
 130    else if (*value1 == 0x00018000)
 131       fprintf(fp, "\t/* SEMAPHORE_END: index_draw enabled */\n");
 132    else
 133       fprintf(fp, "\t/* SEMAPHORE - cmd unknown! */\n");
 134 }
 135
 136 static void
 137 parse_vs_unknown2(FILE *fp, uint32_t *value1, uint32_t *value2)
 138 {
 139    fprintf(fp, "\t/* UNKNOWN_2 */\n");
 140 }
 141
 142 static void
 143 parse_vs_continue(FILE *fp, uint32_t *value1, uint32_t *value2)
 144 {
 145    fprintf(fp, "\t/* CONTINUE: at 0x%08x */\n", *value1);
 146 }
 147
 148 void
 149 lima_parse_vs(FILE *fp, uint32_t *data, int size, uint32_t start)
 150 {
 151    uint32_t *value1;
 152    uint32_t *value2;
 153
 154    fprintf(fp, "\n");
 155    fprintf(fp, "/* ============ VS CMD STREAM BEGIN ============= */\n");
 156    for (int i = 0; i * 4 < size; i += 2) {
 157       value1 = &data[i];
 158       value2 = &data[i + 1];
 159       fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
 160               start + i * 4, i * 4, *value1, *value2);
 161
 162       if ((*value2 & 0xffff0000) == 0x00000000)
 163          parse_vs_draw(fp, value1, value2);
 164       else if ((*value2 & 0xff0000ff) == 0x10000040)
 165          parse_vs_shader_info(fp, value1, value2);
 166       else if ((*value2 & 0xff0000ff) == 0x10000041)
 167          parse_vs_unknown1(fp, value1, value2);
 168       else if ((*value2 & 0xff0000ff) == 0x10000042)
 169          parse_vs_varying_attribute_count(fp, value1, value2);
 170       else if ((*value2 & 0xff0000ff) == 0x20000000)
 171          parse_vs_attributes_address(fp, value1, value2);
 172       else if ((*value2 & 0xff0000ff) == 0x20000008)
 173          parse_vs_varyings_address(fp, value1, value2);
 174       else if ((*value2 & 0xff000000) == 0x30000000)
 175          parse_vs_uniforms_address(fp, value1, value2);
 176       else if ((*value2 & 0xff000000) == 0x40000000)
 177          parse_vs_shader_address(fp, value1, value2);
 178       else if ((*value2  & 0xff000000)== 0x50000000)
 179          parse_vs_semaphore(fp, value1, value2);
 180       else if ((*value2 & 0xff000000) == 0x60000000)
 181          parse_vs_unknown2(fp, value1, value2);
 182       else if ((*value2 & 0xff000000) == 0xf0000000)
 183          parse_vs_continue(fp, value1, value2);
 184       else
 185          fprintf(fp, "\t/* --- unknown cmd --- */\n");
 186    }
 187    fprintf(fp, "/* ============ VS CMD STREAM END =============== */\n");
 188    fprintf(fp, "\n");
 189 }
 190
 191 /* PLBU CMD stream parser functions */
 192
 193 static void
 194 parse_plbu_block_step(FILE *fp, uint32_t *value1, uint32_t *value2)
 195 {
 196    fprintf(fp, "\t/* BLOCK_STEP: shift_min: %d, shift_h: %d, shift_w: %d */\n",
 197            (*value1 & 0xf0000000) >> 28,
 198            (*value1 & 0x0fff0000) >> 16,
 199            *value1 & 0x0000ffff);
 200 }
 201
 202 static void
 203 parse_plbu_tiled_dimensions(FILE *fp, uint32_t *value1, uint32_t *value2)
 204 {
 205    fprintf(fp, "\t/* TILED_DIMENSIONS: tiled_w: %d, tiled_h: %d */\n",
 206            ((*value1 & 0xff000000) >> 24) + 1,
 207            ((*value1 & 0x00ffff00) >> 8) + 1);
 208 }
 209
 210 static void
 211 parse_plbu_block_stride(FILE *fp, uint32_t *value1, uint32_t *value2)
 212 {
 213    fprintf(fp, "\t/* BLOCK_STRIDE: block_w: %d */\n", *value1 & 0x000000ff);
 214 }
 215
 216 static void
 217 parse_plbu_array_address(FILE *fp, uint32_t *value1, uint32_t *value2)
 218 {
 219    fprintf(fp, "\t/* ARRAY_ADDRESS: gp_stream: 0x%08x, block_num (block_w * block_h): %d */\n",
 220            *value1, (*value2 & 0x00ffffff) + 1);
 221 }
 222
 223 static void
 224 parse_plbu_viewport_left(FILE *fp, float *value1, uint32_t *value2)
 225 {
 226    fprintf(fp, "\t/* VIEWPORT_LEFT: viewport_left: %f */\n", *value1);
 227 }
 228
 229 static void
 230 parse_plbu_viewport_right(FILE *fp, float *value1, uint32_t *value2)
 231 {
 232    fprintf(fp, "\t/* VIEWPORT_RIGHT: viewport_right: %f */\n", *value1);
 233 }
 234
 235 static void
 236 parse_plbu_viewport_bottom(FILE *fp, float *value1, uint32_t *value2)
 237 {
 238    fprintf(fp, "\t/* VIEWPORT_BOTTOM: viewport_bottom: %f */\n", *value1);
 239 }
 240
 241 static void
 242 parse_plbu_viewport_top(FILE *fp, float *value1, uint32_t *value2)
 243 {
 244    fprintf(fp, "\t/* VIEWPORT_TOP: viewport_top: %f */\n", *value1);
 245 }
 246
 247 static void
 248 parse_plbu_semaphore(FILE *fp, uint32_t *value1, uint32_t *value2)
 249 {
 250    if (*value1 == 0x00010002)
 251       fprintf(fp, "\t/* ARRAYS_SEMAPHORE_BEGIN */\n");
 252    else if (*value1 == 0x00010001)
 253       fprintf(fp, "\t/* ARRAYS_SEMAPHORE_END */\n");
 254    else
 255       fprintf(fp, "\t/* SEMAPHORE - cmd unknown! */\n");
 256 }
 257
 258 static void
 259 parse_plbu_primitive_setup(FILE *fp, uint32_t *value1, uint32_t *value2)
 260 {
 261    char prim[10];
 262
 263    if ((*value1 & 0x0000f000) == 0x00000000)
 264        strcpy(prim, "POINTS");
 265    else if ((*value1 & 0x0000f000) == 0x00003000)
 266        strcpy(prim, "LINES");
 267    else if ((*value1 & 0x0000f000) == 0x00002000)
 268        strcpy(prim, "TRIANGLES");
 269    else
 270        strcpy(prim, "UNKNOWN");
 271
 272    if (*value1 == 0x00000200)
 273       fprintf(fp, "\t/* UNKNOWN_2 (PRIMITIVE_SETUP INIT?) */\n");
 274    else
 275       fprintf(fp, "\t/* PRIMITIVE_SETUP: prim: %s, cull: %d (0x%x), index_size: %d */\n",
 276               prim,
 277               (*value1 & 0x000f0000) >> 16, (*value1 & 0x000f0000) >> 16,
 278               (*value1 & 0x00000e00) >> 9);
 279 }
 280
 281 static void
 282 parse_plbu_rsw_vertex_array(FILE *fp, uint32_t *value1, uint32_t *value2)
 283 {
 284    fprintf(fp, "\t/* RSW_VERTEX_ARRAY: rsw: 0x%08x, gl_pos: 0x%08x */\n",
 285            *value1,
 286            (*value2 & 0x0fffffff) << 4);
 287 }
 288
 289 static void
 290 parse_plbu_scissors(FILE *fp, uint32_t *value1, uint32_t *value2)
 291 {
 292    float minx = (*value1 & 0xc0000000) >> 30 | (*value2 & 0x00001fff) << 2;
 293    float maxx = ((*value2 & 0x0fffe000) >> 13) + 1;
 294    float miny = *value1 & 0x00003fff;
 295    float maxy = ((*value1 & 0x3fff8000) >> 15) + 1;
 296
 297    fprintf(fp, "\t/* SCISSORS: minx: %f, maxx: %f, miny: %f, maxy: %f */\n",
 298            minx, maxx, miny, maxy);
 299 }
 300
 301 static void
 302 parse_plbu_unknown_1(FILE *fp, uint32_t *value1, uint32_t *value2)
 303 {
 304    fprintf(fp, "\t/* UNKNOWN_1 */\n");
 305 }
 306
 307 static void
 308 parse_plbu_low_prim_size(FILE *fp, float *value1, uint32_t *value2)
 309 {
 310    fprintf(fp, "\t/* LOW_PRIM_SIZE: size: %f */\n", *value1);
 311 }
 312
 313 static void
 314 parse_plbu_depth_range_near(FILE *fp, float *value1, uint32_t *value2)
 315 {
 316    fprintf(fp, "\t/* DEPTH_RANG_NEAR: depth_range: %f */\n", *value1);
 317 }
 318
 319 static void
 320 parse_plbu_depth_range_far(FILE *fp, float *value1, uint32_t *value2)
 321 {
 322    fprintf(fp, "\t/* DEPTH_RANGE_FAR: depth_range: %f */\n", *value1);
 323 }
 324
 325 static void
 326 parse_plbu_indexed_dest(FILE *fp, uint32_t *value1, uint32_t *value2)
 327 {
 328    fprintf(fp, "\t/* INDEXED_DEST: gl_pos: 0x%08x */\n", *value1);
 329 }
 330
 331 static void
 332 parse_plbu_indexed_pt_size(FILE *fp, uint32_t *value1, uint32_t *value2)
 333 {
 334    fprintf(fp, "\t/* INDEXED_PT_SIZE: pt_size: 0x%08x */\n", *value1);
 335 }
 336
 337 static void
 338 parse_plbu_indices(FILE *fp, uint32_t *value1, uint32_t *value2)
 339 {
 340    fprintf(fp, "\t/* INDICES: indices: 0x%08x */\n", *value1);
 341 }
 342
 343 static void
 344 parse_plbu_draw_arrays(FILE *fp, uint32_t *value1, uint32_t *value2)
 345 {
 346    if ((*value1 == 0x00000000) && (*value2 == 0x00000000)) {
 347       fprintf(fp, "\t/* ---EMPTY CMD */\n");
 348       return;
 349    }
 350
 351    uint32_t count = (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8;
 352    uint32_t start = *value1 & 0x00ffffff;
 353    uint32_t mode = (*value2 & 0x001f0000) >> 16;
 354
 355    fprintf(fp, "\t/* DRAW_ARRAYS: count: %d, start: %d, mode: %d (0x%x) */\n",
 356            count, start, mode, mode);
 357 }
 358
 359 static void
 360 parse_plbu_draw_elements(FILE *fp, uint32_t *value1, uint32_t *value2)
 361 {
 362    uint32_t count = (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8;
 363    uint32_t start = *value1 & 0x00ffffff;
 364    uint32_t mode = (*value2 & 0x001f0000) >> 16;
 365
 366    fprintf(fp, "\t/* DRAW_ELEMENTS: count: %d, start: %d, mode: %d (0x%x) */\n",
 367            count, start, mode, mode);
 368 }
 369
 370 static void
 371 parse_plbu_continue(FILE *fp, uint32_t *value1, uint32_t *value2)
 372 {
 373    fprintf(fp, "\t/* CONTINUE: continue at 0x%08x */\n", *value1);
 374 }
 375
 376 static void
 377 parse_plbu_end(FILE *fp, uint32_t *value1, uint32_t *value2)
 378 {
 379    fprintf(fp, "\t/* END (FINISH/FLUSH) */\n");
 380 }
 381
 382 void
 383 lima_parse_plbu(FILE *fp, uint32_t *data, int size, uint32_t start)
 384 {
 385    uint32_t *value1;
 386    uint32_t *value2;
 387
 388    fprintf(fp, "/* ============ PLBU CMD STREAM BEGIN ============= */\n");
 389    for (int i = 0; i * 4 < size; i += 2) {
 390       value1 = &data[i];
 391       value2 = &data[i + 1];
 392       fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
 393               start + i * 4, i * 4, *value1, *value2);
 394
 395       if ((*value2 & 0xffe00000) == 0x00000000)
 396          parse_plbu_draw_arrays(fp, value1, value2);
 397       else if ((*value2 & 0xffe00000) == 0x00200000)
 398          parse_plbu_draw_elements(fp, value1, value2);
 399       else if ((*value2 & 0xff000fff) == 0x10000100)
 400          parse_plbu_indexed_dest(fp, value1, value2);
 401       else if ((*value2 & 0xff000fff) == 0x10000101)
 402          parse_plbu_indices(fp, value1, value2);
 403       else if ((*value2 & 0xff000fff) == 0x10000102)
 404          parse_plbu_indexed_pt_size(fp, value1, value2);
 405       else if ((*value2 & 0xff000fff) == 0x10000105)
 406          parse_plbu_viewport_bottom(fp, (float *)value1, value2);
 407       else if ((*value2 & 0xff000fff) == 0x10000106)
 408          parse_plbu_viewport_top(fp, (float *)value1, value2);
 409       else if ((*value2 & 0xff000fff) == 0x10000107)
 410          parse_plbu_viewport_left(fp, (float *)value1, value2);
 411       else if ((*value2 & 0xff000fff) == 0x10000108)
 412          parse_plbu_viewport_right(fp, (float *)value1, value2);
 413       else if ((*value2 & 0xff000fff) == 0x10000109)
 414          parse_plbu_tiled_dimensions(fp, value1, value2);
 415       else if ((*value2 & 0xff000fff) == 0x1000010a)
 416          parse_plbu_unknown_1(fp, value1, value2);
 417       else if ((*value2 & 0xff000fff) == 0x1000010b) /* also unknown_2 */
 418          parse_plbu_primitive_setup(fp, value1, value2);
 419       else if ((*value2 & 0xff000fff) == 0x1000010c)
 420          parse_plbu_block_step(fp, value1, value2);
 421       else if ((*value2 & 0xff000fff) == 0x1000010d)
 422          parse_plbu_low_prim_size(fp, (float *)value1, value2);
 423       else if ((*value2 & 0xff000fff) == 0x1000010e)
 424          parse_plbu_depth_range_near(fp, (float *)value1, value2);
 425       else if ((*value2 & 0xff000fff) == 0x1000010f)
 426          parse_plbu_depth_range_far(fp, (float *)value1, value2);
 427       else if ((*value2 & 0xff000000) == 0x28000000)
 428          parse_plbu_array_address(fp, value1, value2);
 429       else if ((*value2 & 0xf0000000) == 0x30000000)
 430          parse_plbu_block_stride(fp, value1, value2);
 431       else if (*value2 == 0x50000000)
 432          parse_plbu_end(fp, value1, value2);
 433       else if ((*value2  & 0xf0000000)== 0x60000000)
 434          parse_plbu_semaphore(fp, value1, value2);
 435       else if ((*value2  & 0xf0000000)== 0x70000000)
 436          parse_plbu_scissors(fp, value1, value2);
 437       else if ((*value2  & 0xf0000000)== 0x80000000)
 438          parse_plbu_rsw_vertex_array(fp, value1, value2);
 439       else if ((*value2  & 0xf0000000)== 0xf0000000)
 440          parse_plbu_continue(fp, value1, value2);
 441       else
 442          fprintf(fp, "\t/* --- unknown cmd --- */\n");
 443    }
 444    fprintf(fp, "/* ============ PLBU CMD STREAM END =============== */\n");
 445    fprintf(fp, "\n");
 446 }
 447
 448 static void
 449 parse_rsw(FILE *fp, uint32_t *value, int i, uint32_t *helper)
 450 {
 451    fprintf(fp, "\t/* %s", render_state_infos[i].info);
 452
 453    switch (i) {
 454    case 0: /* BLEND COLOR BG */
 455       fprintf(fp, ": blend_color.color[1] = %f, blend_color.color[2] = %f */\n",
 456               (float)(ubyte_to_float((*value & 0xffff0000) >> 16)),
 457               (float)(ubyte_to_float(*value & 0x0000ffff)));
 458       break;
 459    case 1: /* BLEND COLOR RA */
 460       fprintf(fp, ": blend_color.color[3] = %f, blend_color.color[0] = %f */\n",
 461               (float)(ubyte_to_float((*value & 0xffff0000) >> 16)),
 462               (float)(ubyte_to_float(*value & 0x0000ffff)));
 463       break;
 464    case 2: /* ALPHA BLEND */
 465       fprintf(fp, "(1): colormask 0x%02x, rgb_func %d, alpha_func %d */\n",
 466               (*value & 0xf0000000) >> 28, /* colormask */
 467               (*value & 0x00000007), /* rgb_func */
 468               (*value & 0x00000038) >> 3); /* alpha_func */
 469       /* add a few tabs for alignment */
 470       fprintf(fp, "\t\t\t\t\t\t/* %s(2)", render_state_infos[i].info);
 471       fprintf(fp, ": rgb_src_factor %d, rbg_dst_factor %d, alpha_src_factor %d",
 472               (*value & 0x000007c0) >> 6, /* rgb_src_factor */
 473               (*value & 0x0000f800) >> 11, /* rgb_dst_factor */
 474               (*value & 0x000f0000) >> 16); /* alpha_src_factor */
 475       fprintf(fp, ", alpha_dst_factor %d, bits 24-27 0x%02x */\n",
 476               (*value & 0x00f00000) >> 20, /* alpha_dst_factor */
 477               (*value & 0x0f000000) >> 24); /* bits 24-27 */
 478       break;
 479    case 3: /* DEPTH TEST */
 480       if ((*value & 0x00000001) == 0x00000001)
 481          fprintf(fp, ": depth test enabled && writes allowed");
 482       else
 483          fprintf(fp, ": depth test disabled || writes not allowed");
 484
 485       fprintf(fp, ", PIPE_FUNC_%d", *value & 0x0000000e);
 486       fprintf(fp, ", offset_scale: %d", *value & 0xffff0000);
 487       fprintf(fp, ", unknown bits 4-15: 0x%08x */\n", *value & 0x0000fff0);
 488       break;
 489    case 4: /* DEPTH RANGE */
 490       fprintf(fp, ": viewport.far = %f, viewport.near = %f */\n",
 491               (float)(ushort_to_float((*value & 0xffff0000) >> 16)),
 492               (float)(ushort_to_float(*value & 0x0000ffff)));
 493       break;
 494    case 5: /* STENCIL FRONT */
 495       fprintf(fp, " (to investigate) */\n");
 496       break;
 497    case 6: /* STENCIL BACK */
 498       fprintf(fp, " (to investigate) */\n");
 499       break;
 500    case 7: /* STENCIL TEST */
 501       fprintf(fp, " (to investigate) */\n");
 502       break;
 503    case 8: /* MULTI SAMPLE */
 504       if ((*value & 0x00000f00) == 0x00000000)
 505          fprintf(fp, ": points");
 506       else if ((*value & 0x00000f00) == 0x00000400)
 507          fprintf(fp, ": lines");
 508       else if ((*value & 0x00000f00) == 0x00000800)
 509          fprintf(fp, ": triangles");
 510       else
 511          fprintf(fp, ": unknown");
 512
 513       if ((*value & 0x00000078) == 0x00000068)
 514          fprintf(fp, ", fb_samples */\n");
 515       else if ((*value & 0x00000078) == 0x00000000)
 516          fprintf(fp, " */\n");
 517       else
 518          fprintf(fp, ", UNKNOWN\n");
 519       break;
 520    case 9: /* SHADER ADDRESS */
 521       fprintf(fp, ": fs shader @ 0x%08x, ((uint32_t *)ctx->fs->bo->map)[0] & 0x1f: 0x%08x */\n",
 522               *value & 0xffffffe0, *value & 0x0000001f);
 523       break;
 524    case 10: /* VARYING TYPES */
 525       assert(*helper);
 526       fprintf(fp, "(1): ");
 527       int val, j;
 528       /* 0 - 5 */
 529       for (j = 0; j < 6; j++) {
 530          val = *value & (0x07 << (j * 3));
 531          fprintf(fp, "val %d-%d, ", j, val);
 532       }
 533       /* 6 - 9 */
 534       /* add a few tabs for alignment */
 535       fprintf(fp, "\n\t\t\t\t\t\t/* %s(2): ", render_state_infos[i].info);
 536       for (j = 6; j < 10; j++) {
 537          val = *value & (0x07 << (j * 3));
 538          fprintf(fp, "val %d-%d, ", j, val);
 539       }
 540       /* 10 */
 541       val = ((*value & 0x0c000000) >> 30) | ((*helper & 0x00000001) << 2);
 542       fprintf(fp, "val %d-%d, ", j, val);
 543       j++;
 544       /* 11 */
 545       val = (*helper & 0x0000000e) >> 1;
 546       fprintf(fp, "val %d-%d */\n", j, val);
 547       break;
 548    case 11: /* UNIFORMS ADDRESS */
 549       fprintf(fp, ": pp uniform info @ 0x%08x, bits: 0x%01x */\n",
 550               *value & 0xfffffff0, *value & 0x0000000f);
 551       break;
 552    case 12: /* TEXTURES ADDRESS */
 553       fprintf(fp, ": address: 0x%08x */\n", *value);
 554       break;
 555    case 13: /* AUX0 */
 556       fprintf(fp, ": varying_stride: %d, tex_stateobj.num_samplers: %d */\n",
 557               *value & 0x0000001f, (*value & 0xffffc000) >> 14);
 558       break;
 559    case 14: /* AUX1 */
 560       fprintf(fp, ": ");
 561       if ((*value & 0x00002000) == 0x00002000)
 562          fprintf(fp, "blend->base.dither true, ");
 563       if ((*value & 0x00010000) == 0x00010000)
 564          fprintf(fp, "ctx->const_buffer[PIPE_SHADER_FRAGMENT].buffer true ");
 565       fprintf(fp, "*/\n");
 566       break;
 567    case 15: /* VARYINGS ADDRESS */
 568       fprintf(fp, ": varyings @ 0x%08x */\n", *value & 0xfffffff0);
 569       break;
 570    default: /* should never be executed! */
 571       fprintf(fp, ": something went wrong!!! */\n");
 572       break;
 573    }
 574 }
 575
 576 void
 577 lima_parse_render_state(FILE *fp, uint32_t *data, int size, uint32_t start)
 578 {
 579    uint32_t *value;
 580
 581    fprintf(fp, "/* ============ RSW BEGIN ========================= */\n");
 582    for (int i = 0; i * 4 < size; i++) {
 583       value = &data[i];
 584       fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x",
 585               start + i * 4, i * 4, *value);
 586       if (i == 10)
 587          parse_rsw(fp, value, i, &data[15]);
 588       else
 589          parse_rsw(fp, value, i, NULL);
 590    }
 591    fprintf(fp, "/* ============ RSW END =========================== */\n");
 592 }
 593
 594 static void
 595 parse_texture(FILE *fp, uint32_t *data, uint32_t start, uint32_t offset)
 596 {
 597    uint32_t i = 0;
 598    offset /= 4;
 599    lima_tex_desc *desc = (lima_tex_desc *)&data[offset];
 600
 601    /* Word 0 */
 602    fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x\n",
 603            start + i * 4, i * 4, *(&data[i + offset]));
 604    i++;
 605    fprintf(fp, "\t format: 0x%x (%d)\n", desc->format, desc->format);
 606    fprintf(fp, "\t flag1: 0x%x (%d)\n", desc->flag1, desc->flag1);
 607    fprintf(fp, "\t swap_r_b: 0x%x (%d)\n", desc->swap_r_b, desc->swap_r_b);
 608    fprintf(fp, "\t unknown_0_1: 0x%x (%d)\n", desc->unknown_0_1, desc->unknown_0_1);
 609    fprintf(fp, "\t stride: 0x%x (%d)\n", desc->stride, desc->stride);
 610    fprintf(fp, "\t unknown_0_2: 0x%x (%d)\n", desc->unknown_0_2, desc->unknown_0_2);
 611
 612    /* Word 1 - 3 */
 613    fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x 0x%08x\n",
 614            start + i * 4, i * 4, *(&data[i + offset]), *(&data[i + 1 + offset]), *(&data[i + 2 + offset]));
 615    i += 3;
 616    fprintf(fp, "\t unknown_1_1: 0x%x (%d)\n", desc->unknown_1_1, desc->unknown_1_1);
 617    fprintf(fp, "\t unnorm_coords: 0x%x (%d)\n", desc->unnorm_coords, desc->unnorm_coords);
 618    fprintf(fp, "\t unknown_1_2: 0x%x (%d)\n", desc->unknown_1_2, desc->unknown_1_2);
 619    fprintf(fp, "\t texture_type: 0x%x (%d)\n", desc->texture_type, desc->texture_type);
 620    fprintf(fp, "\t unknown_1_3: 0x%x (%d)\n", desc->unknown_1_3, desc->unknown_1_3);
 621    fprintf(fp, "\t miplevels: 0x%x (%d)\n", desc->miplevels, desc->miplevels);
 622    fprintf(fp, "\t min_mipfilter_1: 0x%x (%d)\n", desc->min_mipfilter_1, desc->min_mipfilter_1);
 623    fprintf(fp, "\t unknown_2_1: 0x%x (%d)\n", desc->unknown_2_1, desc->unknown_2_1);
 624    fprintf(fp, "\t has_stride: 0x%x (%d)\n", desc->has_stride, desc->has_stride);
 625    fprintf(fp, "\t min_mipfilter_2: 0x%x (%d)\n", desc->min_mipfilter_2, desc->min_mipfilter_2);
 626    fprintf(fp, "\t min_img_filter_nearest: 0x%x (%d)\n", desc->min_img_filter_nearest, desc->min_img_filter_nearest);
 627    fprintf(fp, "\t mag_img_filter_nearest: 0x%x (%d)\n", desc->mag_img_filter_nearest, desc->mag_img_filter_nearest);
 628    fprintf(fp, "\t wrap_s_clamp_to_edge: 0x%x (%d)\n", desc->wrap_s_clamp_to_edge, desc->wrap_s_clamp_to_edge);
 629    fprintf(fp, "\t wrap_s_clamp: 0x%x (%d)\n", desc->wrap_s_clamp, desc->wrap_s_clamp);
 630    fprintf(fp, "\t wrap_s_mirror_repeat: 0x%x (%d)\n", desc->wrap_s_mirror_repeat, desc->wrap_s_mirror_repeat);
 631    fprintf(fp, "\t wrap_t_clamp_to_edge: 0x%x (%d)\n", desc->wrap_t_clamp_to_edge, desc->wrap_t_clamp_to_edge);
 632    fprintf(fp, "\t wrap_t_clamp: 0x%x (%d)\n", desc->wrap_t_clamp, desc->wrap_t_clamp);
 633    fprintf(fp, "\t wrap_t_mirror_repeat: 0x%x (%d)\n", desc->wrap_t_mirror_repeat, desc->wrap_t_mirror_repeat);
 634    fprintf(fp, "\t unknown_2_2: 0x%x (%d)\n", desc->unknown_2_2, desc->unknown_2_2);
 635    fprintf(fp, "\t width: 0x%x (%d)\n", desc->width, desc->width);
 636    fprintf(fp, "\t height: 0x%x (%d)\n", desc->height, desc->height);
 637    fprintf(fp, "\t unknown_3_1: 0x%x (%d)\n", desc->unknown_3_1, desc->unknown_3_1);
 638    fprintf(fp, "\t unknown_3_2: 0x%x (%d)\n", desc->unknown_3_2, desc->unknown_3_2);
 639
 640    /* Word 4 */
 641    fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x\n",
 642            start + i * 4, i * 4, *(&data[i + offset]));
 643    i++;
 644    fprintf(fp, "\t unknown_4: 0x%x (%d)\n", desc->unknown_4, desc->unknown_4);
 645
 646    /* Word 5 */
 647    fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x\n",
 648            start + i * 4, i * 4, *(&data[i + offset]));
 649    i++;
 650    fprintf(fp, "\t unknown_5: 0x%x (%d)\n", desc->unknown_5, desc->unknown_5);
 651
 652    /* Word 6 - */
 653    fprintf(fp, "/* 0x%08x (0x%08x) */",
 654            start + i * 4, i * 4);
 655    fprintf(fp, "\t");
 656    for (int k = 0; k < ((((desc->miplevels + 1) * 26) + 64) / 32); k++)
 657       fprintf(fp, "0x%08x ", *(&data[i + offset + k]));
 658    fprintf(fp, "\n");
 659
 660    i++;
 661    fprintf(fp, "\t unknown_6_1: 0x%x (%d)\n", desc->va_s.unknown_6_1, desc->va_s.unknown_6_1);
 662    fprintf(fp, "\t layout: 0x%x (%d)\n", desc->va_s.layout, desc->va_s.layout);
 663    fprintf(fp, "\t unknown_6_2: 0x%x (%d)\n", desc->va_s.unknown_6_2, desc->va_s.unknown_6_2);
 664    fprintf(fp, "\t unknown_6_3: 0x%x (%d)\n", desc->va_s.unknown_6_3, desc->va_s.unknown_6_3);
 665
 666    /* first level */
 667    fprintf(fp, "\t va_0: 0x%x \n", desc->va_s.va_0 << 6);
 668
 669    /* second level up to desc->miplevels */
 670    int j;
 671    unsigned va_bit_idx;
 672    unsigned va_idx;
 673    uint32_t va;
 674    uint32_t va_1;
 675    uint32_t va_2;
 676    for (j = 1; j <= desc->miplevels; j++) {
 677       va = 0;
 678       va_1 = 0;
 679       va_2 = 0;
 680
 681       va_bit_idx = VA_BIT_OFFSET + (VA_BIT_SIZE * j);
 682       va_idx = va_bit_idx / 32;
 683       va_bit_idx %= 32;
 684
 685       /* the first (32 - va_bit_idx) bits */
 686       va_1 |= (*(&data[i + offset + va_idx - 1]) >> va_bit_idx);
 687
 688       /* do we need some bits from the following word? */
 689       if (va_bit_idx > 6) {
 690          /* shift left and right again to erase the unneeded bits, keep space for va1 */
 691          va_2 |= (*(&data[i + offset + va_idx]) << (2 * 32 - VA_BIT_SIZE - va_bit_idx));
 692          va_2 >>= ((2 * 32 - VA_BIT_SIZE - va_bit_idx) - (32 - va_bit_idx));
 693          va |= va_2;
 694       }
 695       va |= va_1;
 696       va <<= 6;
 697       fprintf(fp, "\t va_%d: 0x%x \n", j, va);
 698    }
 699 }
 700
 701 void
 702 lima_parse_texture_descriptor(FILE *fp, uint32_t *data, int size, uint32_t start, uint32_t offset)
 703 {
 704    fprintf(fp, "/* ============ TEXTURE BEGIN ===================== */\n");
 705    parse_texture(fp, data, start, offset);
 706    fprintf(fp, "/* ============ TEXTURE END ======================= */\n");
 707 }