1/* 2 * Copyright © 2007-2011 Intel Corporation 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, sublicense, 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 next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * 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 NONINFRINGEMENT. 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 FROM, 20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 * SOFTWARE. 22 * 23 * Authors: 24 * Eric Anholt <eric@anholt.net> 25 * Chris Wilson <chris@chris-wilson.co.uk> 26 * 27 */ 28 29#ifdef HAVE_CONFIG_H 30#include "config.h" 31#endif 32 33#include <sys/mman.h> 34#include <assert.h> 35 36#include "sna.h" 37#include "sna_reg.h" 38 39#include "gen4_render.h" 40 41#include "kgem_debug.h" 42 43static struct state { 44 struct vertex_buffer { 45 int handle; 46 void *base; 47 const char *ptr; 48 int pitch; 49 50 struct kgem_bo *current; 51 } vb[33]; 52 struct vertex_elements { 53 int buffer; 54 int offset; 55 bool valid; 56 uint32_t type; 57 uint8_t swizzle[4]; 58 } ve[33]; 59 int num_ve; 60 61 struct dynamic_state { 62 struct kgem_bo *current; 63 void *base, *ptr; 64 } dynamic_state; 65} state; 66 67static void gen4_update_vertex_buffer(struct kgem *kgem, const uint32_t *data) 68{ 69 uint32_t reloc = sizeof(uint32_t) * (&data[1] - kgem->batch); 70 struct kgem_bo *bo = NULL; 71 void *base, *ptr; 72 int i; 73 74 for (i = 0; i < kgem->nreloc; i++) 75 if (kgem->reloc[i].offset == reloc) 76 break; 77 assert(i < kgem->nreloc); 78 reloc = kgem->reloc[i].target_handle; 79 80 if (reloc == 0) { 81 base = kgem->batch; 82 } else { 83 list_for_each_entry(bo, &kgem->next_request->buffers, request) 84 if (bo->handle == reloc) 85 break; 86 assert(&bo->request != &kgem->next_request->buffers); 87 base = kgem_bo_map__debug(kgem, bo); 88 } 89 ptr = (char *)base + kgem->reloc[i].delta; 90 91 i = data[0] >> 27; 92 93 state.vb[i].current = bo; 94 state.vb[i].base = base; 95 state.vb[i].ptr = ptr; 96 state.vb[i].pitch = data[0] & 0x7ff; 97} 98 99static uint32_t 100get_ve_component(uint32_t data, int component) 101{ 102 return (data >> (16 + (3 - component) * 4)) & 0x7; 103} 104 105static void gen4_update_vertex_elements(struct kgem *kgem, int id, const uint32_t *data) 106{ 107 state.ve[id].buffer = data[0] >> 27; 108 state.ve[id].valid = !!(data[0] & (1 << 26)); 109 state.ve[id].type = (data[0] >> 16) & 0x1ff; 110 state.ve[id].offset = data[0] & 0x7ff; 111 state.ve[id].swizzle[0] = get_ve_component(data[1], 0); 112 state.ve[id].swizzle[1] = get_ve_component(data[1], 1); 113 state.ve[id].swizzle[2] = get_ve_component(data[1], 2); 114 state.ve[id].swizzle[3] = get_ve_component(data[1], 3); 115} 116 117static void vertices_sint16_out(const struct vertex_elements *ve, const int16_t *v, int max) 118{ 119 int c; 120 121 ErrorF("("); 122 for (c = 0; c < max; c++) { 123 switch (ve->swizzle[c]) { 124 case 0: ErrorF("#"); break; 125 case 1: ErrorF("%d", v[c]); break; 126 case 2: ErrorF("0.0"); break; 127 case 3: ErrorF("1.0"); break; 128 case 4: ErrorF("0x1"); break; 129 case 5: break; 130 default: ErrorF("?"); 131 } 132 if (c < 3) 133 ErrorF(", "); 134 } 135 for (; c < 4; c++) { 136 switch (ve->swizzle[c]) { 137 case 0: ErrorF("#"); break; 138 case 1: ErrorF("1.0"); break; 139 case 2: ErrorF("0.0"); break; 140 case 3: ErrorF("1.0"); break; 141 case 4: ErrorF("0x1"); break; 142 case 5: break; 143 default: ErrorF("?"); 144 } 145 if (c < 3) 146 ErrorF(", "); 147 } 148 ErrorF(")"); 149} 150 151static void vertices_float_out(const struct vertex_elements *ve, const float *f, int max) 152{ 153 int c, o; 154 155 ErrorF("("); 156 for (c = o = 0; c < 4 && o < max; c++) { 157 switch (ve->swizzle[c]) { 158 case 0: ErrorF("#"); break; 159 case 1: ErrorF("%f", f[o++]); break; 160 case 2: ErrorF("0.0"); break; 161 case 3: ErrorF("1.0"); break; 162 case 4: ErrorF("0x1"); break; 163 case 5: break; 164 default: ErrorF("?"); 165 } 166 if (c < 3) 167 ErrorF(", "); 168 } 169 for (; c < 4; c++) { 170 switch (ve->swizzle[c]) { 171 case 0: ErrorF("#"); break; 172 case 1: ErrorF("1.0"); break; 173 case 2: ErrorF("0.0"); break; 174 case 3: ErrorF("1.0"); break; 175 case 4: ErrorF("0x1"); break; 176 case 5: break; 177 default: ErrorF("?"); 178 } 179 if (c < 3) 180 ErrorF(", "); 181 } 182 ErrorF(")"); 183} 184 185static void ve_out(const struct vertex_elements *ve, const void *ptr) 186{ 187 switch (ve->type) { 188 case GEN4_SURFACEFORMAT_R32_FLOAT: 189 vertices_float_out(ve, ptr, 1); 190 break; 191 case GEN4_SURFACEFORMAT_R32G32_FLOAT: 192 vertices_float_out(ve, ptr, 2); 193 break; 194 case GEN4_SURFACEFORMAT_R32G32B32_FLOAT: 195 vertices_float_out(ve, ptr, 3); 196 break; 197 case GEN4_SURFACEFORMAT_R32G32B32A32_FLOAT: 198 vertices_float_out(ve, ptr, 4); 199 break; 200 case GEN4_SURFACEFORMAT_R16_SINT: 201 vertices_sint16_out(ve, ptr, 1); 202 break; 203 case GEN4_SURFACEFORMAT_R16G16_SINT: 204 vertices_sint16_out(ve, ptr, 2); 205 break; 206 case GEN4_SURFACEFORMAT_R16G16B16A16_SINT: 207 vertices_sint16_out(ve, ptr, 4); 208 break; 209 case GEN4_SURFACEFORMAT_R16_SSCALED: 210 vertices_sint16_out(ve, ptr, 1); 211 break; 212 case GEN4_SURFACEFORMAT_R16G16_SSCALED: 213 vertices_sint16_out(ve, ptr, 2); 214 break; 215 case GEN4_SURFACEFORMAT_R16G16B16A16_SSCALED: 216 vertices_sint16_out(ve, ptr, 4); 217 break; 218 } 219} 220 221static void indirect_vertex_out(struct kgem *kgem, uint32_t v) 222{ 223 int i = 0; 224 225 do { 226 const struct vertex_elements *ve = &state.ve[i]; 227 const struct vertex_buffer *vb = &state.vb[ve->buffer]; 228 const void *ptr = vb->ptr + v * vb->pitch + ve->offset; 229 230 if (!ve->valid) 231 continue; 232 233 ve_out(ve, ptr); 234 235 while (++i <= state.num_ve && !state.ve[i].valid) 236 ; 237 238 if (i <= state.num_ve) 239 ErrorF(", "); 240 } while (i <= state.num_ve); 241} 242 243static void primitive_out(struct kgem *kgem, uint32_t *data) 244{ 245 int n; 246 247 assert((data[0] & (1<<15)) == 0); /* XXX index buffers */ 248 249 for (n = 0; n < data[1]; n++) { 250 int v = data[2] + n; 251 ErrorF(" [%d:%d] = ", n, v); 252 indirect_vertex_out(kgem, v); 253 ErrorF("\n"); 254 } 255} 256 257static void 258state_base_out(uint32_t *data, uint32_t offset, unsigned int index, 259 const char *name) 260{ 261 if (data[index] & 1) 262 kgem_debug_print(data, offset, index, 263 "%s state base address 0x%08x\n", 264 name, data[index] & ~1); 265 else 266 kgem_debug_print(data, offset, index, 267 "%s state base not updated\n", 268 name); 269} 270 271static void 272state_max_out(uint32_t *data, uint32_t offset, unsigned int index, 273 const char *name) 274{ 275 if (data[index] == 1) 276 kgem_debug_print(data, offset, index, 277 "%s state upper bound disabled\n", name); 278 else if (data[index] & 1) 279 kgem_debug_print(data, offset, index, 280 "%s state upper bound 0x%08x\n", 281 name, data[index] & ~1); 282 else 283 kgem_debug_print(data, offset, index, 284 "%s state upper bound not updated\n", 285 name); 286} 287 288static const char * 289get_965_surfacetype(unsigned int surfacetype) 290{ 291 switch (surfacetype) { 292 case 0: return "1D"; 293 case 1: return "2D"; 294 case 2: return "3D"; 295 case 3: return "CUBE"; 296 case 4: return "BUFFER"; 297 case 7: return "NULL"; 298 default: return "unknown"; 299 } 300} 301 302static const char * 303get_965_depthformat(unsigned int depthformat) 304{ 305 switch (depthformat) { 306 case 0: return "s8_z24float"; 307 case 1: return "z32float"; 308 case 2: return "z24s8"; 309 case 5: return "z16"; 310 default: return "unknown"; 311 } 312} 313 314static const char * 315get_965_element_component(uint32_t data, int component) 316{ 317 uint32_t component_control = (data >> (16 + (3 - component) * 4)) & 0x7; 318 319 switch (component_control) { 320 case 0: 321 return "nostore"; 322 case 1: 323 switch (component) { 324 case 0: return "X"; 325 case 1: return "Y"; 326 case 2: return "Z"; 327 case 3: return "W"; 328 default: return "fail"; 329 } 330 case 2: 331 return "0.0"; 332 case 3: 333 return "1.0"; 334 case 4: 335 return "0x1"; 336 case 5: 337 return "VID"; 338 default: 339 return "fail"; 340 } 341} 342 343static const char * 344get_965_prim_type(uint32_t data) 345{ 346 uint32_t primtype = (data >> 10) & 0x1f; 347 348 switch (primtype) { 349 case 0x01: return "point list"; 350 case 0x02: return "line list"; 351 case 0x03: return "line strip"; 352 case 0x04: return "tri list"; 353 case 0x05: return "tri strip"; 354 case 0x06: return "tri fan"; 355 case 0x07: return "quad list"; 356 case 0x08: return "quad strip"; 357 case 0x09: return "line list adj"; 358 case 0x0a: return "line strip adj"; 359 case 0x0b: return "tri list adj"; 360 case 0x0c: return "tri strip adj"; 361 case 0x0d: return "tri strip reverse"; 362 case 0x0e: return "polygon"; 363 case 0x0f: return "rect list"; 364 case 0x10: return "line loop"; 365 case 0x11: return "point list bf"; 366 case 0x12: return "line strip cont"; 367 case 0x13: return "line strip bf"; 368 case 0x14: return "line strip cont bf"; 369 case 0x15: return "tri fan no stipple"; 370 default: return "fail"; 371 } 372} 373 374#if 0 375struct reloc { 376 struct kgem_bo *bo; 377 void *base; 378}; 379 380static void * 381get_reloc(struct kgem *kgem, 382 void *base, const uint32_t *reloc, 383 struct reloc *r) 384{ 385 uint32_t delta = *reloc; 386 387 memset(r, 0, sizeof(*r)); 388 389 if (base == 0) { 390 uint32_t handle = sizeof(uint32_t) * (reloc - kgem->batch); 391 struct kgem_bo *bo = NULL; 392 int i; 393 394 for (i = 0; i < kgem->nreloc; i++) 395 if (kgem->reloc[i].offset == handle) 396 break; 397 assert(i < kgem->nreloc); 398 handle = kgem->reloc[i].target_handle; 399 delta = kgem->reloc[i].delta; 400 401 if (handle == 0) { 402 base = kgem->batch; 403 } else { 404 list_for_each_entry(bo, &kgem->next_request->buffers, request) 405 if (bo->handle == handle) 406 break; 407 assert(&bo->request != &kgem->next_request->buffers); 408 base = kgem_bo_map__debug(kgem, bo); 409 r->bo = bo; 410 r->base = base; 411 } 412 } 413 414 return (char *)base + delta; 415} 416#endif 417 418int kgem_gen4_decode_3d(struct kgem *kgem, uint32_t offset) 419{ 420 static const struct { 421 uint32_t opcode; 422 int min_len; 423 int max_len; 424 const char *name; 425 } opcodes[] = { 426 { 0x6000, 3, 3, "URB_FENCE" }, 427 { 0x6001, 2, 2, "CS_URB_FENCE" }, 428 { 0x6002, 2, 2, "CONSTANT_BUFFER" }, 429 { 0x6101, 6, 6, "STATE_BASE_ADDRESS" }, 430 { 0x6102, 2, 2 , "STATE_SIP" }, 431 { 0x6104, 1, 1, "3DSTATE_PIPELINE_SELECT" }, 432 { 0x680b, 1, 1, "3DSTATE_VF_STATISTICS" }, 433 { 0x6904, 1, 1, "3DSTATE_PIPELINE_SELECT" }, 434 { 0x7800, 7, 7, "3DSTATE_PIPELINED_POINTERS" }, 435 { 0x7801, 6, 6, "3DSTATE_BINDING_TABLE_POINTERS" }, 436 { 0x7808, 5, 257, "3DSTATE_VERTEX_BUFFERS" }, 437 { 0x7809, 3, 256, "3DSTATE_VERTEX_ELEMENTS" }, 438 { 0x780a, 3, 3, "3DSTATE_INDEX_BUFFER" }, 439 { 0x780b, 1, 1, "3DSTATE_VF_STATISTICS" }, 440 { 0x7900, 4, 4, "3DSTATE_DRAWING_RECTANGLE" }, 441 { 0x7901, 5, 5, "3DSTATE_CONSTANT_COLOR" }, 442 { 0x7905, 5, 7, "3DSTATE_DEPTH_BUFFER" }, 443 { 0x7906, 2, 2, "3DSTATE_POLY_STIPPLE_OFFSET" }, 444 { 0x7907, 33, 33, "3DSTATE_POLY_STIPPLE_PATTERN" }, 445 { 0x7908, 3, 3, "3DSTATE_LINE_STIPPLE" }, 446 { 0x7909, 2, 2, "3DSTATE_GLOBAL_DEPTH_OFFSET_CLAMP" }, 447 { 0x7909, 2, 2, "3DSTATE_CLEAR_PARAMS" }, 448 { 0x790a, 3, 3, "3DSTATE_AA_LINE_PARAMETERS" }, 449 { 0x790b, 4, 4, "3DSTATE_GS_SVB_INDEX" }, 450 { 0x790d, 3, 3, "3DSTATE_MULTISAMPLE" }, 451 { 0x7910, 2, 2, "3DSTATE_CLEAR_PARAMS" }, 452 { 0x7b00, 6, 6, "3DPRIMITIVE" }, 453 { 0x7805, 3, 3, "3DSTATE_URB" }, 454 { 0x7815, 5, 5, "3DSTATE_CONSTANT_VS_STATE" }, 455 { 0x7816, 5, 5, "3DSTATE_CONSTANT_GS_STATE" }, 456 { 0x7817, 5, 5, "3DSTATE_CONSTANT_PS_STATE" }, 457 { 0x7818, 2, 2, "3DSTATE_SAMPLE_MASK" }, 458 }; 459 uint32_t *data = kgem->batch + offset; 460 uint32_t op; 461 unsigned int len; 462 int i; 463 const char *desc1 = NULL; 464 465 len = (data[0] & 0xff) + 2; 466 op = (data[0] & 0xffff0000) >> 16; 467 switch (op) { 468 case 0x6000: 469 assert(len == 3); 470 471 kgem_debug_print(data, offset, 0, "URB_FENCE: %s%s%s%s%s%s\n", 472 (data[0] >> 13) & 1 ? "cs " : "", 473 (data[0] >> 12) & 1 ? "vfe " : "", 474 (data[0] >> 11) & 1 ? "sf " : "", 475 (data[0] >> 10) & 1 ? "clip " : "", 476 (data[0] >> 9) & 1 ? "gs " : "", 477 (data[0] >> 8) & 1 ? "vs " : ""); 478 kgem_debug_print(data, offset, 1, 479 "vs fence: %d, gs_fence: %d, clip_fence: %d\n", 480 data[1] & 0x3ff, 481 (data[1] >> 10) & 0x3ff, 482 (data[1] >> 20) & 0x3ff); 483 kgem_debug_print(data, offset, 2, 484 "sf fence: %d, vfe_fence: %d, cs_fence: %d\n", 485 data[2] & 0x3ff, 486 (data[2] >> 10) & 0x3ff, 487 (data[2] >> 20) & 0x7ff); 488 return len; 489 490 case 0x6001: 491 kgem_debug_print(data, offset, 0, "CS_URB_STATE\n"); 492 kgem_debug_print(data, offset, 1, "entry_size: %d [%d bytes], n_entries: %d\n", 493 (data[1] >> 4) & 0x1f, 494 (((data[1] >> 4) & 0x1f) + 1) * 64, 495 data[1] & 0x7); 496 return len; 497 case 0x6002: 498 kgem_debug_print(data, offset, 0, "CONSTANT_BUFFER: %s\n", 499 (data[0] >> 8) & 1 ? "valid" : "invalid"); 500 kgem_debug_print(data, offset, 1, "offset: 0x%08x, length: %d bytes\n", 501 data[1] & ~0x3f, ((data[1] & 0x3f) + 1) * 64); 502 return len; 503 case 0x6101: 504 i = 0; 505 kgem_debug_print(data, offset, i++, "STATE_BASE_ADDRESS\n"); 506 assert(len == 6); 507 508 state_base_out(data, offset, i++, "general"); 509 state_base_out(data, offset, i++, "surface"); 510 state_base_out(data, offset, i++, "media"); 511 512 state_max_out(data, offset, i++, "general"); 513 state_max_out(data, offset, i++, "media"); 514 515 return len; 516 517 case 0x7801: 518 assert(len == 6); 519 520 kgem_debug_print(data, offset, 0, 521 "3DSTATE_BINDING_TABLE_POINTERS\n"); 522 kgem_debug_print(data, offset, 1, "VS binding table\n"); 523 kgem_debug_print(data, offset, 2, "GS binding table\n"); 524 kgem_debug_print(data, offset, 3, "CLIP binding table\n"); 525 kgem_debug_print(data, offset, 4, "SF binding table\n"); 526 kgem_debug_print(data, offset, 5, "WM binding table\n"); 527 528 return len; 529 530 case 0x7808: 531 assert((len - 1) % 4 == 0); 532 kgem_debug_print(data, offset, 0, "3DSTATE_VERTEX_BUFFERS\n"); 533 534 for (i = 1; i < len;) { 535 gen4_update_vertex_buffer(kgem, data + i); 536 537 kgem_debug_print(data, offset, i, "buffer %d: %s, pitch %db\n", 538 data[i] >> 27, 539 data[i] & (1 << 20) ? "random" : "sequential", 540 data[i] & 0x07ff); 541 i++; 542 kgem_debug_print(data, offset, i++, "buffer address\n"); 543 kgem_debug_print(data, offset, i++, "max index\n"); 544 kgem_debug_print(data, offset, i++, "mbz\n"); 545 } 546 return len; 547 548 case 0x7809: 549 assert((len + 1) % 2 == 0); 550 kgem_debug_print(data, offset, 0, "3DSTATE_VERTEX_ELEMENTS\n"); 551 552 memset(state.ve, 0, sizeof(state.ve)); /* XXX? */ 553 for (i = 1; i < len;) { 554 gen4_update_vertex_elements(kgem, (i - 1)/2, data + i); 555 556 kgem_debug_print(data, offset, i, "buffer %d: %svalid, type 0x%04x, " 557 "src offset 0x%04x bytes\n", 558 data[i] >> 27, 559 data[i] & (1 << 26) ? "" : "in", 560 (data[i] >> 16) & 0x1ff, 561 data[i] & 0x07ff); 562 i++; 563 kgem_debug_print(data, offset, i, "(%s, %s, %s, %s), " 564 "dst offset 0x%02x bytes\n", 565 get_965_element_component(data[i], 0), 566 get_965_element_component(data[i], 1), 567 get_965_element_component(data[i], 2), 568 get_965_element_component(data[i], 3), 569 (data[i] & 0xff) * 4); 570 i++; 571 } 572 state.num_ve = (len - 1) / 2; /* XXX? */ 573 return len; 574 575 case 0x780a: 576 assert(len == 3); 577 kgem_debug_print(data, offset, 0, "3DSTATE_INDEX_BUFFER\n"); 578 kgem_debug_print(data, offset, 1, "beginning buffer address\n"); 579 kgem_debug_print(data, offset, 2, "ending buffer address\n"); 580 return len; 581 582 case 0x7900: 583 assert(len == 4); 584 kgem_debug_print(data, offset, 0, 585 "3DSTATE_DRAWING_RECTANGLE\n"); 586 kgem_debug_print(data, offset, 1, "top left: %d,%d\n", 587 data[1] & 0xffff, 588 (data[1] >> 16) & 0xffff); 589 kgem_debug_print(data, offset, 2, "bottom right: %d,%d\n", 590 data[2] & 0xffff, 591 (data[2] >> 16) & 0xffff); 592 kgem_debug_print(data, offset, 3, "origin: %d,%d\n", 593 (int)data[3] & 0xffff, 594 ((int)data[3] >> 16) & 0xffff); 595 return len; 596 597 case 0x7905: 598 assert(len == 7); 599 kgem_debug_print(data, offset, 0, 600 "3DSTATE_DEPTH_BUFFER\n"); 601 kgem_debug_print(data, offset, 1, "%s, %s, pitch = %d bytes, %stiled, HiZ %d, Separate Stencil %d\n", 602 get_965_surfacetype(data[1] >> 29), 603 get_965_depthformat((data[1] >> 18) & 0x7), 604 (data[1] & 0x0001ffff) + 1, 605 data[1] & (1 << 27) ? "" : "not ", 606 (data[1] & (1 << 22)) != 0, 607 (data[1] & (1 << 21)) != 0); 608 kgem_debug_print(data, offset, 2, "depth offset\n"); 609 kgem_debug_print(data, offset, 3, "%dx%d\n", 610 ((data[3] & 0x0007ffc0) >> 6) + 1, 611 ((data[3] & 0xfff80000) >> 19) + 1); 612 kgem_debug_print(data, offset, 4, "volume depth\n"); 613 kgem_debug_print(data, offset, 5, "\n"); 614 kgem_debug_print(data, offset, 6, "\n"); 615 return len; 616 617 case 0x7a00: 618 assert(len == 4 || len == 5); 619 switch ((data[1] >> 14) & 0x3) { 620 case 0: desc1 = "no write"; break; 621 case 1: desc1 = "qword write"; break; 622 case 2: desc1 = "PS_DEPTH_COUNT write"; break; 623 case 3: desc1 = "TIMESTAMP write"; break; 624 } 625 kgem_debug_print(data, offset, 0, "PIPE_CONTROL\n"); 626 kgem_debug_print(data, offset, 1, 627 "%s, %scs stall, %stlb invalidate, " 628 "%ssync gfdt, %sdepth stall, %sRC write flush, " 629 "%sinst flush, %sTC flush\n", 630 desc1, 631 data[1] & (1 << 20) ? "" : "no ", 632 data[1] & (1 << 18) ? "" : "no ", 633 data[1] & (1 << 17) ? "" : "no ", 634 data[1] & (1 << 13) ? "" : "no ", 635 data[1] & (1 << 12) ? "" : "no ", 636 data[1] & (1 << 11) ? "" : "no ", 637 data[1] & (1 << 10) ? "" : "no "); 638 if (len == 5) { 639 kgem_debug_print(data, offset, 2, "destination address\n"); 640 kgem_debug_print(data, offset, 3, "immediate dword low\n"); 641 kgem_debug_print(data, offset, 4, "immediate dword high\n"); 642 } else { 643 for (i = 2; i < len; i++) { 644 kgem_debug_print(data, offset, i, "\n"); 645 } 646 } 647 return len; 648 649 case 0x7b00: 650 assert(len == 6); 651 kgem_debug_print(data, offset, 0, 652 "3DPRIMITIVE: %s %s\n", 653 get_965_prim_type(data[0]), 654 (data[0] & (1 << 15)) ? "random" : "sequential"); 655 kgem_debug_print(data, offset, 1, "vertex count\n"); 656 kgem_debug_print(data, offset, 2, "start vertex\n"); 657 kgem_debug_print(data, offset, 3, "instance count\n"); 658 kgem_debug_print(data, offset, 4, "start instance\n"); 659 kgem_debug_print(data, offset, 5, "index bias\n"); 660 primitive_out(kgem, data); 661 return len; 662 } 663 664 /* For the rest, just dump the bytes */ 665 for (i = 0; i < ARRAY_SIZE(opcodes); i++) 666 if (op == opcodes[i].opcode) 667 break; 668 669 assert(i < ARRAY_SIZE(opcodes)); 670 671 len = 1; 672 kgem_debug_print(data, offset, 0, "%s\n", opcodes[i].name); 673 if (opcodes[i].max_len > 1) { 674 len = (data[0] & 0xff) + 2; 675 assert(len >= opcodes[i].min_len && 676 len <= opcodes[i].max_len); 677 } 678 679 for (i = 1; i < len; i++) 680 kgem_debug_print(data, offset, i, "dword %d\n", i); 681 682 return len; 683} 684 685void kgem_gen4_finish_state(struct kgem *kgem) 686{ 687 memset(&state, 0, sizeof(state)); 688} 689