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