Subversion Repositories Kolibri OS

Rev

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