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 <stdio.h>
  26 #include <stdint.h>
  27 #include <string.h>
  28
  29 #include "lima_parser.h"
  30
  31 /* VS CMD stream parser functions */
  32
  33 static void
  34 parse_vs_draw(FILE *fp, uint32_t *value1, uint32_t *value2)
  35 {
  36    if ((*value1 == 0x00000000) && (*value2 == 0x00000000))
  37       fprintf(fp, "\t/* ---EMPTY CMD */\n");
  38    else
  39       fprintf(fp, "\t/* DRAW: num: %d (0x%x), index_draw: %s */\n",
  40               (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8,
  41               (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8,
  42               (*value2 & 0x00000001) ? "true" : "false");
  43 }
  44
  45 static void
  46 parse_vs_shader_info(FILE *fp, uint32_t *value1, uint32_t *value2)
  47 {
  48    fprintf(fp, "\t/* SHADER_INFO: prefetch: %s, size: %d (0x%x) */\n",
  49           (*value1 & 0x00100000) ? "enabled" : "disabled",
  50           (((*value1 & 0x000fffff) >> 10) + 1) << 4,
  51           (((*value1 & 0x000fffff) >> 10) + 1) << 4);
  52 }
  53
  54 static void
  55 parse_vs_unknown1(FILE *fp, uint32_t *value1, uint32_t *value2)
  56 {
  57    fprintf(fp, "\t/* UNKNOWN_1 */\n");
  58 }
  59
  60 static void
  61 parse_vs_varying_attribute_count(FILE *fp, uint32_t *value1, uint32_t *value2)
  62 {
  63    fprintf(fp, "\t/* VARYING_ATTRIBUTE_COUNT: nr_vary: %d (0x%x), nr_attr: %d (0x%x) */\n",
  64           ((*value1 & 0x00ffffff) >> 8) + 1, ((*value1 & 0x00ffffff) >> 8) + 1,
  65           (*value1 >> 24) + 1, (*value1 >> 24) + 1);
  66 }
  67
  68 static void
  69 parse_vs_attributes_address(FILE *fp, uint32_t *value1, uint32_t *value2)
  70 {
  71    fprintf(fp, "\t/* ATTRIBUTES_ADDRESS: address: 0x%08x, size: %d (0x%x) */\n",
  72           *value1, (*value2 & 0x0fffffff) >> 17, (*value2 & 0x0fffffff) >> 17);
  73 }
  74
  75 static void
  76 parse_vs_varyings_address(FILE *fp, uint32_t *value1, uint32_t *value2)
  77 {
  78    fprintf(fp, "\t/* VARYINGS_ADDRESS: address: 0x%08x, size: %d (0x%x) */\n",
  79           *value1, (*value2 & 0x0fffffff) >> 17, (*value2 & 0x0fffffff) >> 17);
  80 }
  81
  82 static void
  83 parse_vs_uniforms_address(FILE *fp, uint32_t *value1, uint32_t *value2)
  84 {
  85    fprintf(fp, "\t/* UNIFORMS_ADDRESS: address: 0x%08x, size: %d (0x%x) */\n",
  86           *value1, (*value2 & 0x0fffffff) >> 12, (*value2 & 0x0fffffff) >> 12);
  87 }
  88
  89 static void
  90 parse_vs_shader_address(FILE *fp, uint32_t *value1, uint32_t *value2)
  91 {
  92    fprintf(fp, "\t/* SHADER_ADDRESS: address: 0x%08x, size: %d (0x%x) */\n",
  93           *value1, (*value2 & 0x0fffffff) >> 12, (*value2 & 0x0fffffff) >> 12);
  94 }
  95
  96 static void
  97 parse_vs_semaphore(FILE *fp, uint32_t *value1, uint32_t *value2)
  98 {
  99    if (*value1 == 0x00028000)
 100       fprintf(fp, "\t/* SEMAPHORE_BEGIN_1 */\n");
 101    else if (*value1 == 0x00000001)
 102       fprintf(fp, "\t/* SEMAPHORE_BEGIN_2 */\n");
 103    else if (*value1 == 0x00000000)
 104       fprintf(fp, "\t/* SEMAPHORE_END: index_draw disabled */\n");
 105    else if (*value1 == 0x00018000)
 106       fprintf(fp, "\t/* SEMAPHORE_END: index_draw enabled */\n");
 107    else
 108       fprintf(fp, "\t/* SEMAPHORE - cmd unknown! */\n");
 109 }
 110
 111 static void
 112 parse_vs_unknown2(FILE *fp, uint32_t *value1, uint32_t *value2)
 113 {
 114    fprintf(fp, "\t/* UNKNOWN_2 */\n");
 115 }
 116
 117 static void
 118 parse_vs_continue(FILE *fp, uint32_t *value1, uint32_t *value2)
 119 {
 120    fprintf(fp, "\t/* CONTINUE: at 0x%08x */\n", *value1);
 121 }
 122
 123 void
 124 lima_parse_vs(FILE *fp, uint32_t *data, int size, uint32_t start)
 125 {
 126    uint32_t *value1;
 127    uint32_t *value2;
 128
 129    fprintf(fp, "\n");
 130    fprintf(fp, "/* ============ VS CMD STREAM BEGIN ============= */\n");
 131    for (int i = 0; i * 4 < size; i += 2) {
 132       value1 = &data[i];
 133       value2 = &data[i + 1];
 134       fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
 135               start + i * 4, i * 4, *value1, *value2);
 136
 137       if ((*value2 & 0xffff0000) == 0x00000000)
 138          parse_vs_draw(fp, value1, value2);
 139       else if ((*value2 & 0xff0000ff) == 0x10000040)
 140          parse_vs_shader_info(fp, value1, value2);
 141       else if ((*value2 & 0xff0000ff) == 0x10000041)
 142          parse_vs_unknown1(fp, value1, value2);
 143       else if ((*value2 & 0xff0000ff) == 0x10000042)
 144          parse_vs_varying_attribute_count(fp, value1, value2);
 145       else if ((*value2 & 0xff0000ff) == 0x20000000)
 146          parse_vs_attributes_address(fp, value1, value2);
 147       else if ((*value2 & 0xff0000ff) == 0x20000008)
 148          parse_vs_varyings_address(fp, value1, value2);
 149       else if ((*value2 & 0xff000000) == 0x30000000)
 150          parse_vs_uniforms_address(fp, value1, value2);
 151       else if ((*value2 & 0xff000000) == 0x40000000)
 152          parse_vs_shader_address(fp, value1, value2);
 153       else if ((*value2  & 0xff000000)== 0x50000000)
 154          parse_vs_semaphore(fp, value1, value2);
 155       else if ((*value2 & 0xff000000) == 0x60000000)
 156          parse_vs_unknown2(fp, value1, value2);
 157       else if ((*value2 & 0xff000000) == 0xf0000000)
 158          parse_vs_continue(fp, value1, value2);
 159       else
 160          fprintf(fp, "\t/* --- unknown cmd --- */\n");
 161    }
 162    fprintf(fp, "/* ============ VS CMD STREAM END =============== */\n");
 163    fprintf(fp, "\n");
 164 }
 165
 166 /* PLBU CMD stream parser functions */
 167
 168 static void
 169 parse_plbu_block_step(FILE *fp, uint32_t *value1, uint32_t *value2)
 170 {
 171    fprintf(fp, "\t/* BLOCK_STEP: shift_min: %d (0x%x), shift_h: %d (0x%x), shift_w: %d (0x%x) */\n",
 172            (*value1 & 0xf0000000) >> 28, (*value1 & 0xf0000000) >> 28,
 173            (*value1 & 0x0fff0000) >> 16, (*value1 & 0x0fff0000) >> 16,
 174            *value1 & 0x0000ffff, *value1 & 0x0000ffff);
 175 }
 176
 177 static void
 178 parse_plbu_tiled_dimensions(FILE *fp, uint32_t *value1, uint32_t *value2)
 179 {
 180    fprintf(fp, "\t/* TILED_DIMENSIONS: tiled_w: %d (0x%x), tiled_h: %d (0x%x) */\n",
 181            ((*value1 & 0xff000000) >> 24) + 1,
 182            ((*value1 & 0xff000000) >> 24) + 1,
 183            ((*value1 & 0x00ffff00) >> 8) + 1,
 184            ((*value1 & 0x00ffff00) >> 8) + 1);
 185 }
 186
 187 static void
 188 parse_plbu_block_stride(FILE *fp, uint32_t *value1, uint32_t *value2)
 189 {
 190    fprintf(fp, "\t/* BLOCK_STRIDE: block_w: %d (0x%x) */\n",
 191            *value1 & 0x000000ff, *value1 & 0x000000ff);
 192 }
 193
 194 static void
 195 parse_plbu_array_address(FILE *fp, uint32_t *value1, uint32_t *value2)
 196 {
 197    fprintf(fp, "\t/* ARRAY_ADDRESS: gp_stream: 0x%x, block_num (block_w * block_h): %d (0x%x) */\n",
 198            *value1,
 199            (*value2 & 0x00ffffff) + 1, (*value2 & 0x00ffffff) + 1);
 200 }
 201
 202 static void
 203 parse_plbu_viewport_left(FILE *fp, float *value1, uint32_t *value2)
 204 {
 205    fprintf(fp, "\t/* VIEWPORT_LEFT: viewport_left: %f */\n", *value1);
 206 }
 207
 208 static void
 209 parse_plbu_viewport_right(FILE *fp, float *value1, uint32_t *value2)
 210 {
 211    fprintf(fp, "\t/* VIEWPORT_RIGHT: viewport_right: %f */\n", *value1);
 212 }
 213
 214 static void
 215 parse_plbu_viewport_bottom(FILE *fp, float *value1, uint32_t *value2)
 216 {
 217    fprintf(fp, "\t/* VIEWPORT_BOTTOM: viewport_bottom: %f */\n", *value1);
 218 }
 219
 220 static void
 221 parse_plbu_viewport_top(FILE *fp, float *value1, uint32_t *value2)
 222 {
 223    fprintf(fp, "\t/* VIEWPORT_TOP: viewport_top: %f */\n", *value1);
 224 }
 225
 226 static void
 227 parse_plbu_semaphore(FILE *fp, uint32_t *value1, uint32_t *value2)
 228 {
 229    if (*value1 == 0x00010002)
 230       fprintf(fp, "\t/* ARRAYS_SEMAPHORE_BEGIN */\n");
 231    else if (*value1 == 0x00010001)
 232       fprintf(fp, "\t/* ARRAYS_SEMAPHORE_END */\n");
 233    else
 234       fprintf(fp, "\t/* SEMAPHORE - cmd unknown! */\n");
 235 }
 236
 237 static void
 238 parse_plbu_primitive_setup(FILE *fp, uint32_t *value1, uint32_t *value2)
 239 {
 240    char prim[10];
 241
 242    if ((*value1 & 0x0000f000) == 0x00000000)
 243        strcpy(prim, "POINTS");
 244    else if ((*value1 & 0x0000f000) == 0x00003000)
 245        strcpy(prim, "LINES");
 246    else if ((*value1 & 0x0000f000) == 0x00002000)
 247        strcpy(prim, "TRIANGLES");
 248    else
 249        strcpy(prim, "UNKNOWN");
 250
 251    if (*value1 == 0x00000200)
 252       fprintf(fp, "\t/* UNKNOWN_2 (PRIMITIVE_SETUP INIT?) */\n");
 253    else
 254       fprintf(fp, "\t/* PRIMITIVE_SETUP: prim: %s, cull: %d (0x%x), index_size: %d (0x%08x) */\n",
 255               prim,
 256               (*value1 & 0x000f0000) >> 16, (*value1 & 0x000f0000) >> 16,
 257               (*value1 & 0x00001e00) >> 9, (*value1 & 0x00001e00) >> 9);
 258 }
 259
 260 static void
 261 parse_plbu_rsw_vertex_array(FILE *fp, uint32_t *value1, uint32_t *value2)
 262 {
 263    fprintf(fp, "\t/* RSW_VERTEX_ARRAY: rsw: 0x%x, gl_pos: 0x%x */\n",
 264            *value1,
 265            (*value2 & 0x0fffffff) << 4);
 266 }
 267
 268 static void
 269 parse_plbu_scissors(FILE *fp, uint32_t *value1, uint32_t *value2)
 270 {
 271    uint32_t minx = (*value1 & 0xc0000000) >> 30 | (*value2 & 0x00001fff) << 2;
 272    uint32_t maxx = ((*value2 & 0xffffe000) >> 13) + 1;
 273    uint32_t miny = *value1 & 0x00003fff;
 274    uint32_t maxy = ((*value2 & 0x3fff8000) >> 15) + 1;
 275
 276    fprintf(fp, "\t/* SCISSORS: minx: %d, maxx: %d, miny: %d, maxy: %d */\n",
 277            minx, maxx, miny, maxy);
 278 }
 279
 280 static void
 281 parse_plbu_unknown_1(FILE *fp, uint32_t *value1, uint32_t *value2)
 282 {
 283    fprintf(fp, "\t/* UNKNOWN_1 */\n");
 284 }
 285
 286 static void
 287 parse_plbu_low_prim_size(FILE *fp, float *value1, uint32_t *value2)
 288 {
 289    fprintf(fp, "\t/* LOW_PRIM_SIZE: size: %f (0x%x) */\n",
 290            *value1, *(uint32_t *)value1);
 291 }
 292
 293 static void
 294 parse_plbu_depth_range_near(FILE *fp, float *value1, uint32_t *value2)
 295 {
 296    fprintf(fp, "\t/* DEPTH_RANG_NEAR: depth_range: %f (0x%x) */\n",
 297            *value1, *(uint32_t *)value1);
 298 }
 299
 300 static void
 301 parse_plbu_depth_range_far(FILE *fp, float *value1, uint32_t *value2)
 302 {
 303    fprintf(fp, "\t/* DEPTH_RANGE_FAR: depth_range: %f (0x%x) */\n",
 304            *value1, *(uint32_t *)value1);
 305 }
 306
 307 static void
 308 parse_plbu_indexed_dest(FILE *fp, uint32_t *value1, uint32_t *value2)
 309 {
 310    fprintf(fp, "\t/* INDEXED_DEST: gl_pos: 0x%08x */\n", *value1);
 311 }
 312
 313 static void
 314 parse_plbu_indexed_pt_size(FILE *fp, uint32_t *value1, uint32_t *value2)
 315 {
 316    fprintf(fp, "\t/* INDEXED_PT_SIZE: pt_size: 0x%08x */\n", *value1);
 317 }
 318
 319 static void
 320 parse_plbu_indices(FILE *fp, uint32_t *value1, uint32_t *value2)
 321 {
 322    fprintf(fp, "\t/* INDICES: indices: 0x%x */\n", *value1);
 323 }
 324
 325 static void
 326 parse_plbu_draw_arrays(FILE *fp, uint32_t *value1, uint32_t *value2)
 327 {
 328    if ((*value1 == 0x00000000) && (*value2 == 0x00000000)) {
 329       fprintf(fp, "\t/* ---EMPTY CMD */\n");
 330       return;
 331    }
 332
 333    uint32_t count = (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8;
 334    uint32_t start = *value1 & 0x00ffffff;
 335    uint32_t mode = (*value2 & 0x001f0000) >> 16;
 336
 337    fprintf(fp, "\t/* DRAW_ARRAYS: count: %d, start: %d, mode: %d (0x%x) */\n",
 338            count, start, mode, mode);
 339 }
 340
 341 static void
 342 parse_plbu_draw_elements(FILE *fp, uint32_t *value1, uint32_t *value2)
 343 {
 344    uint32_t count = (*value1 & 0xff000000) >> 24 | (*value2 & 0x000000ff) << 8;
 345    uint32_t start = *value1 & 0x00ffffff;
 346    uint32_t mode = (*value2 & 0x001f0000) >> 16;
 347
 348    fprintf(fp, "\t/* DRAW_ELEMENTS: count: %d, start: %d, mode: %d (0x%x) */\n",
 349            count, start, mode, mode);
 350 }
 351
 352 static void
 353 parse_plbu_continue(FILE *fp, uint32_t *value1, uint32_t *value2)
 354 {
 355    fprintf(fp, "\t/* CONTINUE: continue at 0x%08x */\n", *value1);
 356 }
 357
 358 static void
 359 parse_plbu_end(FILE *fp, uint32_t *value1, uint32_t *value2)
 360 {
 361    fprintf(fp, "\t/* END (FINISH/FLUSH) */\n");
 362 }
 363
 364 void
 365 lima_parse_plbu(FILE *fp, uint32_t *data, int size, uint32_t start)
 366 {
 367    uint32_t *value1;
 368    uint32_t *value2;
 369
 370    fprintf(fp, "/* ============ PLBU CMD STREAM BEGIN ============= */\n");
 371    for (int i = 0; i * 4 < size; i += 2) {
 372       value1 = &data[i];
 373       value2 = &data[i + 1];
 374       fprintf(fp, "/* 0x%08x (0x%08x) */\t0x%08x 0x%08x",
 375               start + i * 4, i * 4, *value1, *value2);
 376
 377       if ((*value2 & 0xffe00000) == 0x00000000)
 378          parse_plbu_draw_arrays(fp, value1, value2);
 379       else if ((*value2 & 0xffe00000) == 0x00200000)
 380          parse_plbu_draw_elements(fp, value1, value2);
 381       else if ((*value2 & 0xff000fff) == 0x10000100)
 382          parse_plbu_indexed_dest(fp, value1, value2);
 383       else if ((*value2 & 0xff000fff) == 0x10000101)
 384          parse_plbu_indices(fp, value1, value2);
 385       else if ((*value2 & 0xff000fff) == 0x10000102)
 386          parse_plbu_indexed_pt_size(fp, value1, value2);
 387       else if ((*value2 & 0xff000fff) == 0x10000105)
 388          parse_plbu_viewport_bottom(fp, (float *)value1, value2);
 389       else if ((*value2 & 0xff000fff) == 0x10000106)
 390          parse_plbu_viewport_top(fp, (float *)value1, value2);
 391       else if ((*value2 & 0xff000fff) == 0x10000107)
 392          parse_plbu_viewport_left(fp, (float *)value1, value2);
 393       else if ((*value2 & 0xff000fff) == 0x10000108)
 394          parse_plbu_viewport_right(fp, (float *)value1, value2);
 395       else if ((*value2 & 0xff000fff) == 0x10000109)
 396          parse_plbu_tiled_dimensions(fp, value1, value2);
 397       else if ((*value2 & 0xff000fff) == 0x1000010a)
 398          parse_plbu_unknown_1(fp, value1, value2);
 399       else if ((*value2 & 0xff000fff) == 0x1000010b) /* also unknown_2 */
 400          parse_plbu_primitive_setup(fp, value1, value2);
 401       else if ((*value2 & 0xff000fff) == 0x1000010c)
 402          parse_plbu_block_step(fp, value1, value2);
 403       else if ((*value2 & 0xff000fff) == 0x1000010d)
 404          parse_plbu_low_prim_size(fp, (float *)value1, value2);
 405       else if ((*value2 & 0xff000fff) == 0x1000010e)
 406          parse_plbu_depth_range_near(fp, (float *)value1, value2);
 407       else if ((*value2 & 0xff000fff) == 0x1000010f)
 408          parse_plbu_depth_range_far(fp, (float *)value1, value2);
 409       else if ((*value2 & 0xff000000) == 0x28000000)
 410          parse_plbu_array_address(fp, value1, value2);
 411       else if ((*value2 & 0xf0000000) == 0x30000000)
 412          parse_plbu_block_stride(fp, value1, value2);
 413       else if (*value2 == 0x50000000)
 414          parse_plbu_end(fp, value1, value2);
 415       else if ((*value2  & 0xf0000000)== 0x60000000)
 416          parse_plbu_semaphore(fp, value1, value2);
 417       else if ((*value2  & 0xf0000000)== 0x70000000)
 418          parse_plbu_scissors(fp, value1, value2);
 419       else if ((*value2  & 0xf0000000)== 0x80000000)
 420          parse_plbu_rsw_vertex_array(fp, value1, value2);
 421       else if ((*value2  & 0xf0000000)== 0xf0000000)
 422          parse_plbu_continue(fp, value1, value2);
 423       else
 424          fprintf(fp, "\t/* --- unknown cmd --- */\n");
 425    }
 426    fprintf(fp, "/* ============ PLBU CMD STREAM END =============== */\n");
 427    fprintf(fp, "\n");
 428 }