src/gallium/drivers/i965/intel_decode.c

   1 /* -*- c-basic-offset: 4 -*- */
   2 /*
   3  * Copyright © 2007 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  22  * IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Eric Anholt <eric@anholt.net>
  26  *
  27  */
  28
  29 /** @file intel_decode.c
  30  * This file contains code to print out batchbuffer contents in a
  31  * human-readable format.
  32  *
  33  * The current version only supports i915 packets, and only pretty-prints a
  34  * subset of them.  The intention is for it to make just a best attempt to
  35  * decode, but never crash in the process.
  36  */
  37
  38 #include <stdio.h>
  39 #include <stdarg.h>
  40 #include <stdint.h>
  41 #include <string.h>
  42
  43 #include "util/u_memory.h"
  44 #include "util/u_string.h"
  45
  46 #include "intel_decode.h"
  47 #include "brw_reg.h"
  48
  49 /*#include "intel_chipset.h"*/
  50 #define IS_9XX(x) 1             /* XXX */
  51
  52 #define BUFFER_FAIL(_count, _len, _name) do {                   \
  53     fprintf(out, "Buffer size too small in %s (%d < %d)\n",     \
  54             (_name), (_count), (_len));                         \
  55     (*failures)++;                                              \
  56     return count;                                               \
  57 } while (0)
  58
  59 static FILE *out;
  60 static uint32_t saved_s2 = 0, saved_s4 = 0;
  61 static char saved_s2_set = 0, saved_s4_set = 0;
  62
  63 static float
  64 int_as_float(uint32_t intval)
  65 {
  66     union intfloat {
  67         uint32_t i;
  68         float f;
  69     } uval;
  70
  71     uval.i = intval;
  72     return uval.f;
  73 }
  74
  75 static void
  76 instr_out(const uint32_t *data, uint32_t hw_offset, unsigned int index,
  77           char *fmt, ...)
  78 {
  79     va_list va;
  80
  81     fprintf(out, "0x%08x: 0x%08x:%s ", hw_offset + index * 4, data[index],
  82             index == 0 ? "" : "  ");
  83     va_start(va, fmt);
  84     vfprintf(out, fmt, va);
  85     va_end(va);
  86 }
  87
  88
  89 static int
  90 decode_mi(const uint32_t *data, int count, uint32_t hw_offset, int *failures)
  91 {
  92     unsigned int opcode;
  93
  94     struct {
  95         uint32_t opcode;
  96         int len_mask;
  97         int min_len;
  98         int max_len;
  99         char *name;
 100     } opcodes_mi[] = {
 101         { 0x08, 0, 1, 1, "MI_ARB_ON_OFF" },
 102         { 0x0a, 0, 1, 1, "MI_BATCH_BUFFER_END" },
 103         { 0x30, 0x3f, 3, 3, "MI_BATCH_BUFFER" },
 104         { 0x31, 0x3f, 2, 2, "MI_BATCH_BUFFER_START" },
 105         { 0x14, 0x3f, 3, 3, "MI_DISPLAY_BUFFER_INFO" },
 106         { 0x04, 0, 1, 1, "MI_FLUSH" },
 107         { 0x22, 0x1f, 3, 3, "MI_LOAD_REGISTER_IMM" },
 108         { 0x13, 0x3f, 2, 2, "MI_LOAD_SCAN_LINES_EXCL" },
 109         { 0x12, 0x3f, 2, 2, "MI_LOAD_SCAN_LINES_INCL" },
 110         { 0x00, 0, 1, 1, "MI_NOOP" },
 111         { 0x11, 0x3f, 2, 2, "MI_OVERLAY_FLIP" },
 112         { 0x07, 0, 1, 1, "MI_REPORT_HEAD" },
 113         { 0x18, 0x3f, 2, 2, "MI_SET_CONTEXT" },
 114         { 0x20, 0x3f, 3, 4, "MI_STORE_DATA_IMM" },
 115         { 0x21, 0x3f, 3, 4, "MI_STORE_DATA_INDEX" },
 116         { 0x24, 0x3f, 3, 3, "MI_STORE_REGISTER_MEM" },
 117         { 0x02, 0, 1, 1, "MI_USER_INTERRUPT" },
 118         { 0x03, 0, 1, 1, "MI_WAIT_FOR_EVENT" },
 119     };
 120
 121     switch ((data[0] & 0x1f800000) >> 23) {
 122     case 0x0a:
 123         instr_out(data, hw_offset, 0, "MI_BATCH_BUFFER_END\n");
 124         return -1;
 125     }
 126
 127     for (opcode = 0; opcode < Elements(opcodes_mi); opcode++) {
 128         if ((data[0] & 0x1f800000) >> 23 == opcodes_mi[opcode].opcode) {
 129             unsigned int len = 1, i;
 130
 131             instr_out(data, hw_offset, 0, "%s\n", opcodes_mi[opcode].name);
 132             if (opcodes_mi[opcode].max_len > 1) {
 133                 len = (data[0] & opcodes_mi[opcode].len_mask) + 2;
 134                 if (len < opcodes_mi[opcode].min_len ||
 135                     len > opcodes_mi[opcode].max_len)
 136                 {
 137                     fprintf(out, "Bad length (%d) in %s, [%d, %d]\n",
 138                             len, opcodes_mi[opcode].name,
 139                             opcodes_mi[opcode].min_len,
 140                             opcodes_mi[opcode].max_len);
 141                 }
 142             }
 143
 144             for (i = 1; i < len; i++) {
 145                 if (i >= count)
 146                     BUFFER_FAIL(count, len, opcodes_mi[opcode].name);
 147                 instr_out(data, hw_offset, i, "dword %d\n", i);
 148             }
 149
 150             return len;
 151         }
 152     }
 153
 154     instr_out(data, hw_offset, 0, "MI UNKNOWN\n");
 155     (*failures)++;
 156     return 1;
 157 }
 158
 159 static int
 160 decode_2d(const uint32_t *data, int count, uint32_t hw_offset, int *failures)
 161 {
 162     unsigned int opcode, len;
 163     char *format = NULL;
 164
 165     struct {
 166         uint32_t opcode;
 167         int min_len;
 168         int max_len;
 169         char *name;
 170     } opcodes_2d[] = {
 171         { 0x40, 5, 5, "COLOR_BLT" },
 172         { 0x43, 6, 6, "SRC_COPY_BLT" },
 173         { 0x01, 8, 8, "XY_SETUP_BLT" },
 174         { 0x11, 9, 9, "XY_SETUP_MONO_PATTERN_SL_BLT" },
 175         { 0x03, 3, 3, "XY_SETUP_CLIP_BLT" },
 176         { 0x24, 2, 2, "XY_PIXEL_BLT" },
 177         { 0x25, 3, 3, "XY_SCANLINES_BLT" },
 178         { 0x26, 4, 4, "Y_TEXT_BLT" },
 179         { 0x31, 5, 134, "XY_TEXT_IMMEDIATE_BLT" },
 180         { 0x50, 6, 6, "XY_COLOR_BLT" },
 181         { 0x51, 6, 6, "XY_PAT_BLT" },
 182         { 0x76, 8, 8, "XY_PAT_CHROMA_BLT" },
 183         { 0x72, 7, 135, "XY_PAT_BLT_IMMEDIATE" },
 184         { 0x77, 9, 137, "XY_PAT_CHROMA_BLT_IMMEDIATE" },
 185         { 0x52, 9, 9, "XY_MONO_PAT_BLT" },
 186         { 0x59, 7, 7, "XY_MONO_PAT_FIXED_BLT" },
 187         { 0x53, 8, 8, "XY_SRC_COPY_BLT" },
 188         { 0x54, 8, 8, "XY_MONO_SRC_COPY_BLT" },
 189         { 0x71, 9, 137, "XY_MONO_SRC_COPY_IMMEDIATE_BLT" },
 190         { 0x55, 9, 9, "XY_FULL_BLT" },
 191         { 0x55, 9, 137, "XY_FULL_IMMEDIATE_PATTERN_BLT" },
 192         { 0x56, 9, 9, "XY_FULL_MONO_SRC_BLT" },
 193         { 0x75, 10, 138, "XY_FULL_MONO_SRC_IMMEDIATE_PATTERN_BLT" },
 194         { 0x57, 12, 12, "XY_FULL_MONO_PATTERN_BLT" },
 195         { 0x58, 12, 12, "XY_FULL_MONO_PATTERN_MONO_SRC_BLT" },
 196     };
 197
 198     switch ((data[0] & 0x1fc00000) >> 22) {
 199     case 0x50:
 200         instr_out(data, hw_offset, 0,
 201                   "XY_COLOR_BLT (rgb %sabled, alpha %sabled, dst tile %d)\n",
 202                   (data[0] & (1 << 20)) ? "en" : "dis",
 203                   (data[0] & (1 << 21)) ? "en" : "dis",
 204                   (data[0] >> 11) & 1);
 205
 206         len = (data[0] & 0x000000ff) + 2;
 207         if (len != 6)
 208             fprintf(out, "Bad count in XY_COLOR_BLT\n");
 209         if (count < 6)
 210             BUFFER_FAIL(count, len, "XY_COLOR_BLT");
 211
 212         switch ((data[1] >> 24) & 0x3) {
 213         case 0:
 214             format="8";
 215             break;
 216         case 1:
 217             format="565";
 218             break;
 219         case 2:
 220             format="1555";
 221             break;
 222         case 3:
 223             format="8888";
 224             break;
 225         }
 226
 227         instr_out(data, hw_offset, 1, "format %s, pitch %d, "
 228                   "clipping %sabled\n", format,
 229                   (short)(data[1] & 0xffff),
 230                   data[1] & (1 << 30) ? "en" : "dis");
 231         instr_out(data, hw_offset, 2, "(%d,%d)\n",
 232                   data[2] & 0xffff, data[2] >> 16);
 233         instr_out(data, hw_offset, 3, "(%d,%d)\n",
 234                   data[3] & 0xffff, data[3] >> 16);
 235         instr_out(data, hw_offset, 4, "offset 0x%08x\n", data[4]);
 236         instr_out(data, hw_offset, 5, "color\n");
 237         return len;
 238     case 0x53:
 239         instr_out(data, hw_offset, 0,
 240                   "XY_SRC_COPY_BLT (rgb %sabled, alpha %sabled, "
 241                   "src tile %d, dst tile %d)\n",
 242                   (data[0] & (1 << 20)) ? "en" : "dis",
 243                   (data[0] & (1 << 21)) ? "en" : "dis",
 244                   (data[0] >> 15) & 1,
 245                   (data[0] >> 11) & 1);
 246
 247         len = (data[0] & 0x000000ff) + 2;
 248         if (len != 8)
 249             fprintf(out, "Bad count in XY_SRC_COPY_BLT\n");
 250         if (count < 8)
 251             BUFFER_FAIL(count, len, "XY_SRC_COPY_BLT");
 252
 253         switch ((data[1] >> 24) & 0x3) {
 254         case 0:
 255             format="8";
 256             break;
 257         case 1:
 258             format="565";
 259             break;
 260         case 2:
 261             format="1555";
 262             break;
 263         case 3:
 264             format="8888";
 265             break;
 266         }
 267
 268         instr_out(data, hw_offset, 1, "format %s, dst pitch %d, "
 269                   "clipping %sabled\n", format,
 270                   (short)(data[1] & 0xffff),
 271                   data[1] & (1 << 30) ? "en" : "dis");
 272         instr_out(data, hw_offset, 2, "dst (%d,%d)\n",
 273                   data[2] & 0xffff, data[2] >> 16);
 274         instr_out(data, hw_offset, 3, "dst (%d,%d)\n",
 275                   data[3] & 0xffff, data[3] >> 16);
 276         instr_out(data, hw_offset, 4, "dst offset 0x%08x\n", data[4]);
 277         instr_out(data, hw_offset, 5, "src (%d,%d)\n",
 278                   data[5] & 0xffff, data[5] >> 16);
 279         instr_out(data, hw_offset, 6, "src pitch %d\n",
 280                   (short)(data[6] & 0xffff));
 281         instr_out(data, hw_offset, 7, "src offset 0x%08x\n", data[7]);
 282         return len;
 283     }
 284
 285     for (opcode = 0; opcode < Elements(opcodes_2d); opcode++) {
 286         if ((data[0] & 0x1fc00000) >> 22 == opcodes_2d[opcode].opcode) {
 287             unsigned int i;
 288
 289             len = 1;
 290             instr_out(data, hw_offset, 0, "%s\n", opcodes_2d[opcode].name);
 291             if (opcodes_2d[opcode].max_len > 1) {
 292                 len = (data[0] & 0x000000ff) + 2;
 293                 if (len < opcodes_2d[opcode].min_len ||
 294                     len > opcodes_2d[opcode].max_len)
 295                 {
 296                     fprintf(out, "Bad count in %s\n", opcodes_2d[opcode].name);
 297                 }
 298             }
 299
 300             for (i = 1; i < len; i++) {
 301                 if (i >= count)
 302                     BUFFER_FAIL(count, len, opcodes_2d[opcode].name);
 303                 instr_out(data, hw_offset, i, "dword %d\n", i);
 304             }
 305
 306             return len;
 307         }
 308     }
 309
 310     instr_out(data, hw_offset, 0, "2D UNKNOWN\n");
 311     (*failures)++;
 312     return 1;
 313 }
 314
 315 static int
 316 decode_3d_1c(const uint32_t *data, int count, uint32_t hw_offset, int *failures)
 317 {
 318     uint32_t opcode;
 319
 320     opcode = (data[0] & 0x00f80000) >> 19;
 321
 322     switch (opcode) {
 323     case 0x11:
 324         instr_out(data, hw_offset, 0, "3DSTATE_DEPTH_SUBRECTANGLE_DISABLE\n");
 325         return 1;
 326     case 0x10:
 327         instr_out(data, hw_offset, 0, "3DSTATE_SCISSOR_ENABLE\n");
 328         return 1;
 329     case 0x01:
 330         instr_out(data, hw_offset, 0, "3DSTATE_MAP_COORD_SET_I830\n");
 331         return 1;
 332     case 0x0a:
 333         instr_out(data, hw_offset, 0, "3DSTATE_MAP_CUBE_I830\n");
 334         return 1;
 335     case 0x05:
 336         instr_out(data, hw_offset, 0, "3DSTATE_MAP_TEX_STREAM_I830\n");
 337         return 1;
 338     }
 339
 340     instr_out(data, hw_offset, 0, "3D UNKNOWN: 3d_1c opcode = 0x%x\n",
 341               opcode);
 342     (*failures)++;
 343     return 1;
 344 }
 345
 346 /** Sets the string dstname to describe the destination of the PS instruction */
 347 static void
 348 i915_get_instruction_dst(const uint32_t *data, int i, char *dstname, int do_mask)
 349 {
 350     uint32_t a0 = data[i];
 351     int dst_nr = (a0 >> 14) & 0xf;
 352     char dstmask[8];
 353     char *sat;
 354
 355     if (do_mask) {
 356         if (((a0 >> 10) & 0xf) == 0xf) {
 357             dstmask[0] = 0;
 358         } else {
 359             int dstmask_index = 0;
 360
 361             dstmask[dstmask_index++] = '.';
 362             if (a0 & (1 << 10))
 363                 dstmask[dstmask_index++] = 'x';
 364             if (a0 & (1 << 11))
 365                 dstmask[dstmask_index++] = 'y';
 366             if (a0 & (1 << 12))
 367                 dstmask[dstmask_index++] = 'z';
 368             if (a0 & (1 << 13))
 369                 dstmask[dstmask_index++] = 'w';
 370             dstmask[dstmask_index++] = 0;
 371         }
 372
 373         if (a0 & (1 << 22))
 374             sat = ".sat";
 375         else
 376             sat = "";
 377     } else {
 378         dstmask[0] = 0;
 379         sat = "";
 380     }
 381
 382     switch ((a0 >> 19) & 0x7) {
 383     case 0:
 384         if (dst_nr > 15)
 385             fprintf(out, "bad destination reg R%d\n", dst_nr);
 386         sprintf(dstname, "R%d%s%s", dst_nr, dstmask, sat);
 387         break;
 388     case 4:
 389         if (dst_nr > 0)
 390             fprintf(out, "bad destination reg oC%d\n", dst_nr);
 391         sprintf(dstname, "oC%s%s", dstmask, sat);
 392         break;
 393     case 5:
 394         if (dst_nr > 0)
 395             fprintf(out, "bad destination reg oD%d\n", dst_nr);
 396         sprintf(dstname, "oD%s%s",  dstmask, sat);
 397         break;
 398     case 6:
 399         if (dst_nr > 3)
 400             fprintf(out, "bad destination reg U%d\n", dst_nr);
 401         sprintf(dstname, "U%d%s%s", dst_nr, dstmask, sat);
 402         break;
 403     default:
 404         sprintf(dstname, "RESERVED");
 405         break;
 406     }
 407 }
 408
 409 static char *
 410 i915_get_channel_swizzle(uint32_t select)
 411 {
 412     switch (select & 0x7) {
 413     case 0:
 414         return (select & 8) ? "-x" : "x";
 415     case 1:
 416         return (select & 8) ? "-y" : "y";
 417     case 2:
 418         return (select & 8) ? "-z" : "z";
 419     case 3:
 420         return (select & 8) ? "-w" : "w";
 421     case 4:
 422         return (select & 8) ? "-0" : "0";
 423     case 5:
 424         return (select & 8) ? "-1" : "1";
 425     default:
 426         return (select & 8) ? "-bad" : "bad";
 427     }
 428 }
 429
 430 static void
 431 i915_get_instruction_src_name(uint32_t src_type, uint32_t src_nr, char *name)
 432 {
 433     switch (src_type) {
 434     case 0:
 435         sprintf(name, "R%d", src_nr);
 436         if (src_nr > 15)
 437             fprintf(out, "bad src reg %s\n", name);
 438         break;
 439     case 1:
 440         if (src_nr < 8)
 441             sprintf(name, "T%d", src_nr);
 442         else if (src_nr == 8)
 443             sprintf(name, "DIFFUSE");
 444         else if (src_nr == 9)
 445             sprintf(name, "SPECULAR");
 446         else if (src_nr == 10)
 447             sprintf(name, "FOG");
 448         else {
 449             fprintf(out, "bad src reg T%d\n", src_nr);
 450             sprintf(name, "RESERVED");
 451         }
 452         break;
 453     case 2:
 454         sprintf(name, "C%d", src_nr);
 455         if (src_nr > 31)
 456             fprintf(out, "bad src reg %s\n", name);
 457         break;
 458     case 4:
 459         sprintf(name, "oC");
 460         if (src_nr > 0)
 461             fprintf(out, "bad src reg oC%d\n", src_nr);
 462         break;
 463     case 5:
 464         sprintf(name, "oD");
 465         if (src_nr > 0)
 466             fprintf(out, "bad src reg oD%d\n", src_nr);
 467         break;
 468     case 6:
 469         sprintf(name, "U%d", src_nr);
 470         if (src_nr > 3)
 471             fprintf(out, "bad src reg %s\n", name);
 472         break;
 473     default:
 474         fprintf(out, "bad src reg type %d\n", src_type);
 475         sprintf(name, "RESERVED");
 476         break;
 477     }
 478 }
 479
 480 static void
 481 i915_get_instruction_src0(const uint32_t *data, int i, char *srcname)
 482 {
 483     uint32_t a0 = data[i];
 484     uint32_t a1 = data[i + 1];
 485     int src_nr = (a0 >> 2) & 0x1f;
 486     char *swizzle_x = i915_get_channel_swizzle((a1 >> 28) & 0xf);
 487     char *swizzle_y = i915_get_channel_swizzle((a1 >> 24) & 0xf);
 488     char *swizzle_z = i915_get_channel_swizzle((a1 >> 20) & 0xf);
 489     char *swizzle_w = i915_get_channel_swizzle((a1 >> 16) & 0xf);
 490     char swizzle[100];
 491
 492     i915_get_instruction_src_name((a0 >> 7) & 0x7, src_nr, srcname);
 493     util_snprintf(swizzle, sizeof(swizzle), ".%s%s%s%s", swizzle_x, swizzle_y, swizzle_z, swizzle_w);
 494     if (strcmp(swizzle, ".xyzw") != 0)
 495         strcat(srcname, swizzle);
 496 }
 497
 498 static void
 499 i915_get_instruction_src1(const uint32_t *data, int i, char *srcname)
 500 {
 501     uint32_t a1 = data[i + 1];
 502     uint32_t a2 = data[i + 2];
 503     int src_nr = (a1 >> 8) & 0x1f;
 504     char *swizzle_x = i915_get_channel_swizzle((a1 >> 4) & 0xf);
 505     char *swizzle_y = i915_get_channel_swizzle((a1 >> 0) & 0xf);
 506     char *swizzle_z = i915_get_channel_swizzle((a2 >> 28) & 0xf);
 507     char *swizzle_w = i915_get_channel_swizzle((a2 >> 24) & 0xf);
 508     char swizzle[100];
 509
 510     i915_get_instruction_src_name((a1 >> 13) & 0x7, src_nr, srcname);
 511     util_snprintf(swizzle, sizeof(swizzle), ".%s%s%s%s", swizzle_x, swizzle_y, swizzle_z, swizzle_w);
 512     if (strcmp(swizzle, ".xyzw") != 0)
 513         strcat(srcname, swizzle);
 514 }
 515
 516 static void
 517 i915_get_instruction_src2(const uint32_t *data, int i, char *srcname)
 518 {
 519     uint32_t a2 = data[i + 2];
 520     int src_nr = (a2 >> 16) & 0x1f;
 521     char *swizzle_x = i915_get_channel_swizzle((a2 >> 12) & 0xf);
 522     char *swizzle_y = i915_get_channel_swizzle((a2 >> 8) & 0xf);
 523     char *swizzle_z = i915_get_channel_swizzle((a2 >> 4) & 0xf);
 524     char *swizzle_w = i915_get_channel_swizzle((a2 >> 0) & 0xf);
 525     char swizzle[100];
 526
 527     i915_get_instruction_src_name((a2 >> 21) & 0x7, src_nr, srcname);
 528     util_snprintf(swizzle, sizeof(swizzle), ".%s%s%s%s", swizzle_x, swizzle_y, swizzle_z, swizzle_w);
 529     if (strcmp(swizzle, ".xyzw") != 0)
 530         strcat(srcname, swizzle);
 531 }
 532
 533 static void
 534 i915_get_instruction_addr(uint32_t src_type, uint32_t src_nr, char *name)
 535 {
 536     switch (src_type) {
 537     case 0:
 538         sprintf(name, "R%d", src_nr);
 539         if (src_nr > 15)
 540             fprintf(out, "bad src reg %s\n", name);
 541         break;
 542     case 1:
 543         if (src_nr < 8)
 544             sprintf(name, "T%d", src_nr);
 545         else if (src_nr == 8)
 546             sprintf(name, "DIFFUSE");
 547         else if (src_nr == 9)
 548             sprintf(name, "SPECULAR");
 549         else if (src_nr == 10)
 550             sprintf(name, "FOG");
 551         else {
 552             fprintf(out, "bad src reg T%d\n", src_nr);
 553             sprintf(name, "RESERVED");
 554         }
 555         break;
 556     case 4:
 557         sprintf(name, "oC");
 558         if (src_nr > 0)
 559             fprintf(out, "bad src reg oC%d\n", src_nr);
 560         break;
 561     case 5:
 562         sprintf(name, "oD");
 563         if (src_nr > 0)
 564             fprintf(out, "bad src reg oD%d\n", src_nr);
 565         break;
 566     default:
 567         fprintf(out, "bad src reg type %d\n", src_type);
 568         sprintf(name, "RESERVED");
 569         break;
 570     }
 571 }
 572
 573 static void
 574 i915_decode_alu1(const uint32_t *data, uint32_t hw_offset,
 575                  int i, char *instr_prefix, char *op_name)
 576 {
 577     char dst[100], src0[100];
 578
 579     i915_get_instruction_dst(data, i, dst, 1);
 580     i915_get_instruction_src0(data, i, src0);
 581
 582     instr_out(data, hw_offset, i++, "%s: %s %s, %s\n", instr_prefix,
 583               op_name, dst, src0);
 584     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 585     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 586 }
 587
 588 static void
 589 i915_decode_alu2(const uint32_t *data, uint32_t hw_offset,
 590                  int i, char *instr_prefix, char *op_name)
 591 {
 592     char dst[100], src0[100], src1[100];
 593
 594     i915_get_instruction_dst(data, i, dst, 1);
 595     i915_get_instruction_src0(data, i, src0);
 596     i915_get_instruction_src1(data, i, src1);
 597
 598     instr_out(data, hw_offset, i++, "%s: %s %s, %s, %s\n", instr_prefix,
 599               op_name, dst, src0, src1);
 600     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 601     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 602 }
 603
 604 static void
 605 i915_decode_alu3(const uint32_t *data, uint32_t hw_offset,
 606                  int i, char *instr_prefix, char *op_name)
 607 {
 608     char dst[100], src0[100], src1[100], src2[100];
 609
 610     i915_get_instruction_dst(data, i, dst, 1);
 611     i915_get_instruction_src0(data, i, src0);
 612     i915_get_instruction_src1(data, i, src1);
 613     i915_get_instruction_src2(data, i, src2);
 614
 615     instr_out(data, hw_offset, i++, "%s: %s %s, %s, %s, %s\n", instr_prefix,
 616               op_name, dst, src0, src1, src2);
 617     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 618     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 619 }
 620
 621 static void
 622 i915_decode_tex(const uint32_t *data, uint32_t hw_offset, int i, char *instr_prefix,
 623                 char *tex_name)
 624 {
 625     uint32_t t0 = data[i];
 626     uint32_t t1 = data[i + 1];
 627     char dst_name[100];
 628     char addr_name[100];
 629     int sampler_nr;
 630
 631     i915_get_instruction_dst(data, i, dst_name, 0);
 632     i915_get_instruction_addr((t1 >> 24) & 0x7,
 633                               (t1 >> 17) & 0xf,
 634                               addr_name);
 635     sampler_nr = t0 & 0xf;
 636
 637     instr_out(data, hw_offset, i++, "%s: %s %s, S%d, %s\n", instr_prefix,
 638               tex_name, dst_name, sampler_nr, addr_name);
 639     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 640     instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 641 }
 642
 643 static void
 644 i915_decode_dcl(const uint32_t *data, uint32_t hw_offset, int i, char *instr_prefix)
 645 {
 646     uint32_t d0 = data[i];
 647     char *sampletype;
 648     int dcl_nr = (d0 >> 14) & 0xf;
 649     char *dcl_x = d0 & (1 << 10) ? "x" : "";
 650     char *dcl_y = d0 & (1 << 11) ? "y" : "";
 651     char *dcl_z = d0 & (1 << 12) ? "z" : "";
 652     char *dcl_w = d0 & (1 << 13) ? "w" : "";
 653     char dcl_mask[10];
 654
 655     switch ((d0 >> 19) & 0x3) {
 656     case 1:
 657         util_snprintf(dcl_mask, sizeof(dcl_mask), ".%s%s%s%s", dcl_x, dcl_y, dcl_z, dcl_w);
 658         if (strcmp(dcl_mask, ".") == 0)
 659             fprintf(out, "bad (empty) dcl mask\n");
 660
 661         if (dcl_nr > 10)
 662             fprintf(out, "bad T%d dcl register number\n", dcl_nr);
 663         if (dcl_nr < 8) {
 664             if (strcmp(dcl_mask, ".x") != 0 &&
 665                 strcmp(dcl_mask, ".xy") != 0 &&
 666                 strcmp(dcl_mask, ".xz") != 0 &&
 667                 strcmp(dcl_mask, ".w") != 0 &&
 668                 strcmp(dcl_mask, ".xyzw") != 0) {
 669                 fprintf(out, "bad T%d.%s dcl mask\n", dcl_nr, dcl_mask);
 670             }
 671             instr_out(data, hw_offset, i++, "%s: DCL T%d%s\n", instr_prefix,
 672                       dcl_nr, dcl_mask);
 673         } else {
 674             if (strcmp(dcl_mask, ".xz") == 0)
 675                 fprintf(out, "errataed bad dcl mask %s\n", dcl_mask);
 676             else if (strcmp(dcl_mask, ".xw") == 0)
 677                 fprintf(out, "errataed bad dcl mask %s\n", dcl_mask);
 678             else if (strcmp(dcl_mask, ".xzw") == 0)
 679                 fprintf(out, "errataed bad dcl mask %s\n", dcl_mask);
 680
 681             if (dcl_nr == 8) {
 682                 instr_out(data, hw_offset, i++, "%s: DCL DIFFUSE%s\n", instr_prefix,
 683                           dcl_mask);
 684             } else if (dcl_nr == 9) {
 685                 instr_out(data, hw_offset, i++, "%s: DCL SPECULAR%s\n", instr_prefix,
 686                           dcl_mask);
 687             } else if (dcl_nr == 10) {
 688                 instr_out(data, hw_offset, i++, "%s: DCL FOG%s\n", instr_prefix,
 689                           dcl_mask);
 690             }
 691         }
 692         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 693         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 694         break;
 695     case 3:
 696         switch ((d0 >> 22) & 0x3) {
 697         case 0:
 698             sampletype = "2D";
 699             break;
 700         case 1:
 701             sampletype = "CUBE";
 702             break;
 703         case 2:
 704             sampletype = "3D";
 705             break;
 706         default:
 707             sampletype = "RESERVED";
 708             break;
 709         }
 710         if (dcl_nr > 15)
 711             fprintf(out, "bad S%d dcl register number\n", dcl_nr);
 712         instr_out(data, hw_offset, i++, "%s: DCL S%d %s\n", instr_prefix,
 713                   dcl_nr, sampletype);
 714         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 715         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 716         break;
 717     default:
 718         instr_out(data, hw_offset, i++, "%s: DCL RESERVED%d\n", instr_prefix, dcl_nr);
 719         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 720         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 721     }
 722 }
 723
 724 static void
 725 i915_decode_instruction(const uint32_t *data, uint32_t hw_offset,
 726                         int i, char *instr_prefix)
 727 {
 728     switch ((data[i] >> 24) & 0x1f) {
 729     case 0x0:
 730         instr_out(data, hw_offset, i++, "%s: NOP\n", instr_prefix);
 731         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 732         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 733         break;
 734     case 0x01:
 735         i915_decode_alu2(data, hw_offset, i, instr_prefix, "ADD");
 736         break;
 737     case 0x02:
 738         i915_decode_alu1(data, hw_offset, i, instr_prefix, "MOV");
 739         break;
 740     case 0x03:
 741         i915_decode_alu2(data, hw_offset, i, instr_prefix, "MUL");
 742         break;
 743     case 0x04:
 744         i915_decode_alu3(data, hw_offset, i, instr_prefix, "MAD");
 745         break;
 746     case 0x05:
 747         i915_decode_alu3(data, hw_offset, i, instr_prefix, "DP2ADD");
 748         break;
 749     case 0x06:
 750         i915_decode_alu2(data, hw_offset, i, instr_prefix, "DP3");
 751         break;
 752     case 0x07:
 753         i915_decode_alu2(data, hw_offset, i, instr_prefix, "DP4");
 754         break;
 755     case 0x08:
 756         i915_decode_alu1(data, hw_offset, i, instr_prefix, "FRC");
 757         break;
 758     case 0x09:
 759         i915_decode_alu1(data, hw_offset, i, instr_prefix, "RCP");
 760         break;
 761     case 0x0a:
 762         i915_decode_alu1(data, hw_offset, i, instr_prefix, "RSQ");
 763         break;
 764     case 0x0b:
 765         i915_decode_alu1(data, hw_offset, i, instr_prefix, "EXP");
 766         break;
 767     case 0x0c:
 768         i915_decode_alu1(data, hw_offset, i, instr_prefix, "LOG");
 769         break;
 770     case 0x0d:
 771         i915_decode_alu2(data, hw_offset, i, instr_prefix, "CMP");
 772         break;
 773     case 0x0e:
 774         i915_decode_alu2(data, hw_offset, i, instr_prefix, "MIN");
 775         break;
 776     case 0x0f:
 777         i915_decode_alu2(data, hw_offset, i, instr_prefix, "MAX");
 778         break;
 779     case 0x10:
 780         i915_decode_alu1(data, hw_offset, i, instr_prefix, "FLR");
 781         break;
 782     case 0x11:
 783         i915_decode_alu1(data, hw_offset, i, instr_prefix, "MOD");
 784         break;
 785     case 0x12:
 786         i915_decode_alu1(data, hw_offset, i, instr_prefix, "TRC");
 787         break;
 788     case 0x13:
 789         i915_decode_alu2(data, hw_offset, i, instr_prefix, "SGE");
 790         break;
 791     case 0x14:
 792         i915_decode_alu2(data, hw_offset, i, instr_prefix, "SLT");
 793         break;
 794     case 0x15:
 795         i915_decode_tex(data, hw_offset, i, instr_prefix, "TEXLD");
 796         break;
 797     case 0x16:
 798         i915_decode_tex(data, hw_offset, i, instr_prefix, "TEXLDP");
 799         break;
 800     case 0x17:
 801         i915_decode_tex(data, hw_offset, i, instr_prefix, "TEXLDB");
 802         break;
 803     case 0x19:
 804         i915_decode_dcl(data, hw_offset, i, instr_prefix);
 805         break;
 806     default:
 807         instr_out(data, hw_offset, i++, "%s: unknown\n", instr_prefix);
 808         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 809         instr_out(data, hw_offset, i++, "%s\n", instr_prefix);
 810         break;
 811     }
 812 }
 813
 814 static int
 815 decode_3d_1d(const uint32_t *data, int count,
 816              uint32_t hw_offset,
 817              uint32_t devid,
 818              int *failures)
 819 {
 820     unsigned int len, i, c, idx, word, map, sampler, instr;
 821     char *format;
 822     uint32_t opcode;
 823
 824     struct {
 825         uint32_t opcode;
 826         int i830_only;
 827         int min_len;
 828         int max_len;
 829         char *name;
 830     } opcodes_3d_1d[] = {
 831         { 0x8e, 0, 3, 3, "3DSTATE_BUFFER_INFO" },
 832         { 0x86, 0, 4, 4, "3DSTATE_CHROMA_KEY" },
 833         { 0x9c, 0, 7, 7, "3DSTATE_CLEAR_PARAMETERS" },
 834         { 0x88, 0, 2, 2, "3DSTATE_CONSTANT_BLEND_COLOR" },
 835         { 0x99, 0, 2, 2, "3DSTATE_DEFAULT_DIFFUSE" },
 836         { 0x9a, 0, 2, 2, "3DSTATE_DEFAULT_SPECULAR" },
 837         { 0x98, 0, 2, 2, "3DSTATE_DEFAULT_Z" },
 838         { 0x97, 0, 2, 2, "3DSTATE_DEPTH_OFFSET_SCALE" },
 839         { 0x85, 0, 2, 2, "3DSTATE_DEST_BUFFER_VARIABLES" },
 840         { 0x80, 0, 5, 5, "3DSTATE_DRAWING_RECTANGLE" },
 841         { 0x9d, 0, 65, 65, "3DSTATE_FILTER_COEFFICIENTS_4X4" },
 842         { 0x9e, 0, 4, 4, "3DSTATE_MONO_FILTER" },
 843         { 0x89, 0, 4, 4, "3DSTATE_FOG_MODE" },
 844         { 0x8f, 0, 2, 16, "3DSTATE_MAP_PALLETE_LOAD_32" },
 845         { 0x81, 0, 3, 3, "3DSTATE_SCISSOR_RECTANGLE" },
 846         { 0x83, 0, 2, 2, "3DSTATE_SPAN_STIPPLE" },
 847         { 0x8c, 1, 2, 2, "3DSTATE_MAP_COORD_TRANSFORM_I830" },
 848         { 0x8b, 1, 2, 2, "3DSTATE_MAP_VERTEX_TRANSFORM_I830" },
 849         { 0x8d, 1, 3, 3, "3DSTATE_W_STATE_I830" },
 850         { 0x01, 1, 2, 2, "3DSTATE_COLOR_FACTOR_I830" },
 851         { 0x02, 1, 2, 2, "3DSTATE_MAP_COORD_SETBIND_I830" },
 852     }, *opcode_3d_1d;
 853
 854     opcode = (data[0] & 0x00ff0000) >> 16;
 855
 856     switch (opcode) {
 857     case 0x07:
 858         /* This instruction is unusual.  A 0 length means just 1 DWORD instead of
 859          * 2.  The 0 length is specified in one place to be unsupported, but
 860          * stated to be required in another, and 0 length LOAD_INDIRECTs appear
 861          * to cause no harm at least.
 862          */
 863         instr_out(data, hw_offset, 0, "3DSTATE_LOAD_INDIRECT\n");
 864         len = (data[0] & 0x000000ff) + 1;
 865         i = 1;
 866         if (data[0] & (0x01 << 8)) {
 867             if (i + 2 >= count)
 868                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 869             instr_out(data, hw_offset, i++, "SIS.0\n");
 870             instr_out(data, hw_offset, i++, "SIS.1\n");
 871         }
 872         if (data[0] & (0x02 << 8)) {
 873             if (i + 1 >= count)
 874                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 875             instr_out(data, hw_offset, i++, "DIS.0\n");
 876         }
 877         if (data[0] & (0x04 << 8)) {
 878             if (i + 2 >= count)
 879                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 880             instr_out(data, hw_offset, i++, "SSB.0\n");
 881             instr_out(data, hw_offset, i++, "SSB.1\n");
 882         }
 883         if (data[0] & (0x08 << 8)) {
 884             if (i + 2 >= count)
 885                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 886             instr_out(data, hw_offset, i++, "MSB.0\n");
 887             instr_out(data, hw_offset, i++, "MSB.1\n");
 888         }
 889         if (data[0] & (0x10 << 8)) {
 890             if (i + 2 >= count)
 891                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 892             instr_out(data, hw_offset, i++, "PSP.0\n");
 893             instr_out(data, hw_offset, i++, "PSP.1\n");
 894         }
 895         if (data[0] & (0x20 << 8)) {
 896             if (i + 2 >= count)
 897                 BUFFER_FAIL(count, len, "3DSTATE_LOAD_INDIRECT");
 898             instr_out(data, hw_offset, i++, "PSC.0\n");
 899             instr_out(data, hw_offset, i++, "PSC.1\n");
 900         }
 901         if (len != i) {
 902             fprintf(out, "Bad count in 3DSTATE_LOAD_INDIRECT\n");
 903             (*failures)++;
 904             return len;
 905         }
 906         return len;
 907     case 0x04:
 908         instr_out(data, hw_offset, 0, "3DSTATE_LOAD_STATE_IMMEDIATE_1\n");
 909         len = (data[0] & 0x0000000f) + 2;
 910         i = 1;
 911         for (word = 0; word <= 8; word++) {
 912             if (data[0] & (1 << (4 + word))) {
 913                 if (i >= count)
 914                     BUFFER_FAIL(count, len, "3DSTATE_LOAD_STATE_IMMEDIATE_1");
 915
 916                 /* save vertex state for decode */
 917                 if (IS_9XX(devid)) {
 918                     if (word == 2) {
 919                         saved_s2_set = 1;
 920                         saved_s2 = data[i];
 921                     }
 922                     if (word == 4) {
 923                         saved_s4_set = 1;
 924                         saved_s4 = data[i];
 925                     }
 926                 }
 927
 928                 instr_out(data, hw_offset, i++, "S%d\n", word);
 929             }
 930         }
 931         if (len != i) {
 932             fprintf(out, "Bad count in 3DSTATE_LOAD_STATE_IMMEDIATE_1\n");
 933             (*failures)++;
 934         }
 935         return len;
 936     case 0x03:
 937         instr_out(data, hw_offset, 0, "3DSTATE_LOAD_STATE_IMMEDIATE_2\n");
 938         len = (data[0] & 0x0000000f) + 2;
 939         i = 1;
 940         for (word = 6; word <= 14; word++) {
 941             if (data[0] & (1 << word)) {
 942                 if (i >= count)
 943                     BUFFER_FAIL(count, len, "3DSTATE_LOAD_STATE_IMMEDIATE_2");
 944
 945                 if (word == 6)
 946                     instr_out(data, hw_offset, i++, "TBCF\n");
 947                 else if (word >= 7 && word <= 10) {
 948                     instr_out(data, hw_offset, i++, "TB%dC\n", word - 7);
 949                     instr_out(data, hw_offset, i++, "TB%dA\n", word - 7);
 950                 } else if (word >= 11 && word <= 14) {
 951                     instr_out(data, hw_offset, i++, "TM%dS0\n", word - 11);
 952                     instr_out(data, hw_offset, i++, "TM%dS1\n", word - 11);
 953                     instr_out(data, hw_offset, i++, "TM%dS2\n", word - 11);
 954                     instr_out(data, hw_offset, i++, "TM%dS3\n", word - 11);
 955                     instr_out(data, hw_offset, i++, "TM%dS4\n", word - 11);
 956                 }
 957             }
 958         }
 959         if (len != i) {
 960             fprintf(out, "Bad count in 3DSTATE_LOAD_STATE_IMMEDIATE_2\n");
 961             (*failures)++;
 962         }
 963         return len;
 964     case 0x00:
 965         instr_out(data, hw_offset, 0, "3DSTATE_MAP_STATE\n");
 966         len = (data[0] & 0x0000003f) + 2;
 967         instr_out(data, hw_offset, 1, "mask\n");
 968
 969         i = 2;
 970         for (map = 0; map <= 15; map++) {
 971             if (data[1] & (1 << map)) {
 972                 int width, height, pitch, dword;
 973                 const char *tiling;
 974
 975                 if (i + 3 >= count)
 976                     BUFFER_FAIL(count, len, "3DSTATE_MAP_STATE");
 977                 instr_out(data, hw_offset, i++, "map %d MS2\n", map);
 978
 979                 dword = data[i];
 980                 width = ((dword >> 10) & ((1 << 11) - 1))+1;
 981                 height = ((dword >> 21) & ((1 << 11) - 1))+1;
 982
 983                 tiling = "none";
 984                 if (dword & (1 << 2))
 985                         tiling = "fenced";
 986                 else if (dword & (1 << 1))
 987                         tiling = dword & (1 << 0) ? "Y" : "X";
 988                 instr_out(data, hw_offset, i++, "map %d MS3 [width=%d, height=%d, tiling=%s]\n", map, width, height, tiling);
 989
 990                 dword = data[i];
 991                 pitch = 4*(((dword >> 21) & ((1 << 11) - 1))+1);
 992                 instr_out(data, hw_offset, i++, "map %d MS4 [pitch=%d]\n", map, pitch);
 993             }
 994         }
 995         if (len != i) {
 996             fprintf(out, "Bad count in 3DSTATE_MAP_STATE\n");
 997             (*failures)++;
 998             return len;
 999         }
1000         return len;
1001     case 0x06:
1002         instr_out(data, hw_offset, 0, "3DSTATE_PIXEL_SHADER_CONSTANTS\n");
1003         len = (data[0] & 0x000000ff) + 2;
1004
1005         i = 2;
1006         for (c = 0; c <= 31; c++) {
1007             if (data[1] & (1 << c)) {
1008                 if (i + 4 >= count)
1009                     BUFFER_FAIL(count, len, "3DSTATE_PIXEL_SHADER_CONSTANTS");
1010                 instr_out(data, hw_offset, i, "C%d.X = %f\n",
1011                           c, int_as_float(data[i]));
1012                 i++;
1013                 instr_out(data, hw_offset, i, "C%d.Y = %f\n",
1014                           c, int_as_float(data[i]));
1015                 i++;
1016                 instr_out(data, hw_offset, i, "C%d.Z = %f\n",
1017                           c, int_as_float(data[i]));
1018                 i++;
1019                 instr_out(data, hw_offset, i, "C%d.W = %f\n",
1020                           c, int_as_float(data[i]));
1021                 i++;
1022             }
1023         }
1024         if (len != i) {
1025             fprintf(out, "Bad count in 3DSTATE_PIXEL_SHADER_CONSTANTS\n");
1026             (*failures)++;
1027         }
1028         return len;
1029     case 0x05:
1030         instr_out(data, hw_offset, 0, "3DSTATE_PIXEL_SHADER_PROGRAM\n");
1031         len = (data[0] & 0x000000ff) + 2;
1032         if ((len - 1) % 3 != 0 || len > 370) {
1033             fprintf(out, "Bad count in 3DSTATE_PIXEL_SHADER_PROGRAM\n");
1034             (*failures)++;
1035         }
1036         i = 1;
1037         for (instr = 0; instr < (len - 1) / 3; instr++) {
1038             char instr_prefix[10];
1039
1040             if (i + 3 >= count)
1041                 BUFFER_FAIL(count, len, "3DSTATE_PIXEL_SHADER_PROGRAM");
1042             util_snprintf(instr_prefix, sizeof(instr_prefix), "PS%03d", instr);
1043             i915_decode_instruction(data, hw_offset, i, instr_prefix);
1044             i += 3;
1045         }
1046         return len;
1047     case 0x01:
1048         if (!IS_9XX(devid))
1049                 break;
1050         instr_out(data, hw_offset, 0, "3DSTATE_SAMPLER_STATE\n");
1051         instr_out(data, hw_offset, 1, "mask\n");
1052         len = (data[0] & 0x0000003f) + 2;
1053         i = 2;
1054         for (sampler = 0; sampler <= 15; sampler++) {
1055             if (data[1] & (1 << sampler)) {
1056                 if (i + 3 >= count)
1057                     BUFFER_FAIL(count, len, "3DSTATE_SAMPLER_STATE");
1058                 instr_out(data, hw_offset, i++, "sampler %d SS2\n",
1059                           sampler);
1060                 instr_out(data, hw_offset, i++, "sampler %d SS3\n",
1061                           sampler);
1062                 instr_out(data, hw_offset, i++, "sampler %d SS4\n",
1063                           sampler);
1064             }
1065         }
1066         if (len != i) {
1067             fprintf(out, "Bad count in 3DSTATE_SAMPLER_STATE\n");
1068             (*failures)++;
1069         }
1070         return len;
1071     case 0x85:
1072         len = (data[0] & 0x0000000f) + 2;
1073
1074         if (len != 2)
1075             fprintf(out, "Bad count in 3DSTATE_DEST_BUFFER_VARIABLES\n");
1076         if (count < 2)
1077             BUFFER_FAIL(count, len, "3DSTATE_DEST_BUFFER_VARIABLES");
1078
1079         instr_out(data, hw_offset, 0,
1080                   "3DSTATE_DEST_BUFFER_VARIABLES\n");
1081
1082         switch ((data[1] >> 8) & 0xf) {
1083         case 0x0: format = "g8"; break;
1084         case 0x1: format = "x1r5g5b5"; break;
1085         case 0x2: format = "r5g6b5"; break;
1086         case 0x3: format = "a8r8g8b8"; break;
1087         case 0x4: format = "ycrcb_swapy"; break;
1088         case 0x5: format = "ycrcb_normal"; break;
1089         case 0x6: format = "ycrcb_swapuv"; break;
1090         case 0x7: format = "ycrcb_swapuvy"; break;
1091         case 0x8: format = "a4r4g4b4"; break;
1092         case 0x9: format = "a1r5g5b5"; break;
1093         case 0xa: format = "a2r10g10b10"; break;
1094         default: format = "BAD"; break;
1095         }
1096         instr_out(data, hw_offset, 1, "%s format, early Z %sabled\n",
1097                   format,
1098                   (data[1] & (1 << 31)) ? "en" : "dis");
1099         return len;
1100
1101     case 0x8e:
1102         {
1103             const char *name, *tiling;
1104
1105             len = (data[0] & 0x0000000f) + 2;
1106             if (len != 3)
1107                 fprintf(out, "Bad count in 3DSTATE_BUFFER_INFO\n");
1108             if (count < 3)
1109                 BUFFER_FAIL(count, len, "3DSTATE_BUFFER_INFO");
1110
1111             switch((data[1] >> 24) & 0x7) {
1112             case 0x3: name = "color"; break;
1113             case 0x7: name = "depth"; break;
1114             default: name = "unknown"; break;
1115             }
1116
1117             tiling = "none";
1118             if (data[1] & (1 << 23))
1119                 tiling = "fenced";
1120             else if (data[1] & (1 << 22))
1121                 tiling = data[1] & (1 << 21) ? "Y" : "X";
1122
1123             instr_out(data, hw_offset, 0, "3DSTATE_BUFFER_INFO\n");
1124             instr_out(data, hw_offset, 1, "%s, tiling = %s, pitch=%d\n", name, tiling, data[1]&0xffff);
1125
1126             instr_out(data, hw_offset, 2, "address\n");
1127             return len;
1128         }
1129     }
1130
1131     for (idx = 0; idx < Elements(opcodes_3d_1d); idx++)
1132     {
1133         opcode_3d_1d = &opcodes_3d_1d[idx];
1134         if (opcode_3d_1d->i830_only && IS_9XX(devid))
1135             continue;
1136
1137         if (((data[0] & 0x00ff0000) >> 16) == opcode_3d_1d->opcode) {
1138             len = 1;
1139
1140             instr_out(data, hw_offset, 0, "%s\n", opcode_3d_1d->name);
1141             if (opcode_3d_1d->max_len > 1) {
1142                 len = (data[0] & 0x0000ffff) + 2;
1143                 if (len < opcode_3d_1d->min_len ||
1144                     len > opcode_3d_1d->max_len)
1145                 {
1146                     fprintf(out, "Bad count in %s\n",
1147                             opcode_3d_1d->name);
1148                     (*failures)++;
1149                 }
1150             }
1151
1152             for (i = 1; i < len; i++) {
1153                 if (i >= count)
1154                     BUFFER_FAIL(count, len,  opcode_3d_1d->name);
1155                 instr_out(data, hw_offset, i, "dword %d\n", i);
1156             }
1157
1158             return len;
1159         }
1160     }
1161
1162     instr_out(data, hw_offset, 0, "3D UNKNOWN: 3d_1d opcode = 0x%x\n", opcode);
1163     (*failures)++;
1164     return 1;
1165 }
1166
1167 static int
1168 decode_3d_primitive(const uint32_t *data, int count, uint32_t hw_offset,
1169                     int *failures)
1170 {
1171     char immediate = (data[0] & (1 << 23)) == 0;
1172     unsigned int len, i, ret;
1173     char *primtype;
1174     int original_s2 = saved_s2;
1175     int original_s4 = saved_s4;
1176
1177     switch ((data[0] >> 18) & 0xf) {
1178     case 0x0: primtype = "TRILIST"; break;
1179     case 0x1: primtype = "TRISTRIP"; break;
1180     case 0x2: primtype = "TRISTRIP_REVERSE"; break;
1181     case 0x3: primtype = "TRIFAN"; break;
1182     case 0x4: primtype = "POLYGON"; break;
1183     case 0x5: primtype = "LINELIST"; break;
1184     case 0x6: primtype = "LINESTRIP"; break;
1185     case 0x7: primtype = "RECTLIST"; break;
1186     case 0x8: primtype = "POINTLIST"; break;
1187     case 0x9: primtype = "DIB"; break;
1188     case 0xa: primtype = "CLEAR_RECT"; saved_s4 = 3 << 6; saved_s2 = ~0; break;
1189     default: primtype = "unknown"; break;
1190     }
1191
1192     /* XXX: 3DPRIM_DIB not supported */
1193     if (immediate) {
1194         len = (data[0] & 0x0003ffff) + 2;
1195         instr_out(data, hw_offset, 0, "3DPRIMITIVE inline %s\n", primtype);
1196         if (count < len)
1197             BUFFER_FAIL(count, len,  "3DPRIMITIVE inline");
1198         if (!saved_s2_set || !saved_s4_set) {
1199             fprintf(out, "unknown vertex format\n");
1200             for (i = 1; i < len; i++) {
1201                 instr_out(data, hw_offset, i,
1202                           "           vertex data (%f float)\n",
1203                           int_as_float(data[i]));
1204             }
1205         } else {
1206             unsigned int vertex = 0;
1207             for (i = 1; i < len;) {
1208                 unsigned int tc;
1209
1210 #define VERTEX_OUT(fmt, ...) do {                                       \
1211     if (i < len)                                                        \
1212         instr_out(data, hw_offset, i, " V%d."fmt"\n", vertex, __VA_ARGS__); \
1213     else                                                                \
1214         fprintf(out, " missing data in V%d\n", vertex);                 \
1215     i++;                                                                \
1216 } while (0)
1217
1218                 VERTEX_OUT("X = %f", int_as_float(data[i]));
1219                 VERTEX_OUT("Y = %f", int_as_float(data[i]));
1220                 switch (saved_s4 >> 6 & 0x7) {
1221                 case 0x1:
1222                     VERTEX_OUT("Z = %f", int_as_float(data[i]));
1223                     break;
1224                 case 0x2:
1225                     VERTEX_OUT("Z = %f", int_as_float(data[i]));
1226                     VERTEX_OUT("W = %f", int_as_float(data[i]));
1227                     break;
1228                 case 0x3:
1229                     break;
1230                 case 0x4:
1231                     VERTEX_OUT("W = %f", int_as_float(data[i]));
1232                     break;
1233                 default:
1234                     fprintf(out, "bad S4 position mask\n");
1235                 }
1236
1237                 if (saved_s4 & (1 << 10)) {
1238                     VERTEX_OUT("color = (A=0x%02x, R=0x%02x, G=0x%02x, "
1239                                "B=0x%02x)",
1240                                data[i] >> 24,
1241                                (data[i] >> 16) & 0xff,
1242                                (data[i] >> 8) & 0xff,
1243                                data[i] & 0xff);
1244                 }
1245                 if (saved_s4 & (1 << 11)) {
1246                     VERTEX_OUT("spec = (A=0x%02x, R=0x%02x, G=0x%02x, "
1247                                "B=0x%02x)",
1248                                data[i] >> 24,
1249                                (data[i] >> 16) & 0xff,
1250                                (data[i] >> 8) & 0xff,
1251                                data[i] & 0xff);
1252                 }
1253                 if (saved_s4 & (1 << 12))
1254                     VERTEX_OUT("width = 0x%08x)", data[i]);
1255
1256                 for (tc = 0; tc <= 7; tc++) {
1257                     switch ((saved_s2 >> (tc * 4)) & 0xf) {
1258                     case 0x0:
1259                         VERTEX_OUT("T%d.X = %f", tc, int_as_float(data[i]));
1260                         VERTEX_OUT("T%d.Y = %f", tc, int_as_float(data[i]));
1261                         break;
1262                     case 0x1:
1263                         VERTEX_OUT("T%d.X = %f", tc, int_as_float(data[i]));
1264                         VERTEX_OUT("T%d.Y = %f", tc, int_as_float(data[i]));
1265                         VERTEX_OUT("T%d.Z = %f", tc, int_as_float(data[i]));
1266                         break;
1267                     case 0x2:
1268                         VERTEX_OUT("T%d.X = %f", tc, int_as_float(data[i]));
1269                         VERTEX_OUT("T%d.Y = %f", tc, int_as_float(data[i]));
1270                         VERTEX_OUT("T%d.Z = %f", tc, int_as_float(data[i]));
1271                         VERTEX_OUT("T%d.W = %f", tc, int_as_float(data[i]));
1272                         break;
1273                     case 0x3:
1274                         VERTEX_OUT("T%d.X = %f", tc, int_as_float(data[i]));
1275                         break;
1276                     case 0x4:
1277                         VERTEX_OUT("T%d.XY = 0x%08x half-float", tc, data[i]);
1278                         break;
1279                     case 0x5:
1280                         VERTEX_OUT("T%d.XY = 0x%08x half-float", tc, data[i]);
1281                         VERTEX_OUT("T%d.ZW = 0x%08x half-float", tc, data[i]);
1282                         break;
1283                     case 0xf:
1284                         break;
1285                     default:
1286                         fprintf(out, "bad S2.T%d format\n", tc);
1287                     }
1288                 }
1289                 vertex++;
1290             }
1291         }
1292
1293         ret = len;
1294     } else {
1295         /* indirect vertices */
1296         len = data[0] & 0x0000ffff; /* index count */
1297         if (data[0] & (1 << 17)) {
1298             /* random vertex access */
1299             if (count < (len + 1) / 2 + 1) {
1300                 BUFFER_FAIL(count, (len + 1) / 2 + 1,
1301                             "3DPRIMITIVE random indirect");
1302             }
1303             instr_out(data, hw_offset, 0,
1304                       "3DPRIMITIVE random indirect %s (%d)\n", primtype, len);
1305             if (len == 0) {
1306                 /* vertex indices continue until 0xffff is found */
1307                 for (i = 1; i < count; i++) {
1308                     if ((data[i] & 0xffff) == 0xffff) {
1309                         instr_out(data, hw_offset, i,
1310                                   "            indices: (terminator)\n");
1311                         ret = i;
1312                         goto out;
1313                     } else if ((data[i] >> 16) == 0xffff) {
1314                         instr_out(data, hw_offset, i,
1315                                   "            indices: 0x%04x, "
1316                                   "(terminator)\n",
1317                                   data[i] & 0xffff);
1318                         ret = i;
1319                         goto out;
1320                     } else {
1321                         instr_out(data, hw_offset, i,
1322                                   "            indices: 0x%04x, 0x%04x\n",
1323                                   data[i] & 0xffff, data[i] >> 16);
1324                     }
1325                 }
1326                 fprintf(out,
1327                         "3DPRIMITIVE: no terminator found in index buffer\n");
1328                 (*failures)++;
1329                 ret = count;
1330                 goto out;
1331             } else {
1332                 /* fixed size vertex index buffer */
1333                 for (i = 0; i < len; i += 2) {
1334                     if (i * 2 == len - 1) {
1335                         instr_out(data, hw_offset, i,
1336                                   "            indices: 0x%04x\n",
1337                                   data[i] & 0xffff);
1338                     } else {
1339                         instr_out(data, hw_offset, i,
1340                                   "            indices: 0x%04x, 0x%04x\n",
1341                                   data[i] & 0xffff, data[i] >> 16);
1342                     }
1343                 }
1344             }
1345             ret = (len + 1) / 2 + 1;
1346             goto out;
1347         } else {
1348             /* sequential vertex access */
1349             if (count < 2)
1350                 BUFFER_FAIL(count, 2, "3DPRIMITIVE seq indirect");
1351             instr_out(data, hw_offset, 0,
1352                       "3DPRIMITIVE sequential indirect %s, %d starting from "
1353                       "%d\n", primtype, len, data[1] & 0xffff);
1354             instr_out(data, hw_offset, 1, "           start\n");
1355             ret = 2;
1356             goto out;
1357         }
1358     }
1359
1360 out:
1361     saved_s2 = original_s2;
1362     saved_s4 = original_s4;
1363     return ret;
1364 }
1365
1366 static int
1367 decode_3d(const uint32_t *data, int count, uint32_t hw_offset, uint32_t devid, int *failures)
1368 {
1369     uint32_t opcode;
1370     unsigned int idx;
1371
1372     struct {
1373         uint32_t opcode;
1374         int min_len;
1375         int max_len;
1376         char *name;
1377     } opcodes_3d[] = {
1378         { 0x06, 1, 1, "3DSTATE_ANTI_ALIASING" },
1379         { 0x08, 1, 1, "3DSTATE_BACKFACE_STENCIL_OPS" },
1380         { 0x09, 1, 1, "3DSTATE_BACKFACE_STENCIL_MASKS" },
1381         { 0x16, 1, 1, "3DSTATE_COORD_SET_BINDINGS" },
1382         { 0x15, 1, 1, "3DSTATE_FOG_COLOR" },
1383         { 0x0b, 1, 1, "3DSTATE_INDEPENDENT_ALPHA_BLEND" },
1384         { 0x0d, 1, 1, "3DSTATE_MODES_4" },
1385         { 0x0c, 1, 1, "3DSTATE_MODES_5" },
1386         { 0x07, 1, 1, "3DSTATE_RASTERIZATION_RULES" },
1387     }, *opcode_3d;
1388
1389     opcode = (data[0] & 0x1f000000) >> 24;
1390
1391     switch (opcode) {
1392     case 0x1f:
1393         return decode_3d_primitive(data, count, hw_offset, failures);
1394     case 0x1d:
1395         return decode_3d_1d(data, count, hw_offset, devid, failures);
1396     case 0x1c:
1397         return decode_3d_1c(data, count, hw_offset, failures);
1398     }
1399
1400     for (idx = 0; idx < Elements(opcodes_3d); idx++) {
1401         opcode_3d = &opcodes_3d[idx];
1402         if (opcode == opcode_3d->opcode) {
1403             unsigned int len = 1, i;
1404
1405             instr_out(data, hw_offset, 0, "%s\n", opcode_3d->name);
1406             if (opcode_3d->max_len > 1) {
1407                 len = (data[0] & 0xff) + 2;
1408                 if (len < opcode_3d->min_len ||
1409                     len > opcode_3d->max_len)
1410                 {
1411                     fprintf(out, "Bad count in %s\n", opcode_3d->name);
1412                 }
1413             }
1414
1415             for (i = 1; i < len; i++) {
1416                 if (i >= count)
1417                     BUFFER_FAIL(count, len, opcode_3d->name);
1418                 instr_out(data, hw_offset, i, "dword %d\n", i);
1419             }
1420             return len;
1421         }
1422     }
1423
1424     instr_out(data, hw_offset, 0, "3D UNKNOWN: 3d opcode = 0x%x\n", opcode);
1425     (*failures)++;
1426     return 1;
1427 }
1428
1429 static const char *
1430 get_965_surfacetype(unsigned int surfacetype)
1431 {
1432     switch (surfacetype) {
1433     case 0: return "1D";
1434     case 1: return "2D";
1435     case 2: return "3D";
1436     case 3: return "CUBE";
1437     case 4: return "BUFFER";
1438     case 7: return "NULL";
1439     default: return "unknown";
1440     }
1441 }
1442
1443 static const char *
1444 get_965_depthformat(unsigned int depthformat)
1445 {
1446     switch (depthformat) {
1447     case 0: return "s8_z24float";
1448     case 1: return "z32float";
1449     case 2: return "z24s8";
1450     case 5: return "z16";
1451     default: return "unknown";
1452     }
1453 }
1454
1455 static const char *
1456 get_965_element_component(uint32_t data, int component)
1457 {
1458     uint32_t component_control = (data >> (16 + (3 - component) * 4)) & 0x7;
1459
1460     switch (component_control) {
1461     case 0:
1462         return "nostore";
1463     case 1:
1464         switch (component) {
1465         case 0: return "X";
1466         case 1: return "Y";
1467         case 2: return "Z";
1468         case 3: return "W";
1469         default: return "fail";
1470         }
1471     case 2:
1472         return "0.0";
1473     case 3:
1474         return "1.0";
1475     case 4:
1476         return "0x1";
1477     case 5:
1478         return "VID";
1479     default:
1480         return "fail";
1481     }
1482 }
1483
1484 static const char *
1485 get_965_prim_type(uint32_t data)
1486 {
1487     uint32_t primtype = (data >> 10) & 0x1f;
1488
1489     switch (primtype) {
1490     case 0x01: return "point list";
1491     case 0x02: return "line list";
1492     case 0x03: return "line strip";
1493     case 0x04: return "tri list";
1494     case 0x05: return "tri strip";
1495     case 0x06: return "tri fan";
1496     case 0x07: return "quad list";
1497     case 0x08: return "quad strip";
1498     case 0x09: return "line list adj";
1499     case 0x0a: return "line strip adj";
1500     case 0x0b: return "tri list adj";
1501     case 0x0c: return "tri strip adj";
1502     case 0x0d: return "tri strip reverse";
1503     case 0x0e: return "polygon";
1504     case 0x0f: return "rect list";
1505     case 0x10: return "line loop";
1506     case 0x11: return "point list bf";
1507     case 0x12: return "line strip cont";
1508     case 0x13: return "line strip bf";
1509     case 0x14: return "line strip cont bf";
1510     case 0x15: return "tri fan no stipple";
1511     default: return "fail";
1512     }
1513 }
1514 static int
1515 i965_decode_urb_fence(const uint32_t *data, uint32_t hw_offset, int len, int count,
1516                       int *failures)
1517 {
1518         uint32_t vs_fence, clip_fence, gs_fence, sf_fence, vfe_fence, cs_fence;
1519
1520         if (len != 3)
1521             fprintf(out, "Bad count in URB_FENCE\n");
1522         if (count < 3)
1523             BUFFER_FAIL(count, len, "URB_FENCE");
1524
1525         vs_fence = data[1] & 0x3ff;
1526         gs_fence = (data[1] >> 10) & 0x3ff;
1527         clip_fence = (data[1] >> 20) & 0x3ff;
1528         sf_fence = data[2] & 0x3ff;
1529         vfe_fence = (data[2] >> 10) & 0x3ff;
1530         cs_fence = (data[2] >> 20) & 0x7ff;
1531
1532         instr_out(data, hw_offset, 0, "URB_FENCE: %s%s%s%s%s%s\n",
1533                         (data[0] >> 13) & 1 ? "cs " : "",
1534                         (data[0] >> 12) & 1 ? "vfe " : "",
1535                         (data[0] >> 11) & 1 ? "sf " : "",
1536                         (data[0] >> 10) & 1 ? "clip " : "",
1537                         (data[0] >> 9)  & 1 ? "gs " : "",
1538                         (data[0] >> 8)  & 1 ? "vs " : "");
1539         instr_out(data, hw_offset, 1,
1540                   "vs fence: %d, clip_fence: %d, gs_fence: %d\n",
1541                   vs_fence, clip_fence, gs_fence);
1542         instr_out(data, hw_offset, 2,
1543                   "sf fence: %d, vfe_fence: %d, cs_fence: %d\n",
1544                   sf_fence, vfe_fence, cs_fence);
1545         if (gs_fence < vs_fence)
1546             fprintf(out, "gs fence < vs fence!\n");
1547         if (clip_fence < gs_fence)
1548             fprintf(out, "clip fence < gs fence!\n");
1549         if (sf_fence < clip_fence)
1550             fprintf(out, "sf fence < clip fence!\n");
1551         if (cs_fence < sf_fence)
1552             fprintf(out, "cs fence < sf fence!\n");
1553
1554         return len;
1555 }
1556
1557 static void
1558 state_base_out(const uint32_t *data, uint32_t hw_offset, unsigned int index,
1559                char *name)
1560 {
1561     if (data[index] & 1) {
1562         instr_out(data, hw_offset, index, "%s state base address 0x%08x\n",
1563                   name, data[index] & ~1);
1564     } else {
1565         instr_out(data, hw_offset, index, "%s state base not updated\n",
1566                   name);
1567     }
1568 }
1569
1570 static void
1571 state_max_out(const uint32_t *data, uint32_t hw_offset, unsigned int index,
1572               char *name)
1573 {
1574     if (data[index] & 1) {
1575         if (data[index] == 1) {
1576             instr_out(data, hw_offset, index,
1577                       "%s state upper bound disabled\n", name);
1578         } else {
1579             instr_out(data, hw_offset, index, "%s state upper bound 0x%08x\n",
1580                       name, data[index] & ~1);
1581         }
1582     } else {
1583         instr_out(data, hw_offset, index, "%s state upper bound not updated\n",
1584                   name);
1585     }
1586 }
1587
1588 static int
1589 decode_3d_965(const uint32_t *data, int count, uint32_t hw_offset, uint32_t devid, int *failures)
1590 {
1591     uint32_t opcode;
1592     unsigned int idx, len;
1593     int i, sba_len;
1594     char *desc1 = NULL;
1595
1596     struct {
1597         uint32_t opcode;
1598         int min_len;
1599         int max_len;
1600         char *name;
1601     } opcodes_3d[] = {
1602         { 0x6000, 3, 3, "URB_FENCE" },
1603         { 0x6001, 2, 2, "CS_URB_STATE" },
1604         { 0x6002, 2, 2, "CONSTANT_BUFFER" },
1605         { 0x6101, 6, 6, "STATE_BASE_ADDRESS" },
1606         { 0x6102, 2, 2 , "STATE_SIP" },
1607         { 0x6104, 1, 1, "3DSTATE_PIPELINE_SELECT" },
1608         { 0x680b, 1, 1, "3DSTATE_VF_STATISTICS" },
1609         { 0x6904, 1, 1, "3DSTATE_PIPELINE_SELECT" },
1610         { 0x7800, 7, 7, "3DSTATE_PIPELINED_POINTERS" },
1611         { 0x7801, 6, 6, "3DSTATE_BINDING_TABLE_POINTERS" },
1612         { 0x780b, 1, 1, "3DSTATE_VF_STATISTICS" },
1613         { 0x7808, 5, 257, "3DSTATE_VERTEX_BUFFERS" },
1614         { 0x7809, 3, 256, "3DSTATE_VERTEX_ELEMENTS" },
1615         { 0x780a, 3, 3, "3DSTATE_INDEX_BUFFER" },
1616         { 0x7900, 4, 4, "3DSTATE_DRAWING_RECTANGLE" },
1617         { 0x7901, 5, 5, "3DSTATE_CONSTANT_COLOR" },
1618         { 0x7905, 5, 7, "3DSTATE_DEPTH_BUFFER" },
1619         { 0x7906, 2, 2, "3DSTATE_POLY_STIPPLE_OFFSET" },
1620         { 0x7907, 33, 33, "3DSTATE_POLY_STIPPLE_PATTERN" },
1621         { 0x7908, 3, 3, "3DSTATE_LINE_STIPPLE" },
1622         { 0x7909, 2, 2, "3DSTATE_GLOBAL_DEPTH_OFFSET_CLAMP" },
1623         { 0x7909, 2, 2, "3DSTATE_CLEAR_PARAMS" },
1624         { 0x790a, 3, 3, "3DSTATE_AA_LINE_PARAMETERS" },
1625         { 0x790b, 4, 4, "3DSTATE_GS_SVB_INDEX" },
1626         { 0x790d, 3, 3, "3DSTATE_MULTISAMPLE" },
1627         { 0x7b00, 6, 6, "3DPRIMITIVE" },
1628         { 0x7802, 4, 4, "3DSTATE_SAMPLER_STATE_POINTERS" },
1629         { 0x7805, 3, 3, "3DSTATE_URB" },
1630         { 0x780e, 4, 4, "3DSTATE_CC_STATE_POINTERS" },
1631         { 0x7810, 6, 6, "3DSTATE_VS_STATE" },
1632         { 0x7811, 7, 7, "3DSTATE_GS_STATE" },
1633         { 0x7812, 4, 4, "3DSTATE_CLIP_STATE" },
1634         { 0x7813, 20, 20, "3DSTATE_SF_STATE" },
1635         { 0x7814, 9, 9, "3DSTATE_WM_STATE" },
1636         { 0x7812, 4, 4, "3DSTATE_CLIP_STATE" },
1637         { 0x7815, 5, 5, "3DSTATE_CONSTANT_VS_STATE" },
1638         { 0x7816, 5, 5, "3DSTATE_CONSTANT_GS_STATE" },
1639         { 0x7817, 5, 5, "3DSTATE_CONSTANT_PS_STATE" },
1640         { 0x7818, 2, 2, "3DSTATE_SAMPLE_MASK" },
1641    }, *opcode_3d;
1642
1643     len = (data[0] & 0x0000ffff) + 2;
1644
1645     opcode = (data[0] & 0xffff0000) >> 16;
1646     switch (opcode) {
1647     case 0x6000:
1648         len = (data[0] & 0x000000ff) + 2;
1649         return i965_decode_urb_fence(data, hw_offset, len, count, failures);
1650     case 0x6001:
1651         instr_out(data, hw_offset, 0, "CS_URB_STATE\n");
1652         instr_out(data, hw_offset, 1, "entry_size: %d [%d bytes], n_entries: %d\n",
1653                         (data[1] >> 4) & 0x1f,
1654                         (((data[1] >> 4) & 0x1f) + 1) * 64,
1655                         data[1] & 0x7);
1656         return len;
1657     case 0x6002:
1658         len = (data[0] & 0x000000ff) + 2;
1659         instr_out(data, hw_offset, 0, "CONSTANT_BUFFER: %s\n",
1660                         (data[0] >> 8) & 1 ? "valid" : "invalid");
1661         instr_out(data, hw_offset, 1, "offset: 0x%08x, length: %d bytes\n",
1662                         data[1] & ~0x3f, ((data[1] & 0x3f) + 1) * 64);
1663         return len;
1664     case 0x6101:
1665         if (IS_GEN6(devid))
1666             sba_len = 10;
1667         else if (IS_IRONLAKE(devid))
1668             sba_len = 8;
1669         else
1670             sba_len = 6;
1671         if (len != sba_len)
1672             fprintf(out, "Bad count in STATE_BASE_ADDRESS\n");
1673         if (len != sba_len)
1674             BUFFER_FAIL(count, len, "STATE_BASE_ADDRESS");
1675
1676         i = 0;
1677         instr_out(data, hw_offset, 0,
1678                   "STATE_BASE_ADDRESS\n");
1679         i++;
1680
1681         state_base_out(data, hw_offset, i++, "general");
1682         state_base_out(data, hw_offset, i++, "surface");
1683         if (IS_GEN6(devid))
1684             state_base_out(data, hw_offset, i++, "dynamic");
1685         state_base_out(data, hw_offset, i++, "indirect");
1686         if (IS_IRONLAKE(devid) || IS_GEN6(devid))
1687             state_base_out(data, hw_offset, i++, "instruction");
1688
1689         state_max_out(data, hw_offset, i++, "general");
1690         if (IS_GEN6(devid))
1691             state_max_out(data, hw_offset, i++, "dynamic");
1692         state_max_out(data, hw_offset, i++, "indirect");
1693         if (IS_IRONLAKE(devid) || IS_GEN6(devid))
1694             state_max_out(data, hw_offset, i++, "instruction");
1695
1696         return len;
1697     case 0x7800:
1698         if (len != 7)
1699             fprintf(out, "Bad count in 3DSTATE_PIPELINED_POINTERS\n");
1700         if (count < 7)
1701             BUFFER_FAIL(count, len, "3DSTATE_PIPELINED_POINTERS");
1702
1703         instr_out(data, hw_offset, 0,
1704                   "3DSTATE_PIPELINED_POINTERS\n");
1705         instr_out(data, hw_offset, 1, "VS state\n");
1706         instr_out(data, hw_offset, 2, "GS state\n");
1707         instr_out(data, hw_offset, 3, "Clip state\n");
1708         instr_out(data, hw_offset, 4, "SF state\n");
1709         instr_out(data, hw_offset, 5, "WM state\n");
1710         instr_out(data, hw_offset, 6, "CC state\n");
1711         return len;
1712     case 0x7801:
1713         len = (data[0] & 0x000000ff) + 2;
1714         if (len != 6 && len != 4)
1715             fprintf(out, "Bad count in 3DSTATE_BINDING_TABLE_POINTERS\n");
1716         if (len == 6) {
1717             if (count < 6)
1718                 BUFFER_FAIL(count, len, "3DSTATE_BINDING_TABLE_POINTERS");
1719             instr_out(data, hw_offset, 0,
1720                       "3DSTATE_BINDING_TABLE_POINTERS\n");
1721             instr_out(data, hw_offset, 1, "VS binding table\n");
1722             instr_out(data, hw_offset, 2, "GS binding table\n");
1723             instr_out(data, hw_offset, 3, "Clip binding table\n");
1724             instr_out(data, hw_offset, 4, "SF binding table\n");
1725             instr_out(data, hw_offset, 5, "WM binding table\n");
1726         } else {
1727             if (count < 4)
1728                 BUFFER_FAIL(count, len, "3DSTATE_BINDING_TABLE_POINTERS");
1729
1730             instr_out(data, hw_offset, 0,
1731                       "3DSTATE_BINDING_TABLE_POINTERS: VS mod %d, "
1732                       "GS mod %d, PS mod %d\n",
1733                       (data[0] & (1 << 8)) != 0,
1734                       (data[0] & (1 << 9)) != 0,
1735                       (data[0] & (1 << 10)) != 0);
1736             instr_out(data, hw_offset, 1, "VS binding table\n");
1737             instr_out(data, hw_offset, 2, "GS binding table\n");
1738             instr_out(data, hw_offset, 3, "WM binding table\n");
1739         }
1740
1741         return len;
1742
1743     case 0x7808:
1744         len = (data[0] & 0xff) + 2;
1745         if ((len - 1) % 4 != 0)
1746             fprintf(out, "Bad count in 3DSTATE_VERTEX_BUFFERS\n");
1747         if (count < len)
1748             BUFFER_FAIL(count, len, "3DSTATE_VERTEX_BUFFERS");
1749         instr_out(data, hw_offset, 0, "3DSTATE_VERTEX_BUFFERS\n");
1750
1751         for (i = 1; i < len;) {
1752             instr_out(data, hw_offset, i, "buffer %d: %s, pitch %db\n",
1753                       data[i] >> 27,
1754                       data[i] & (1 << 26) ? "random" : "sequential",
1755                       data[i] & 0x07ff);
1756             i++;
1757             instr_out(data, hw_offset, i++, "buffer address\n");
1758             instr_out(data, hw_offset, i++, "max index\n");
1759             instr_out(data, hw_offset, i++, "mbz\n");
1760         }
1761         return len;
1762
1763     case 0x7809:
1764         len = (data[0] & 0xff) + 2;
1765         if ((len + 1) % 2 != 0)
1766             fprintf(out, "Bad count in 3DSTATE_VERTEX_ELEMENTS\n");
1767         if (count < len)
1768             BUFFER_FAIL(count, len, "3DSTATE_VERTEX_ELEMENTS");
1769         instr_out(data, hw_offset, 0, "3DSTATE_VERTEX_ELEMENTS\n");
1770
1771         for (i = 1; i < len;) {
1772             instr_out(data, hw_offset, i, "buffer %d: %svalid, type 0x%04x, "
1773                       "src offset 0x%04x bytes\n",
1774                       data[i] >> 27,
1775                       data[i] & (1 << 26) ? "" : "in",
1776                       (data[i] >> 16) & 0x1ff,
1777                       data[i] & 0x07ff);
1778             i++;
1779             instr_out(data, hw_offset, i, "(%s, %s, %s, %s), "
1780                       "dst offset 0x%02x bytes\n",
1781                       get_965_element_component(data[i], 0),
1782                       get_965_element_component(data[i], 1),
1783                       get_965_element_component(data[i], 2),
1784                       get_965_element_component(data[i], 3),
1785                       (data[i] & 0xff) * 4);
1786             i++;
1787         }
1788         return len;
1789
1790     case 0x780d:
1791         len = (data[0] & 0xff) + 2;
1792         if (len != 4)
1793             fprintf(out, "Bad count in 3DSTATE_VIEWPORT_STATE_POINTERS\n");
1794         if (count < len)
1795             BUFFER_FAIL(count, len, "3DSTATE_VIEWPORT_STATE_POINTERS");
1796         instr_out(data, hw_offset, 0, "3DSTATE_VIEWPORT_STATE_POINTERS\n");
1797         instr_out(data, hw_offset, 1, "clip\n");
1798         instr_out(data, hw_offset, 2, "sf\n");
1799         instr_out(data, hw_offset, 3, "cc\n");
1800         return len;
1801
1802     case 0x780a:
1803         len = (data[0] & 0xff) + 2;
1804         if (len != 3)
1805             fprintf(out, "Bad count in 3DSTATE_INDEX_BUFFER\n");
1806         if (count < len)
1807             BUFFER_FAIL(count, len, "3DSTATE_INDEX_BUFFER");
1808         instr_out(data, hw_offset, 0, "3DSTATE_INDEX_BUFFER\n");
1809         instr_out(data, hw_offset, 1, "beginning buffer address\n");
1810         instr_out(data, hw_offset, 2, "ending buffer address\n");
1811         return len;
1812
1813     case 0x7900:
1814         if (len != 4)
1815             fprintf(out, "Bad count in 3DSTATE_DRAWING_RECTANGLE\n");
1816         if (count < 4)
1817             BUFFER_FAIL(count, len, "3DSTATE_DRAWING_RECTANGLE");
1818
1819         instr_out(data, hw_offset, 0,
1820                   "3DSTATE_DRAWING_RECTANGLE\n");
1821         instr_out(data, hw_offset, 1, "top left: %d,%d\n",
1822                   data[1] & 0xffff,
1823                   (data[1] >> 16) & 0xffff);
1824         instr_out(data, hw_offset, 2, "bottom right: %d,%d\n",
1825                   data[2] & 0xffff,
1826                   (data[2] >> 16) & 0xffff);
1827         instr_out(data, hw_offset, 3, "origin: %d,%d\n",
1828                   (int)data[3] & 0xffff,
1829                   ((int)data[3] >> 16) & 0xffff);
1830
1831         return len;
1832
1833     case 0x7905:
1834         if (len < 5 || len > 7)
1835             fprintf(out, "Bad count in 3DSTATE_DEPTH_BUFFER\n");
1836         if (count < len)
1837             BUFFER_FAIL(count, len, "3DSTATE_DEPTH_BUFFER");
1838
1839         instr_out(data, hw_offset, 0,
1840                   "3DSTATE_DEPTH_BUFFER\n");
1841         instr_out(data, hw_offset, 1, "%s, %s, pitch = %d bytes, %stiled\n",
1842                   get_965_surfacetype(data[1] >> 29),
1843                   get_965_depthformat((data[1] >> 18) & 0x7),
1844                   (data[1] & 0x0001ffff) + 1,
1845                   data[1] & (1 << 27) ? "" : "not ");
1846         instr_out(data, hw_offset, 2, "depth offset\n");
1847         instr_out(data, hw_offset, 3, "%dx%d\n",
1848                   ((data[3] & 0x0007ffc0) >> 6) + 1,
1849                   ((data[3] & 0xfff80000) >> 19) + 1);
1850         instr_out(data, hw_offset, 4, "volume depth\n");
1851         if (len >= 6)
1852             instr_out(data, hw_offset, 5, "\n");
1853        if (len >= 7)
1854            instr_out(data, hw_offset, 6, "render target view extent\n");
1855
1856         return len;
1857
1858     case 0x7a00:
1859         len = (data[0] & 0xff) + 2;
1860         if (len != 4)
1861             fprintf(out, "Bad count in PIPE_CONTROL\n");
1862         if (count < len)
1863             BUFFER_FAIL(count, len, "PIPE_CONTROL");
1864
1865         switch ((data[0] >> 14) & 0x3) {
1866         case 0: desc1 = "no write"; break;
1867         case 1: desc1 = "qword write"; break;
1868         case 2: desc1 = "PS_DEPTH_COUNT write"; break;
1869         case 3: desc1 = "TIMESTAMP write"; break;
1870         }
1871         instr_out(data, hw_offset, 0,
1872                   "PIPE_CONTROL: %s, %sdepth stall, %sRC write flush, "
1873                   "%sinst flush\n",
1874                   desc1,
1875                   data[0] & (1 << 13) ? "" : "no ",
1876                   data[0] & (1 << 12) ? "" : "no ",
1877                   data[0] & (1 << 11) ? "" : "no ");
1878         instr_out(data, hw_offset, 1, "destination address\n");
1879         instr_out(data, hw_offset, 2, "immediate dword low\n");
1880         instr_out(data, hw_offset, 3, "immediate dword high\n");
1881         return len;
1882
1883     case 0x7b00:
1884         len = (data[0] & 0xff) + 2;
1885         if (len != 6)
1886             fprintf(out, "Bad count in 3DPRIMITIVE\n");
1887         if (count < len)
1888             BUFFER_FAIL(count, len, "3DPRIMITIVE");
1889
1890         instr_out(data, hw_offset, 0,
1891                   "3DPRIMITIVE: %s %s\n",
1892                   get_965_prim_type(data[0]),
1893                   (data[0] & (1 << 15)) ? "random" : "sequential");
1894         instr_out(data, hw_offset, 1, "vertex count\n");
1895         instr_out(data, hw_offset, 2, "start vertex\n");
1896         instr_out(data, hw_offset, 3, "instance count\n");
1897         instr_out(data, hw_offset, 4, "start instance\n");
1898         instr_out(data, hw_offset, 5, "index bias\n");
1899         return len;
1900     }
1901
1902     for (idx = 0; idx < Elements(opcodes_3d); idx++) {
1903         opcode_3d = &opcodes_3d[idx];
1904         if ((data[0] & 0xffff0000) >> 16 == opcode_3d->opcode) {
1905             unsigned int i;
1906             len = 1;
1907
1908             instr_out(data, hw_offset, 0, "%s\n", opcode_3d->name);
1909             if (opcode_3d->max_len > 1) {
1910                 len = (data[0] & 0xff) + 2;
1911                 if (len < opcode_3d->min_len ||
1912                     len > opcode_3d->max_len)
1913                 {
1914                     fprintf(out, "Bad count in %s\n", opcode_3d->name);
1915                 }
1916             }
1917
1918             for (i = 1; i < len; i++) {
1919                 if (i >= count)
1920                     BUFFER_FAIL(count, len, opcode_3d->name);
1921                 instr_out(data, hw_offset, i, "dword %d\n", i);
1922             }
1923             return len;
1924         }
1925     }
1926
1927     instr_out(data, hw_offset, 0, "3D UNKNOWN: 3d_965 opcode = 0x%x\n", opcode);
1928     (*failures)++;
1929     return 1;
1930 }
1931
1932 static int
1933 decode_3d_i830(const uint32_t *data, int count, uint32_t hw_offset, uint32_t devid, int *failures)
1934 {
1935     unsigned int idx;
1936     uint32_t opcode;
1937
1938     struct {
1939         uint32_t opcode;
1940         int min_len;
1941         int max_len;
1942         char *name;
1943     } opcodes_3d[] = {
1944         { 0x02, 1, 1, "3DSTATE_MODES_3" },
1945         { 0x03, 1, 1, "3DSTATE_ENABLES_1"},
1946         { 0x04, 1, 1, "3DSTATE_ENABLES_2"},
1947         { 0x05, 1, 1, "3DSTATE_VFT0"},
1948         { 0x06, 1, 1, "3DSTATE_AA"},
1949         { 0x07, 1, 1, "3DSTATE_RASTERIZATION_RULES" },
1950         { 0x08, 1, 1, "3DSTATE_MODES_1" },
1951         { 0x09, 1, 1, "3DSTATE_STENCIL_TEST" },
1952         { 0x0a, 1, 1, "3DSTATE_VFT1"},
1953         { 0x0b, 1, 1, "3DSTATE_INDPT_ALPHA_BLEND" },
1954         { 0x0c, 1, 1, "3DSTATE_MODES_5" },
1955         { 0x0d, 1, 1, "3DSTATE_MAP_BLEND_OP" },
1956         { 0x0e, 1, 1, "3DSTATE_MAP_BLEND_ARG" },
1957         { 0x0f, 1, 1, "3DSTATE_MODES_2" },
1958         { 0x15, 1, 1, "3DSTATE_FOG_COLOR" },
1959         { 0x16, 1, 1, "3DSTATE_MODES_4" },
1960     }, *opcode_3d;
1961
1962     opcode = (data[0] & 0x1f000000) >> 24;
1963
1964     switch (opcode) {
1965     case 0x1f:
1966         return decode_3d_primitive(data, count, hw_offset, failures);
1967     case 0x1d:
1968         return decode_3d_1d(data, count, hw_offset, devid, failures);
1969     case 0x1c:
1970         return decode_3d_1c(data, count, hw_offset, failures);
1971     }
1972
1973     for (idx = 0; idx < Elements(opcodes_3d); idx++) {
1974         opcode_3d = &opcodes_3d[idx];
1975         if ((data[0] & 0x1f000000) >> 24 == opcode_3d->opcode) {
1976             unsigned int len = 1, i;
1977
1978             instr_out(data, hw_offset, 0, "%s\n", opcode_3d->name);
1979             if (opcode_3d->max_len > 1) {
1980                 len = (data[0] & 0xff) + 2;
1981                 if (len < opcode_3d->min_len ||
1982                     len > opcode_3d->max_len)
1983                 {
1984                     fprintf(out, "Bad count in %s\n", opcode_3d->name);
1985                 }
1986             }
1987
1988             for (i = 1; i < len; i++) {
1989                 if (i >= count)
1990                     BUFFER_FAIL(count, len, opcode_3d->name);
1991                 instr_out(data, hw_offset, i, "dword %d\n", i);
1992             }
1993             return len;
1994         }
1995     }
1996
1997     instr_out(data, hw_offset, 0, "3D UNKNOWN: 3d_i830 opcode = 0x%x\n", opcode);
1998     (*failures)++;
1999     return 1;
2000 }
2001
2002 /**
2003  * Decodes an i830-i915 batch buffer, writing the output to stdout.
2004  *
2005  * \param data batch buffer contents
2006  * \param count number of DWORDs to decode in the batch buffer
2007  * \param hw_offset hardware address for the buffer
2008  */
2009 int
2010 intel_decode(const uint32_t *data, int count,
2011              uint32_t hw_offset,
2012              uint32_t devid,
2013              uint32_t ignore_end_of_batchbuffer)
2014 {
2015     int ret;
2016     int index = 0;
2017     int failures = 0;
2018
2019     out = stderr;
2020
2021     while (index < count) {
2022         switch ((data[index] & 0xe0000000) >> 29) {
2023         case 0x0:
2024             ret = decode_mi(data + index, count - index,
2025                                hw_offset + index * 4, &failures);
2026
2027             /* If MI_BATCHBUFFER_END happened, then dump the rest of the
2028              * output in case we some day want it in debugging, but don't
2029              * decode it since it'll just confuse in the common case.
2030              */
2031             if (ret == -1) {
2032                 if (ignore_end_of_batchbuffer) {
2033                     index++;
2034                 } else {
2035                     for (index = index + 1; index < count; index++) {
2036                         instr_out(data, hw_offset, index, "\n");
2037                     }
2038                 }
2039             } else
2040                 index += ret;
2041             break;
2042         case 0x2:
2043             index += decode_2d(data + index, count - index,
2044                                hw_offset + index * 4, &failures);
2045             break;
2046         case 0x3:
2047             if (IS_965(devid)) {
2048                 index += decode_3d_965(data + index, count - index,
2049                                        hw_offset + index * 4,
2050                                        devid, &failures);
2051             } else if (IS_9XX(devid)) {
2052                 index += decode_3d(data + index, count - index,
2053                                    hw_offset + index * 4,
2054                                    devid, &failures);
2055             } else {
2056                 index += decode_3d_i830(data + index, count - index,
2057                                         hw_offset + index * 4,
2058                                         devid, &failures);
2059             }
2060             break;
2061         default:
2062             instr_out(data, hw_offset, index, "UNKNOWN\n");
2063             failures++;
2064             index++;
2065             break;
2066         }
2067         fflush(out);
2068     }
2069
2070     return failures;
2071 }
2072
2073 void intel_decode_context_reset(void)
2074 {
2075     saved_s2_set = 0;
2076     saved_s4_set = 1;
2077 }
2078