Subversion Repositories Kolibri OS

Rev

Rev 4245 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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. #include "gen6_render.h"
  39.  
  40. #include "kgem_debug.h"
  41.  
  42. static struct state {
  43.         struct vertex_buffer {
  44.                 int handle;
  45.                 const char *ptr;
  46.                 int pitch;
  47.  
  48.                 struct kgem_bo *current;
  49.         } vb[33];
  50.         struct vertex_elements {
  51.                 int buffer;
  52.                 int offset;
  53.                 bool valid;
  54.                 uint32_t type;
  55.                 uint8_t swizzle[4];
  56.         } ve[33];
  57.         int num_ve;
  58.  
  59.         struct dynamic_state {
  60.                 struct kgem_bo *current;
  61.                 void *base, *ptr;
  62.         } dynamic_state;
  63. } state;
  64.  
  65. static void gen6_update_vertex_buffer(struct kgem *kgem, const uint32_t *data)
  66. {
  67.         uint32_t reloc = sizeof(uint32_t) * (&data[1] - kgem->batch);
  68.         struct kgem_bo *bo = NULL;
  69.         void *base;
  70.         int i;
  71.  
  72.         for (i = 0; i < kgem->nreloc; i++)
  73.                 if (kgem->reloc[i].offset == reloc)
  74.                         break;
  75.         assert(i < kgem->nreloc);
  76.         reloc = kgem->reloc[i].target_handle;
  77.  
  78.         if (reloc == -1) {
  79.                 base = kgem->batch;
  80.         } else {
  81.                 list_for_each_entry(bo, &kgem->next_request->buffers, request)
  82.                         if (bo->target_handle == reloc)
  83.                                 break;
  84.                 assert(&bo->request != &kgem->next_request->buffers);
  85.                 base = kgem_bo_map__debug(kgem, bo);
  86.         }
  87.  
  88.         base = (char *)base + kgem->reloc[i].delta;
  89.         i = data[0] >> 26;
  90.  
  91.         state.vb[i].current = bo;
  92.         state.vb[i].ptr = base;
  93.         state.vb[i].pitch = data[0] & 0x7ff;
  94. }
  95.  
  96. static void gen6_update_dynamic_buffer(struct kgem *kgem, const uint32_t offset)
  97. {
  98.         uint32_t reloc = sizeof(uint32_t) * offset;
  99.         struct kgem_bo *bo = NULL;
  100.         void *base, *ptr;
  101.         int i;
  102.  
  103.         if ((kgem->batch[offset] & 1) == 0)
  104.                 return;
  105.  
  106.         for (i = 0; i < kgem->nreloc; i++)
  107.                 if (kgem->reloc[i].offset == reloc)
  108.                         break;
  109.         if(i < kgem->nreloc) {
  110.                 reloc = kgem->reloc[i].target_handle;
  111.  
  112.                 if (reloc == 0) {
  113.                         base = kgem->batch;
  114.                 } else {
  115.                         list_for_each_entry(bo, &kgem->next_request->buffers, request)
  116.                                 if (bo->handle == reloc)
  117.                                         break;
  118.                         assert(&bo->request != &kgem->next_request->buffers);
  119.                         base = kgem_bo_map__debug(kgem, bo);
  120.                 }
  121.                 ptr = (char *)base + (kgem->reloc[i].delta & ~1);
  122.         } else {
  123.                 bo = NULL;
  124.                 base = NULL;
  125.                 ptr = NULL;
  126.         }
  127.  
  128.         state.dynamic_state.current = bo;
  129.         state.dynamic_state.base = base;
  130.         state.dynamic_state.ptr = ptr;
  131. }
  132.  
  133. static uint32_t
  134. get_ve_component(uint32_t data, int component)
  135. {
  136.         return (data >> (16 + (3 - component) * 4)) & 0x7;
  137. }
  138.  
  139. static void gen6_update_vertex_elements(struct kgem *kgem, int id, const uint32_t *data)
  140. {
  141.         state.ve[id].buffer = data[0] >> 26;
  142.         state.ve[id].valid = !!(data[0] & (1 << 25));
  143.         state.ve[id].type = (data[0] >> 16) & 0x1ff;
  144.         state.ve[id].offset = data[0] & 0x7ff;
  145.         state.ve[id].swizzle[0] = get_ve_component(data[1], 0);
  146.         state.ve[id].swizzle[1] = get_ve_component(data[1], 1);
  147.         state.ve[id].swizzle[2] = get_ve_component(data[1], 2);
  148.         state.ve[id].swizzle[3] = get_ve_component(data[1], 3);
  149. }
  150.  
  151. static void gen6_update_sf_state(struct kgem *kgem, uint32_t *data)
  152. {
  153.         state.num_ve = 1 + ((data[1] >> 22) & 0x3f);
  154. }
  155.  
  156. static void vertices_sint16_out(const struct vertex_elements *ve, const int16_t *v, int max)
  157. {
  158.         int c;
  159.  
  160.         ErrorF("(");
  161.         for (c = 0; c < max; c++) {
  162.                 switch (ve->swizzle[c]) {
  163.                 case 0: ErrorF("#"); break;
  164.                 case 1: ErrorF("%d", v[c]); break;
  165.                 case 2: ErrorF("0.0"); break;
  166.                 case 3: ErrorF("1.0"); break;
  167.                 case 4: ErrorF("0x1"); break;
  168.                 case 5: break;
  169.                 default: ErrorF("?");
  170.                 }
  171.                 if (c < 3)
  172.                         ErrorF(", ");
  173.         }
  174.         for (; c < 4; c++) {
  175.                 switch (ve->swizzle[c]) {
  176.                 case 0: ErrorF("#"); break;
  177.                 case 1: ErrorF("1.0"); break;
  178.                 case 2: ErrorF("0.0"); break;
  179.                 case 3: ErrorF("1.0"); break;
  180.                 case 4: ErrorF("0x1"); break;
  181.                 case 5: break;
  182.                 default: ErrorF("?");
  183.                 }
  184.                 if (c < 3)
  185.                         ErrorF(", ");
  186.         }
  187.         ErrorF(")");
  188. }
  189.  
  190. static void vertices_float_out(const struct vertex_elements *ve, const float *f, int max)
  191. {
  192.         int c, o;
  193.  
  194.         ErrorF("(");
  195.         for (c = o = 0; c < 4 && o < max; c++) {
  196.                 switch (ve->swizzle[c]) {
  197.                 case 0: ErrorF("#"); break;
  198.                 case 1: ErrorF("%f", f[o++]); break;
  199.                 case 2: ErrorF("0.0"); break;
  200.                 case 3: ErrorF("1.0"); break;
  201.                 case 4: ErrorF("0x1"); break;
  202.                 case 5: break;
  203.                 default: ErrorF("?");
  204.                 }
  205.                 if (c < 3)
  206.                         ErrorF(", ");
  207.         }
  208.         for (; c < 4; c++) {
  209.                 switch (ve->swizzle[c]) {
  210.                 case 0: ErrorF("#"); break;
  211.                 case 1: ErrorF("1.0"); break;
  212.                 case 2: ErrorF("0.0"); break;
  213.                 case 3: ErrorF("1.0"); break;
  214.                 case 4: ErrorF("0x1"); break;
  215.                 case 5: break;
  216.                 default: ErrorF("?");
  217.                 }
  218.                 if (c < 3)
  219.                         ErrorF(", ");
  220.         }
  221.         ErrorF(")");
  222. }
  223.  
  224. static void ve_out(const struct vertex_elements *ve, const void *ptr)
  225. {
  226.         switch (ve->type) {
  227.         case GEN6_SURFACEFORMAT_R32_FLOAT:
  228.                 vertices_float_out(ve, ptr, 1);
  229.                 break;
  230.         case GEN6_SURFACEFORMAT_R32G32_FLOAT:
  231.                 vertices_float_out(ve, ptr, 2);
  232.                 break;
  233.         case GEN6_SURFACEFORMAT_R32G32B32_FLOAT:
  234.                 vertices_float_out(ve, ptr, 3);
  235.                 break;
  236.         case GEN6_SURFACEFORMAT_R32G32B32A32_FLOAT:
  237.                 vertices_float_out(ve, ptr, 4);
  238.                 break;
  239.         case GEN6_SURFACEFORMAT_R16_SINT:
  240.                 vertices_sint16_out(ve, ptr, 1);
  241.                 break;
  242.         case GEN6_SURFACEFORMAT_R16G16_SINT:
  243.                 vertices_sint16_out(ve, ptr, 2);
  244.                 break;
  245.         case GEN6_SURFACEFORMAT_R16G16B16A16_SINT:
  246.                 vertices_sint16_out(ve, ptr, 4);
  247.                 break;
  248.         case GEN6_SURFACEFORMAT_R16_SSCALED:
  249.                 vertices_sint16_out(ve, ptr, 1);
  250.                 break;
  251.         case GEN6_SURFACEFORMAT_R16G16_SSCALED:
  252.                 vertices_sint16_out(ve, ptr, 2);
  253.                 break;
  254.         case GEN6_SURFACEFORMAT_R16G16B16A16_SSCALED:
  255.                 vertices_sint16_out(ve, ptr, 4);
  256.                 break;
  257.         }
  258. }
  259.  
  260. static void indirect_vertex_out(struct kgem *kgem, uint32_t v)
  261. {
  262.         int i = 1;
  263.  
  264.         do {
  265.                 const struct vertex_elements *ve = &state.ve[i];
  266.                 const struct vertex_buffer *vb = &state.vb[ve->buffer];
  267.                 const void *ptr = vb->ptr + v * vb->pitch + ve->offset;
  268.  
  269.                 if (ve->valid)
  270.                         ve_out(ve, ptr);
  271.  
  272.                 while (++i <= state.num_ve && !state.ve[i].valid)
  273.                         ;
  274.  
  275.                 if (i <= state.num_ve)
  276.                         ErrorF(", ");
  277.         } while (i <= state.num_ve);
  278. }
  279.  
  280. static void primitive_out(struct kgem *kgem, uint32_t *data)
  281. {
  282.         int n;
  283.  
  284.         assert((data[0] & (1<<15)) == 0); /* XXX index buffers */
  285.  
  286.         for (n = 0; n < data[1]; n++) {
  287.                 int v = data[2] + n;
  288.                 ErrorF("        [%d:%d] = ", n, v);
  289.                 indirect_vertex_out(kgem, v);
  290.                 ErrorF("\n");
  291.         }
  292. }
  293.  
  294. static void finish_state(struct kgem *kgem)
  295. {
  296.         memset(&state, 0, sizeof(state));
  297. }
  298.  
  299. static void
  300. state_base_out(uint32_t *data, uint32_t offset, unsigned int index,
  301.                const char *name)
  302. {
  303.     if (data[index] & 1)
  304.         kgem_debug_print(data, offset, index,
  305.                   "%s state base address 0x%08x\n",
  306.                   name, data[index] & ~1);
  307.     else
  308.         kgem_debug_print(data, offset, index,
  309.                   "%s state base not updated\n",
  310.                   name);
  311. }
  312.  
  313. static void
  314. state_max_out(uint32_t *data, uint32_t offset, unsigned int index,
  315.               const char *name)
  316. {
  317.         if (data[index] == 1)
  318.                 kgem_debug_print(data, offset, index,
  319.                           "%s state upper bound disabled\n", name);
  320.         else if (data[index] & 1)
  321.                 kgem_debug_print(data, offset, index,
  322.                           "%s state upper bound 0x%08x\n",
  323.                           name, data[index] & ~1);
  324.         else
  325.                 kgem_debug_print(data, offset, index,
  326.                           "%s state upper bound not updated\n",
  327.                           name);
  328. }
  329.  
  330. static const char *
  331. get_965_surfacetype(unsigned int surfacetype)
  332. {
  333.         switch (surfacetype) {
  334.         case 0: return "1D";
  335.         case 1: return "2D";
  336.         case 2: return "3D";
  337.         case 3: return "CUBE";
  338.         case 4: return "BUFFER";
  339.         case 7: return "NULL";
  340.         default: return "unknown";
  341.         }
  342. }
  343.  
  344. static const char *
  345. get_965_depthformat(unsigned int depthformat)
  346. {
  347.         switch (depthformat) {
  348.         case 0: return "s8_z24float";
  349.         case 1: return "z32float";
  350.         case 2: return "z24s8";
  351.         case 5: return "z16";
  352.         default: return "unknown";
  353.         }
  354. }
  355.  
  356. static const char *
  357. get_965_element_component(uint32_t data, int component)
  358. {
  359.         uint32_t component_control = (data >> (16 + (3 - component) * 4)) & 0x7;
  360.  
  361.         switch (component_control) {
  362.         case 0:
  363.                 return "nostore";
  364.         case 1:
  365.                 switch (component) {
  366.                 case 0: return "X";
  367.                 case 1: return "Y";
  368.                 case 2: return "Z";
  369.                 case 3: return "W";
  370.                 default: return "fail";
  371.                 }
  372.         case 2:
  373.                 return "0.0";
  374.         case 3:
  375.                 return "1.0";
  376.         case 4:
  377.                 return "0x1";
  378.         case 5:
  379.                 return "VID";
  380.         default:
  381.                 return "fail";
  382.         }
  383. }
  384.  
  385. static const char *
  386. get_965_prim_type(uint32_t data)
  387. {
  388.         uint32_t primtype = (data >> 10) & 0x1f;
  389.  
  390.         switch (primtype) {
  391.         case 0x01: return "point list";
  392.         case 0x02: return "line list";
  393.         case 0x03: return "line strip";
  394.         case 0x04: return "tri list";
  395.         case 0x05: return "tri strip";
  396.         case 0x06: return "tri fan";
  397.         case 0x07: return "quad list";
  398.         case 0x08: return "quad strip";
  399.         case 0x09: return "line list adj";
  400.         case 0x0a: return "line strip adj";
  401.         case 0x0b: return "tri list adj";
  402.         case 0x0c: return "tri strip adj";
  403.         case 0x0d: return "tri strip reverse";
  404.         case 0x0e: return "polygon";
  405.         case 0x0f: return "rect list";
  406.         case 0x10: return "line loop";
  407.         case 0x11: return "point list bf";
  408.         case 0x12: return "line strip cont";
  409.         case 0x13: return "line strip bf";
  410.         case 0x14: return "line strip cont bf";
  411.         case 0x15: return "tri fan no stipple";
  412.         default: return "fail";
  413.         }
  414. }
  415.  
  416. struct reloc {
  417.         struct kgem_bo *bo;
  418.         void *base;
  419. };
  420.  
  421. static void *
  422. get_reloc(struct kgem *kgem,
  423.           void *base, const uint32_t *reloc,
  424.           struct reloc *r)
  425. {
  426.         uint32_t delta = *reloc;
  427.  
  428.         memset(r, 0, sizeof(*r));
  429.  
  430.         if (base == 0) {
  431.                 uint32_t handle = sizeof(uint32_t) * (reloc - kgem->batch);
  432.                 struct kgem_bo *bo = NULL;
  433.                 int i;
  434.  
  435.                 for (i = 0; i < kgem->nreloc; i++)
  436.                         if (kgem->reloc[i].offset == handle)
  437.                                 break;
  438.                 assert(i < kgem->nreloc);
  439.                 handle = kgem->reloc[i].target_handle;
  440.                 delta = kgem->reloc[i].delta;
  441.  
  442.                 if (handle == 0) {
  443.                         base = kgem->batch;
  444.                 } else {
  445.                         list_for_each_entry(bo, &kgem->next_request->buffers, request)
  446.                                 if (bo->handle == handle)
  447.                                         break;
  448.                         assert(&bo->request != &kgem->next_request->buffers);
  449.                         base = kgem_bo_map__debug(kgem, bo);
  450.                         r->bo = bo;
  451.                         r->base = base;
  452.                 }
  453.         }
  454.  
  455.         return (char *)base + (delta & ~3);
  456. }
  457.  
  458. static const char *
  459. gen6_filter_to_string(uint32_t filter)
  460. {
  461.         switch (filter) {
  462.         default:
  463.         case GEN6_MAPFILTER_NEAREST: return "nearest";
  464.         case GEN6_MAPFILTER_LINEAR: return "linear";
  465.         }
  466. }
  467.  
  468. static const char *
  469. gen6_repeat_to_string(uint32_t repeat)
  470. {
  471.         switch (repeat) {
  472.         default:
  473.         case GEN6_TEXCOORDMODE_CLAMP_BORDER: return "border";
  474.         case GEN6_TEXCOORDMODE_WRAP: return "wrap";
  475.         case GEN6_TEXCOORDMODE_CLAMP: return "clamp";
  476.         case GEN6_TEXCOORDMODE_MIRROR: return "mirror";
  477.         }
  478. }
  479.  
  480. static void
  481. gen6_decode_sampler_state(struct kgem *kgem, const uint32_t *reloc)
  482. {
  483.         const struct gen6_sampler_state *ss;
  484.         struct reloc r;
  485.         const char *min, *mag;
  486.         const char *s_wrap, *t_wrap, *r_wrap;
  487.  
  488.         ss = get_reloc(kgem, state.dynamic_state.ptr, reloc, &r);
  489.  
  490.         min = gen6_filter_to_string(ss->ss0.min_filter);
  491.         mag = gen6_filter_to_string(ss->ss0.mag_filter);
  492.  
  493.         s_wrap = gen6_repeat_to_string(ss->ss1.s_wrap_mode);
  494.         t_wrap = gen6_repeat_to_string(ss->ss1.t_wrap_mode);
  495.         r_wrap = gen6_repeat_to_string(ss->ss1.r_wrap_mode);
  496.  
  497.         ErrorF("  Sampler 0:\n");
  498.         ErrorF("    filter: min=%s, mag=%s\n", min, mag);
  499.         ErrorF("    wrap: s=%s, t=%s, r=%s\n", s_wrap, t_wrap, r_wrap);
  500.  
  501.         ss++;
  502.         min = gen6_filter_to_string(ss->ss0.min_filter);
  503.         mag = gen6_filter_to_string(ss->ss0.mag_filter);
  504.  
  505.         s_wrap = gen6_repeat_to_string(ss->ss1.s_wrap_mode);
  506.         t_wrap = gen6_repeat_to_string(ss->ss1.t_wrap_mode);
  507.         r_wrap = gen6_repeat_to_string(ss->ss1.r_wrap_mode);
  508.  
  509.         ErrorF("  Sampler 1:\n");
  510.         ErrorF("    filter: min=%s, mag=%s\n", min, mag);
  511.         ErrorF("    wrap: s=%s, t=%s, r=%s\n", s_wrap, t_wrap, r_wrap);
  512. }
  513.  
  514. static const char *
  515. gen6_blend_factor_to_string(uint32_t v)
  516. {
  517.         switch (v) {
  518. #define C(x) case GEN6_BLENDFACTOR_##x: return #x;
  519.                 C(ONE);
  520.                 C(SRC_COLOR);
  521.                 C(SRC_ALPHA);
  522.                 C(DST_ALPHA);
  523.                 C(DST_COLOR);
  524.                 C(SRC_ALPHA_SATURATE);
  525.                 C(CONST_COLOR);
  526.                 C(CONST_ALPHA);
  527.                 C(SRC1_COLOR);
  528.                 C(SRC1_ALPHA);
  529.                 C(ZERO);
  530.                 C(INV_SRC_COLOR);
  531.                 C(INV_SRC_ALPHA);
  532.                 C(INV_DST_ALPHA);
  533.                 C(INV_DST_COLOR);
  534.                 C(INV_CONST_COLOR);
  535.                 C(INV_CONST_ALPHA);
  536.                 C(INV_SRC1_COLOR);
  537.                 C(INV_SRC1_ALPHA);
  538. #undef C
  539.         default: return "???";
  540.         }
  541. }
  542.  
  543. static const char *
  544. gen6_blend_function_to_string(uint32_t v)
  545. {
  546.         switch (v) {
  547. #define C(x) case GEN6_BLENDFUNCTION_##x: return #x;
  548.                 C(ADD);
  549.                 C(SUBTRACT);
  550.                 C(REVERSE_SUBTRACT);
  551.                 C(MIN);
  552.                 C(MAX);
  553. #undef C
  554.         default: return "???";
  555.         }
  556. }
  557.  
  558. static float unpack_float(uint32_t dw)
  559. {
  560.         union {
  561.                 float f;
  562.                 uint32_t dw;
  563.         } u;
  564.         u.dw = dw;
  565.         return u.f;
  566. }
  567.  
  568. static void
  569. gen6_decode_blend(struct kgem *kgem, const uint32_t *reloc)
  570. {
  571.         const struct gen6_blend_state *blend;
  572.         struct reloc r;
  573.         const char *dst, *src;
  574.         const char *func;
  575.  
  576.         blend = get_reloc(kgem, state.dynamic_state.ptr, reloc, &r);
  577.  
  578.         dst = gen6_blend_factor_to_string(blend->blend0.dest_blend_factor);
  579.         src = gen6_blend_factor_to_string(blend->blend0.source_blend_factor);
  580.         func = gen6_blend_function_to_string(blend->blend0.blend_func);
  581.  
  582.         ErrorF("  Blend (%s): function %s, src=%s, dst=%s\n",
  583.                blend->blend0.blend_enable ? "enabled" : "disabled",
  584.                func, src, dst);
  585. }
  586.  
  587. int kgem_gen6_decode_3d(struct kgem *kgem, uint32_t offset)
  588. {
  589.         static const struct {
  590.                 uint32_t opcode;
  591.                 int min_len;
  592.                 int max_len;
  593.                 const char *name;
  594.         } opcodes[] = {
  595.                 { 0x6101, 6, 6, "STATE_BASE_ADDRESS" },
  596.                 { 0x6102, 2, 2 , "STATE_SIP" },
  597.                 { 0x6104, 1, 1, "3DSTATE_PIPELINE_SELECT" },
  598.                 { 0x680b, 1, 1, "3DSTATE_VF_STATISTICS" },
  599.                 { 0x6904, 1, 1, "3DSTATE_PIPELINE_SELECT" },
  600.                 { 0x7800, 7, 7, "3DSTATE_PIPELINED_POINTERS" },
  601.                 { 0x7801, 6, 6, "3DSTATE_BINDING_TABLE_POINTERS" },
  602.                 { 0x7808, 5, 257, "3DSTATE_VERTEX_BUFFERS" },
  603.                 { 0x7809, 3, 256, "3DSTATE_VERTEX_ELEMENTS" },
  604.                 { 0x780a, 3, 3, "3DSTATE_INDEX_BUFFER" },
  605.                 { 0x780b, 1, 1, "3DSTATE_VF_STATISTICS" },
  606.                 { 0x7900, 4, 4, "3DSTATE_DRAWING_RECTANGLE" },
  607.                 { 0x7901, 5, 5, "3DSTATE_CONSTANT_COLOR" },
  608.                 { 0x7905, 5, 7, "3DSTATE_DEPTH_BUFFER" },
  609.                 { 0x7906, 2, 2, "3DSTATE_POLY_STIPPLE_OFFSET" },
  610.                 { 0x7907, 33, 33, "3DSTATE_POLY_STIPPLE_PATTERN" },
  611.                 { 0x7908, 3, 3, "3DSTATE_LINE_STIPPLE" },
  612.                 { 0x7909, 2, 2, "3DSTATE_GLOBAL_DEPTH_OFFSET_CLAMP" },
  613.                 { 0x7909, 2, 2, "3DSTATE_CLEAR_PARAMS" },
  614.                 { 0x790a, 3, 3, "3DSTATE_AA_LINE_PARAMETERS" },
  615.                 { 0x790b, 4, 4, "3DSTATE_GS_SVB_INDEX" },
  616.                 { 0x790d, 3, 3, "3DSTATE_MULTISAMPLE" },
  617.                 { 0x7910, 2, 2, "3DSTATE_CLEAR_PARAMS" },
  618.                 { 0x7b00, 6, 6, "3DPRIMITIVE" },
  619.                 { 0x7802, 4, 4, "3DSTATE_SAMPLER_STATE_POINTERS" },
  620.                 { 0x7805, 3, 3, "3DSTATE_URB" },
  621.                 { 0x780d, 4, 4, "3DSTATE_VIEWPORT_STATE_POINTERS" },
  622.                 { 0x780e, 4, 4, "3DSTATE_CC_STATE_POINTERS" },
  623.                 { 0x780f, 2, 2, "3DSTATE_SCISSOR_STATE_POINTERS" },
  624.                 { 0x7810, 6, 6, "3DSTATE_VS_STATE" },
  625.                 { 0x7811, 7, 7, "3DSTATE_GS_STATE" },
  626.                 { 0x7812, 4, 4, "3DSTATE_CLIP_STATE" },
  627.                 { 0x7813, 20, 20, "3DSTATE_SF_STATE" },
  628.                 { 0x7814, 9, 9, "3DSTATE_WM_STATE" },
  629.                 { 0x7815, 5, 5, "3DSTATE_CONSTANT_VS_STATE" },
  630.                 { 0x7816, 5, 5, "3DSTATE_CONSTANT_GS_STATE" },
  631.                 { 0x7817, 5, 5, "3DSTATE_CONSTANT_WM_STATE" },
  632.                 { 0x7818, 2, 2, "3DSTATE_SAMPLE_MASK" },
  633.         };
  634.         uint32_t *data = kgem->batch + offset;
  635.         uint32_t op;
  636.         unsigned int len;
  637.         int i, j;
  638.         const char *desc1 = NULL;
  639.  
  640.         len = (data[0] & 0xff) + 2;
  641.         op = (data[0] & 0xffff0000) >> 16;
  642.         switch (op) {
  643.         case 0x6101:
  644.                 i = 0;
  645.                 kgem_debug_print(data, offset, i++, "STATE_BASE_ADDRESS\n");
  646.                 if (kgem->gen >= 060) {
  647.                         assert(len == 10);
  648.  
  649.                         state_base_out(data, offset, i++, "general");
  650.                         state_base_out(data, offset, i++, "surface");
  651.                         state_base_out(data, offset, i++, "dynamic");
  652.                         state_base_out(data, offset, i++, "indirect");
  653.                         state_base_out(data, offset, i++, "instruction");
  654.  
  655.                         state_max_out(data, offset, i++, "general");
  656.                         state_max_out(data, offset, i++, "dynamic");
  657.                         state_max_out(data, offset, i++, "indirect");
  658.                         state_max_out(data, offset, i++, "instruction");
  659.  
  660.                         gen6_update_dynamic_buffer(kgem, offset + 3);
  661.                 } else if (kgem->gen >= 050) {
  662.                         assert(len == 8);
  663.  
  664.                         state_base_out(data, offset, i++, "general");
  665.                         state_base_out(data, offset, i++, "surface");
  666.                         state_base_out(data, offset, i++, "media");
  667.                         state_base_out(data, offset, i++, "instruction");
  668.  
  669.                         state_max_out(data, offset, i++, "general");
  670.                         state_max_out(data, offset, i++, "media");
  671.                         state_max_out(data, offset, i++, "instruction");
  672.                 }
  673.  
  674.                 return len;
  675.  
  676.         case 0x7801:
  677.                 if (kgem->gen >= 060) {
  678.                         assert(len == 4);
  679.  
  680.                         kgem_debug_print(data, offset, 0,
  681.                                   "3DSTATE_BINDING_TABLE_POINTERS: VS mod %d, "
  682.                                   "GS mod %d, WM mod %d\n",
  683.                                   (data[0] & (1 << 8)) != 0,
  684.                                   (data[0] & (1 << 9)) != 0,
  685.                                   (data[0] & (1 << 12)) != 0);
  686.                         kgem_debug_print(data, offset, 1, "VS binding table\n");
  687.                         kgem_debug_print(data, offset, 2, "GS binding table\n");
  688.                         kgem_debug_print(data, offset, 3, "WM binding table\n");
  689.                 } else if (kgem->gen >= 040) {
  690.                         assert(len == 6);
  691.  
  692.                         kgem_debug_print(data, offset, 0,
  693.                                   "3DSTATE_BINDING_TABLE_POINTERS\n");
  694.                         kgem_debug_print(data, offset, 1, "VS binding table\n");
  695.                         kgem_debug_print(data, offset, 2, "GS binding table\n");
  696.                         kgem_debug_print(data, offset, 3, "CLIP binding table\n");
  697.                         kgem_debug_print(data, offset, 4, "SF binding table\n");
  698.                         kgem_debug_print(data, offset, 5, "WM binding table\n");
  699.                 }
  700.  
  701.                 return len;
  702.  
  703.         case 0x7802:
  704.                 assert(len == 4);
  705.                 kgem_debug_print(data, offset, 0, "3DSTATE_SAMPLER_STATE_POINTERS: VS mod %d, "
  706.                           "GS mod %d, WM mod %d\n",
  707.                           (data[0] & (1 << 8)) != 0,
  708.                           (data[0] & (1 << 9)) != 0,
  709.                           (data[0] & (1 << 12)) != 0);
  710.                 kgem_debug_print(data, offset, 1, "VS sampler state\n");
  711.                 kgem_debug_print(data, offset, 2, "GS sampler state\n");
  712.                 kgem_debug_print(data, offset, 3, "WM sampler state\n");
  713.                 gen6_decode_sampler_state(kgem, &data[3]);
  714.                 return len;
  715.  
  716.         case 0x7808:
  717.                 assert((len - 1) % 4 == 0);
  718.                 kgem_debug_print(data, offset, 0, "3DSTATE_VERTEX_BUFFERS\n");
  719.  
  720.                 for (i = 1; i < len;) {
  721.                         gen6_update_vertex_buffer(kgem, data + i);
  722.  
  723.                         kgem_debug_print(data, offset, i, "buffer %d: %s, pitch %db\n",
  724.                                   data[i] >> 26,
  725.                                   data[i] & (1 << 20) ? "random" : "sequential",
  726.                                   data[i] & 0x07ff);
  727.                         i++;
  728.                         kgem_debug_print(data, offset, i++, "buffer address\n");
  729.                         kgem_debug_print(data, offset, i++, "max index\n");
  730.                         kgem_debug_print(data, offset, i++, "mbz\n");
  731.                 }
  732.                 return len;
  733.  
  734.         case 0x7809:
  735.                 assert((len + 1) % 2 == 0);
  736.                 kgem_debug_print(data, offset, 0, "3DSTATE_VERTEX_ELEMENTS\n");
  737.  
  738.                 for (i = 1; i < len;) {
  739.                         gen6_update_vertex_elements(kgem, (i - 1)/2, data + i);
  740.  
  741.                         kgem_debug_print(data, offset, i, "buffer %d: %svalid, type 0x%04x, "
  742.                                   "src offset 0x%04x bytes\n",
  743.                                   data[i] >> 26,
  744.                                   data[i] & (1 << 25) ? "" : "in",
  745.                                   (data[i] >> 16) & 0x1ff,
  746.                                   data[i] & 0x07ff);
  747.                         i++;
  748.                         kgem_debug_print(data, offset, i, "(%s, %s, %s, %s), "
  749.                                   "dst offset 0x%02x bytes\n",
  750.                                   get_965_element_component(data[i], 0),
  751.                                   get_965_element_component(data[i], 1),
  752.                                   get_965_element_component(data[i], 2),
  753.                                   get_965_element_component(data[i], 3),
  754.                                   (data[i] & 0xff) * 4);
  755.                         i++;
  756.                 }
  757.                 return len;
  758.  
  759.         case 0x780d:
  760.                 assert(len == 4);
  761.                 kgem_debug_print(data, offset, 0, "3DSTATE_VIEWPORT_STATE_POINTERS\n");
  762.                 kgem_debug_print(data, offset, 1, "clip\n");
  763.                 kgem_debug_print(data, offset, 2, "sf\n");
  764.                 kgem_debug_print(data, offset, 3, "cc\n");
  765.                 return len;
  766.  
  767.         case 0x780a:
  768.                 assert(len == 3);
  769.                 kgem_debug_print(data, offset, 0, "3DSTATE_INDEX_BUFFER\n");
  770.                 kgem_debug_print(data, offset, 1, "beginning buffer address\n");
  771.                 kgem_debug_print(data, offset, 2, "ending buffer address\n");
  772.                 return len;
  773.  
  774.         case 0x780e:
  775.                 assert(len == 4);
  776.                 kgem_debug_print(data, offset, 0, "3DSTATE_CC_STATE_POINTERS\n");
  777.                 kgem_debug_print(data, offset, 1, "blend%s\n",
  778.                                  data[1] & 1 ? " update" : "");
  779.                 if (data[1] & 1)
  780.                         gen6_decode_blend(kgem, data+1);
  781.                 kgem_debug_print(data, offset, 2, "depth+stencil%s\n",
  782.                                  data[2] & 1 ? " update" : "");
  783.                 kgem_debug_print(data, offset, 3, "cc%s\n",
  784.                                  data[3] & 1 ? " update" : "");
  785.                 return len;
  786.  
  787.         case 0x780f:
  788.                 assert(len == 2);
  789.                 kgem_debug_print(data, offset, 0, "3DSTATE_SCISSOR_POINTERS\n");
  790.                 kgem_debug_print(data, offset, 1, "scissor rect offset\n");
  791.                 return len;
  792.  
  793.         case 0x7810:
  794.                 assert(len == 6);
  795.                 kgem_debug_print(data, offset, 0, "3DSTATE_VS\n");
  796.                 kgem_debug_print(data, offset, 1, "kernel pointer\n");
  797.                 kgem_debug_print(data, offset, 2, "SPF=%d, VME=%d, Sampler Count %d, "
  798.                           "Binding table count %d\n",
  799.                           (data[2] >> 31) & 1,
  800.                           (data[2] >> 30) & 1,
  801.                           (data[2] >> 27) & 7,
  802.                           (data[2] >> 18) & 0xff);
  803.                 kgem_debug_print(data, offset, 3, "scratch offset\n");
  804.                 kgem_debug_print(data, offset, 4, "Dispatch GRF start %d, VUE read length %d, "
  805.                           "VUE read offset %d\n",
  806.                           (data[4] >> 20) & 0x1f,
  807.                           (data[4] >> 11) & 0x3f,
  808.                           (data[4] >> 4) & 0x3f);
  809.                 kgem_debug_print(data, offset, 5, "Max Threads %d, Vertex Cache %sable, "
  810.                           "VS func %sable\n",
  811.                           ((data[5] >> 25) & 0x7f) + 1,
  812.                           (data[5] & (1 << 1)) != 0 ? "dis" : "en",
  813.                           (data[5] & 1) != 0 ? "en" : "dis");
  814.                 return len;
  815.  
  816.         case 0x7811:
  817.                 assert(len == 7);
  818.                 kgem_debug_print(data, offset, 0, "3DSTATE_GS\n");
  819.                 kgem_debug_print(data, offset, 1, "kernel pointer\n");
  820.                 kgem_debug_print(data, offset, 2, "SPF=%d, VME=%d, Sampler Count %d, "
  821.                           "Binding table count %d\n",
  822.                           (data[2] >> 31) & 1,
  823.                           (data[2] >> 30) & 1,
  824.                           (data[2] >> 27) & 7,
  825.                           (data[2] >> 18) & 0xff);
  826.                 kgem_debug_print(data, offset, 3, "scratch offset\n");
  827.                 kgem_debug_print(data, offset, 4, "Dispatch GRF start %d, VUE read length %d, "
  828.                           "VUE read offset %d\n",
  829.                           (data[4] & 0xf),
  830.                           (data[4] >> 11) & 0x3f,
  831.                           (data[4] >> 4) & 0x3f);
  832.                 kgem_debug_print(data, offset, 5, "Max Threads %d, Rendering %sable\n",
  833.                           ((data[5] >> 25) & 0x7f) + 1,
  834.                           (data[5] & (1 << 8)) != 0 ? "en" : "dis");
  835.                 kgem_debug_print(data, offset, 6, "Reorder %sable, Discard Adjaceny %sable, "
  836.                           "GS %sable\n",
  837.                           (data[6] & (1 << 30)) != 0 ? "en" : "dis",
  838.                           (data[6] & (1 << 29)) != 0 ? "en" : "dis",
  839.                           (data[6] & (1 << 15)) != 0 ? "en" : "dis");
  840.                 return len;
  841.  
  842.         case 0x7812:
  843.                 assert(len == 4);
  844.                 kgem_debug_print(data, offset, 0, "3DSTATE_CLIP\n");
  845.                 kgem_debug_print(data, offset, 1, "UserClip distance cull test mask 0x%x\n",
  846.                           data[1] & 0xff);
  847.                 kgem_debug_print(data, offset, 2, "Clip %sable, API mode %s, Viewport XY test %sable, "
  848.                           "Viewport Z test %sable, Guardband test %sable, Clip mode %d, "
  849.                           "Perspective Divide %sable, Non-Perspective Barycentric %sable, "
  850.                           "Tri Provoking %d, Line Provoking %d, Trifan Provoking %d\n",
  851.                           (data[2] & (1 << 31)) != 0 ? "en" : "dis",
  852.                           (data[2] & (1 << 30)) != 0 ? "D3D" : "OGL",
  853.                           (data[2] & (1 << 28)) != 0 ? "en" : "dis",
  854.                           (data[2] & (1 << 27)) != 0 ? "en" : "dis",
  855.                           (data[2] & (1 << 26)) != 0 ? "en" : "dis",
  856.                           (data[2] >> 13) & 7,
  857.                           (data[2] & (1 << 9)) != 0 ? "dis" : "en",
  858.                           (data[2] & (1 << 8)) != 0 ? "en" : "dis",
  859.                           (data[2] >> 4) & 3,
  860.                           (data[2] >> 2) & 3,
  861.                           (data[2] & 3));
  862.                 kgem_debug_print(data, offset, 3, "Min PointWidth %d, Max PointWidth %d, "
  863.                           "Force Zero RTAIndex %sable, Max VPIndex %d\n",
  864.                           (data[3] >> 17) & 0x7ff,
  865.                           (data[3] >> 6) & 0x7ff,
  866.                           (data[3] & (1 << 5)) != 0 ? "en" : "dis",
  867.                           (data[3] & 0xf));
  868.                 return len;
  869.  
  870.         case 0x7813:
  871.                 gen6_update_sf_state(kgem, data);
  872.                 assert(len == 20);
  873.                 kgem_debug_print(data, offset, 0, "3DSTATE_SF\n");
  874.                 kgem_debug_print(data, offset, 1, "Attrib Out %d, Attrib Swizzle %sable, VUE read length %d, "
  875.                           "VUE read offset %d\n",
  876.                           (data[1] >> 22) & 0x3f,
  877.                           (data[1] & (1 << 21)) != 0 ? "en" : "dis",
  878.                           (data[1] >> 11) & 0x1f,
  879.                           (data[1] >> 4) & 0x3f);
  880.                 kgem_debug_print(data, offset, 2, "Legacy Global DepthBias %sable, FrontFace fill %d, BF fill %d, "
  881.                           "VP transform %sable, FrontWinding_%s\n",
  882.                           (data[2] & (1 << 11)) != 0 ? "en" : "dis",
  883.                           (data[2] >> 5) & 3,
  884.                           (data[2] >> 3) & 3,
  885.                           (data[2] & (1 << 1)) != 0 ? "en" : "dis",
  886.                           (data[2] & 1) != 0 ? "CCW" : "CW");
  887.                 kgem_debug_print(data, offset, 3, "AA %sable, CullMode %d, Scissor %sable, Multisample m ode %d\n",
  888.                           (data[3] & (1 << 31)) != 0 ? "en" : "dis",
  889.                           (data[3] >> 29) & 3,
  890.                           (data[3] & (1 << 11)) != 0 ? "en" : "dis",
  891.                           (data[3] >> 8) & 3);
  892.                 kgem_debug_print(data, offset, 4, "Last Pixel %sable, SubPixel Precision %d, Use PixelWidth %d\n",
  893.                           (data[4] & (1 << 31)) != 0 ? "en" : "dis",
  894.                           (data[4] & (1 << 12)) != 0 ? 4 : 8,
  895.                           (data[4] & (1 << 11)) != 0);
  896.                 kgem_debug_print(data, offset, 5, "Global Depth Offset Constant %f\n", unpack_float(data[5]));
  897.                 kgem_debug_print(data, offset, 6, "Global Depth Offset Scale %f\n", unpack_float(data[6]));
  898.                 kgem_debug_print(data, offset, 7, "Global Depth Offset Clamp %f\n", unpack_float(data[7]));
  899.                 for (i = 0, j = 0; i < 8; i++, j+=2)
  900.                         kgem_debug_print(data, offset, i+8, "Attrib %d (Override %s%s%s%s, Const Source %d, Swizzle Select %d, "
  901.                                   "Source %d); Attrib %d (Override %s%s%s%s, Const Source %d, Swizzle Select %d, Source %d)\n",
  902.                                   j+1,
  903.                                   (data[8+i] & (1 << 31)) != 0 ? "W":"",
  904.                                   (data[8+i] & (1 << 30)) != 0 ? "Z":"",
  905.                                   (data[8+i] & (1 << 29)) != 0 ? "Y":"",
  906.                                   (data[8+i] & (1 << 28)) != 0 ? "X":"",
  907.                                   (data[8+i] >> 25) & 3, (data[8+i] >> 22) & 3,
  908.                                   (data[8+i] >> 16) & 0x1f,
  909.                                   j,
  910.                                   (data[8+i] & (1 << 15)) != 0 ? "W":"",
  911.                                   (data[8+i] & (1 << 14)) != 0 ? "Z":"",
  912.                                   (data[8+i] & (1 << 13)) != 0 ? "Y":"",
  913.                                   (data[8+i] & (1 << 12)) != 0 ? "X":"",
  914.                                   (data[8+i] >> 9) & 3, (data[8+i] >> 6) & 3,
  915.                                   (data[8+i] & 0x1f));
  916.                 kgem_debug_print(data, offset, 16, "Point Sprite TexCoord Enable\n");
  917.                 kgem_debug_print(data, offset, 17, "Const Interp Enable\n");
  918.                 kgem_debug_print(data, offset, 18, "Attrib 7-0 WrapShortest Enable\n");
  919.                 kgem_debug_print(data, offset, 19, "Attrib 15-8 WrapShortest Enable\n");
  920.  
  921.                 return len;
  922.  
  923.         case 0x7814:
  924.                 assert(len == 9);
  925.                 kgem_debug_print(data, offset, 0, "3DSTATE_WM\n");
  926.                 kgem_debug_print(data, offset, 1, "kernel start pointer 0\n");
  927.                 kgem_debug_print(data, offset, 2, "SPF=%d, VME=%d, Sampler Count %d, "
  928.                           "Binding table count %d\n",
  929.                           (data[2] >> 31) & 1,
  930.                           (data[2] >> 30) & 1,
  931.                           (data[2] >> 27) & 7,
  932.                           (data[2] >> 18) & 0xff);
  933.                 kgem_debug_print(data, offset, 3, "scratch offset\n");
  934.                 kgem_debug_print(data, offset, 4, "Depth Clear %d, Depth Resolve %d, HiZ Resolve %d, "
  935.                           "Dispatch GRF start[0] %d, start[1] %d, start[2] %d\n",
  936.                           (data[4] & (1 << 30)) != 0,
  937.                           (data[4] & (1 << 28)) != 0,
  938.                           (data[4] & (1 << 27)) != 0,
  939.                           (data[4] >> 16) & 0x7f,
  940.                           (data[4] >> 8) & 0x7f,
  941.                           (data[4] & 0x7f));
  942.                 kgem_debug_print(data, offset, 5, "MaxThreads %d, PS KillPixel %d, PS computed Z %d, "
  943.                           "PS use sourceZ %d, Thread Dispatch %d, PS use sourceW %d, Dispatch32 %d, "
  944.                           "Dispatch16 %d, Dispatch8 %d\n",
  945.                           ((data[5] >> 25) & 0x7f) + 1,
  946.                           (data[5] & (1 << 22)) != 0,
  947.                           (data[5] & (1 << 21)) != 0,
  948.                           (data[5] & (1 << 20)) != 0,
  949.                           (data[5] & (1 << 19)) != 0,
  950.                           (data[5] & (1 << 8)) != 0,
  951.                           (data[5] & (1 << 2)) != 0,
  952.                           (data[5] & (1 << 1)) != 0,
  953.                           (data[5] & (1 << 0)) != 0);
  954.                 kgem_debug_print(data, offset, 6, "Num SF output %d, Pos XY offset %d, ZW interp mode %d , "
  955.                           "Barycentric interp mode 0x%x, Point raster rule %d, Multisample mode %d, "
  956.                           "Multisample Dispatch mode %d\n",
  957.                           (data[6] >> 20) & 0x3f,
  958.                           (data[6] >> 18) & 3,
  959.                           (data[6] >> 16) & 3,
  960.                           (data[6] >> 10) & 0x3f,
  961.                           (data[6] & (1 << 9)) != 0,
  962.                           (data[6] >> 1) & 3,
  963.                           (data[6] & 1));
  964.                 kgem_debug_print(data, offset, 7, "kernel start pointer 1\n");
  965.                 kgem_debug_print(data, offset, 8, "kernel start pointer 2\n");
  966.  
  967.                 return len;
  968.  
  969.         case 0x7900:
  970.                 assert(len == 4);
  971.                 kgem_debug_print(data, offset, 0,
  972.                                  "3DSTATE_DRAWING_RECTANGLE\n");
  973.                 kgem_debug_print(data, offset, 1, "top left: %d, %d\n",
  974.                                  (uint16_t)(data[1] & 0xffff),
  975.                                  (uint16_t)(data[1] >> 16));
  976.                 kgem_debug_print(data, offset, 2, "bottom right: %d, %d\n",
  977.                                  (uint16_t)(data[2] & 0xffff),
  978.                                  (uint16_t)(data[2] >> 16));
  979.                 kgem_debug_print(data, offset, 3, "origin: %d, %d\n",
  980.                                  (int16_t)(data[3] & 0xffff),
  981.                                  (int16_t)(data[3] >> 16));
  982.                 return len;
  983.  
  984.         case 0x7905:
  985.                 assert(len == 7);
  986.                 kgem_debug_print(data, offset, 0,
  987.                           "3DSTATE_DEPTH_BUFFER\n");
  988.                 kgem_debug_print(data, offset, 1, "%s, %s, pitch = %d bytes, %stiled, HiZ %d, Seperate Stencil %d\n",
  989.                           get_965_surfacetype(data[1] >> 29),
  990.                           get_965_depthformat((data[1] >> 18) & 0x7),
  991.                           (data[1] & 0x0001ffff) + 1,
  992.                           data[1] & (1 << 27) ? "" : "not ",
  993.                           (data[1] & (1 << 22)) != 0,
  994.                           (data[1] & (1 << 21)) != 0);
  995.                 kgem_debug_print(data, offset, 2, "depth offset\n");
  996.                 kgem_debug_print(data, offset, 3, "%dx%d\n",
  997.                           ((data[3] & 0x0007ffc0) >> 6) + 1,
  998.                           ((data[3] & 0xfff80000) >> 19) + 1);
  999.                 kgem_debug_print(data, offset, 4, "volume depth\n");
  1000.                 kgem_debug_print(data, offset, 5, "\n");
  1001.                 kgem_debug_print(data, offset, 6, "\n");
  1002.                 return len;
  1003.  
  1004.         case 0x7a00:
  1005.                 assert(len == 4 || len == 5);
  1006.                 switch ((data[1] >> 14) & 0x3) {
  1007.                 case 0: desc1 = "no write"; break;
  1008.                 case 1: desc1 = "qword write"; break;
  1009.                 case 2: desc1 = "PS_DEPTH_COUNT write"; break;
  1010.                 case 3: desc1 = "TIMESTAMP write"; break;
  1011.                 }
  1012.                 kgem_debug_print(data, offset, 0, "PIPE_CONTROL\n");
  1013.                 kgem_debug_print(data, offset, 1,
  1014.                           "%s, %scs stall, %stlb invalidate, "
  1015.                           "%ssync gfdt, %sdepth stall, %sRC write flush, "
  1016.                           "%sinst flush, %sTC flush\n",
  1017.                           desc1,
  1018.                           data[1] & (1 << 20) ? "" : "no ",
  1019.                           data[1] & (1 << 18) ? "" : "no ",
  1020.                           data[1] & (1 << 17) ? "" : "no ",
  1021.                           data[1] & (1 << 13) ? "" : "no ",
  1022.                           data[1] & (1 << 12) ? "" : "no ",
  1023.                           data[1] & (1 << 11) ? "" : "no ",
  1024.                           data[1] & (1 << 10) ? "" : "no ");
  1025.                 if (len == 5) {
  1026.                         kgem_debug_print(data, offset, 2, "destination address\n");
  1027.                         kgem_debug_print(data, offset, 3, "immediate dword low\n");
  1028.                         kgem_debug_print(data, offset, 4, "immediate dword high\n");
  1029.                 } else {
  1030.                         for (i = 2; i < len; i++) {
  1031.                                 kgem_debug_print(data, offset, i, "\n");
  1032.                         }
  1033.                 }
  1034.                 return len;
  1035.  
  1036.         case 0x7b00:
  1037.                 assert(len == 6);
  1038.                 kgem_debug_print(data, offset, 0,
  1039.                           "3DPRIMITIVE: %s %s\n",
  1040.                           get_965_prim_type(data[0]),
  1041.                           (data[0] & (1 << 15)) ? "random" : "sequential");
  1042.                 kgem_debug_print(data, offset, 1, "vertex count\n");
  1043.                 kgem_debug_print(data, offset, 2, "start vertex\n");
  1044.                 kgem_debug_print(data, offset, 3, "instance count\n");
  1045.                 kgem_debug_print(data, offset, 4, "start instance\n");
  1046.                 kgem_debug_print(data, offset, 5, "index bias\n");
  1047.                 primitive_out(kgem, data);
  1048.                 return len;
  1049.         }
  1050.  
  1051.         /* For the rest, just dump the bytes */
  1052.         for (i = 0; i < ARRAY_SIZE(opcodes); i++)
  1053.                 if (op == opcodes[i].opcode)
  1054.                         break;
  1055.  
  1056.         assert(i < ARRAY_SIZE(opcodes));
  1057.  
  1058.         len = 1;
  1059.         kgem_debug_print(data, offset, 0, "%s\n", opcodes[i].name);
  1060.         if (opcodes[i].max_len > 1) {
  1061.                 len = (data[0] & 0xff) + 2;
  1062.                 assert(len >= opcodes[i].min_len &&
  1063.                        len <= opcodes[i].max_len);
  1064.         }
  1065.  
  1066.         for (i = 1; i < len; i++)
  1067.                 kgem_debug_print(data, offset, i, "dword %d\n", i);
  1068.  
  1069.         return len;
  1070. }
  1071.  
  1072. void kgem_gen6_finish_state(struct kgem *kgem)
  1073. {
  1074.         finish_state(kgem);
  1075. }
  1076.