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