Subversion Repositories Kolibri OS

Rev

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