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