src/gallium/drivers/i915/i915_debug.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "i915_reg.h"
  29 #include "i915_context.h"
  30 #include "i915_screen.h"
  31 #include "i915_debug.h"
  32 #include "i915_debug_private.h"
  33 #include "i915_batch.h"
  34 #include "util/u_debug.h"
  35
  36
  37
  38 static const struct debug_named_value debug_options[] = {
  39    {"blit",      DBG_BLIT,      "Print when using the 2d blitter"},
  40    {"emit",      DBG_EMIT,      "State emit information"},
  41    {"atoms",     DBG_ATOMS,     "Print dirty state atoms"},
  42    {"flush",     DBG_FLUSH,     "Flushing information"},
  43    {"texture",   DBG_TEXTURE,   "Texture information"},
  44    {"constants", DBG_CONSTANTS, "Constant buffers"},
  45    DEBUG_NAMED_VALUE_END
  46 };
  47
  48 unsigned i915_debug = 0;
  49
  50 DEBUG_GET_ONCE_FLAGS_OPTION(i915_debug, "I915_DEBUG", debug_options, 0)
  51 DEBUG_GET_ONCE_BOOL_OPTION(i915_no_tiling, "I915_NO_TILING", FALSE)
  52 DEBUG_GET_ONCE_BOOL_OPTION(i915_lie, "I915_LIE", FALSE)
  53 DEBUG_GET_ONCE_BOOL_OPTION(i915_use_blitter, "I915_USE_BLITTER", FALSE)
  54
  55 void i915_debug_init(struct i915_screen *is)
  56 {
  57    i915_debug = debug_get_option_i915_debug();
  58    is->debug.tiling = !debug_get_option_i915_no_tiling();
  59    is->debug.lie = debug_get_option_i915_lie();
  60    is->debug.use_blitter = debug_get_option_i915_use_blitter();
  61 }
  62
  63
  64
  65 /***********************************************************************
  66  * Batchbuffer dumping
  67  */
  68
  69 static void
  70 PRINTF(
  71    struct debug_stream  *stream,
  72    const char           *fmt,
  73                         ... )
  74 {
  75    va_list  args;
  76
  77    va_start( args, fmt );
  78    debug_vprintf( fmt, args );
  79    va_end( args );
  80 }
  81
  82
  83 static boolean debug( struct debug_stream *stream, const char *name, unsigned len )
  84 {
  85    unsigned i;
  86    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
  87
  88    if (len == 0) {
  89       PRINTF(stream, "Error - zero length packet (0x%08x)\n", stream->ptr[0]);
  90       assert(0);
  91       return FALSE;
  92    }
  93
  94    if (stream->print_addresses)
  95       PRINTF(stream, "%08x:  ", stream->offset);
  96
  97
  98    PRINTF(stream, "%s (%d dwords):\n", name, len);
  99    for (i = 0; i < len; i++)
 100       PRINTF(stream, "\t0x%08x\n",  ptr[i]);
 101    PRINTF(stream, "\n");
 102
 103    stream->offset += len * sizeof(unsigned);
 104
 105    return TRUE;
 106 }
 107
 108
 109 static const char *get_prim_name( unsigned val )
 110 {
 111    switch (val & PRIM3D_MASK) {
 112    case PRIM3D_TRILIST: return "TRILIST"; break;
 113    case PRIM3D_TRISTRIP: return "TRISTRIP"; break;
 114    case PRIM3D_TRISTRIP_RVRSE: return "TRISTRIP_RVRSE"; break;
 115    case PRIM3D_TRIFAN: return "TRIFAN"; break;
 116    case PRIM3D_POLY: return "POLY"; break;
 117    case PRIM3D_LINELIST: return "LINELIST"; break;
 118    case PRIM3D_LINESTRIP: return "LINESTRIP"; break;
 119    case PRIM3D_RECTLIST: return "RECTLIST"; break;
 120    case PRIM3D_POINTLIST: return "POINTLIST"; break;
 121    case PRIM3D_DIB: return "DIB"; break;
 122    case PRIM3D_CLEAR_RECT: return "CLEAR_RECT"; break;
 123    case PRIM3D_ZONE_INIT: return "ZONE_INIT"; break;
 124    default: return "????"; break;
 125    }
 126 }
 127
 128 static boolean debug_prim( struct debug_stream *stream, const char *name,
 129                              boolean dump_floats,
 130                              unsigned len )
 131 {
 132    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 133    const char *prim = get_prim_name( ptr[0] );
 134    unsigned i;
 135
 136
 137
 138    PRINTF(stream, "%s %s (%d dwords):\n", name, prim, len);
 139    PRINTF(stream, "\t0x%08x\n",  ptr[0]);
 140    for (i = 1; i < len; i++) {
 141       if (dump_floats)
 142          PRINTF(stream, "\t0x%08x // %f\n",  ptr[i], *(float *)&ptr[i]);
 143       else
 144          PRINTF(stream, "\t0x%08x\n",  ptr[i]);
 145    }
 146
 147
 148    PRINTF(stream, "\n");
 149
 150    stream->offset += len * sizeof(unsigned);
 151
 152    return TRUE;
 153 }
 154
 155
 156
 157
 158 static boolean debug_program( struct debug_stream *stream, const char *name, unsigned len )
 159 {
 160    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 161
 162    if (len == 0) {
 163       PRINTF(stream, "Error - zero length packet (0x%08x)\n", stream->ptr[0]);
 164       assert(0);
 165       return FALSE;
 166    }
 167
 168    if (stream->print_addresses)
 169       PRINTF(stream, "%08x:  ", stream->offset);
 170
 171    PRINTF(stream, "%s (%d dwords):\n", name, len);
 172    i915_disassemble_program( stream, ptr, len );
 173
 174    stream->offset += len * sizeof(unsigned);
 175    return TRUE;
 176 }
 177
 178
 179 static boolean debug_chain( struct debug_stream *stream, const char *name, unsigned len )
 180 {
 181    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 182    unsigned old_offset = stream->offset + len * sizeof(unsigned);
 183    unsigned i;
 184
 185    PRINTF(stream, "%s (%d dwords):\n", name, len);
 186    for (i = 0; i < len; i++)
 187       PRINTF(stream, "\t0x%08x\n",  ptr[i]);
 188
 189    stream->offset = ptr[1] & ~0x3;
 190
 191    if (stream->offset < old_offset)
 192       PRINTF(stream, "\n... skipping backwards from 0x%x --> 0x%x ...\n\n",
 193                    old_offset, stream->offset );
 194    else
 195       PRINTF(stream, "\n... skipping from 0x%x --> 0x%x ...\n\n",
 196                    old_offset, stream->offset );
 197
 198
 199    return TRUE;
 200 }
 201
 202
 203 static boolean debug_variable_length_prim( struct debug_stream *stream )
 204 {
 205    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 206    const char *prim = get_prim_name( ptr[0] );
 207    unsigned i, len;
 208
 209    ushort *idx = (ushort *)(ptr+1);
 210    for (i = 0; idx[i] != 0xffff; i++)
 211       ;
 212
 213    len = 1+(i+2)/2;
 214
 215    PRINTF(stream, "3DPRIM, %s variable length %d indicies (%d dwords):\n", prim, i, len);
 216    for (i = 0; i < len; i++)
 217       PRINTF(stream, "\t0x%08x\n",  ptr[i]);
 218    PRINTF(stream, "\n");
 219
 220    stream->offset += len * sizeof(unsigned);
 221    return TRUE;
 222 }
 223
 224
 225 static void
 226 BITS(
 227    struct debug_stream  *stream,
 228    unsigned             dw,
 229    unsigned             hi,
 230    unsigned             lo,
 231    const char           *fmt,
 232                         ... )
 233 {
 234    va_list  args;
 235    unsigned himask = ~0UL >> (31 - (hi));
 236
 237    PRINTF(stream, "\t\t ");
 238
 239    va_start( args, fmt );
 240    debug_vprintf( fmt, args );
 241    va_end( args );
 242
 243    PRINTF(stream, ": 0x%x\n", ((dw) & himask) >> (lo));
 244 }
 245
 246 #ifdef DEBUG
 247 #define MBZ( dw, hi, lo) do {                                                   \
 248    unsigned x = (dw) >> (lo);                           \
 249    unsigned lomask = (1 << (lo)) - 1;                   \
 250    unsigned himask;                                     \
 251    himask = (1UL << (hi)) - 1;                          \
 252    assert ((x & himask & ~lomask) == 0);        \
 253 } while (0)
 254 #else
 255 #define MBZ( dw, hi, lo) do {                                                   \
 256 } while (0)
 257 #endif
 258
 259 static void
 260 FLAG(
 261    struct debug_stream  *stream,
 262    unsigned             dw,
 263    unsigned             bit,
 264    const char           *fmt,
 265                         ... )
 266 {
 267    if (((dw) >> (bit)) & 1) {
 268       va_list  args;
 269
 270       PRINTF(stream, "\t\t ");
 271
 272       va_start( args, fmt );
 273       debug_vprintf( fmt, args );
 274       va_end( args );
 275
 276       PRINTF(stream, "\n");
 277    }
 278 }
 279
 280 static boolean debug_load_immediate( struct debug_stream *stream,
 281                                        const char *name,
 282                                        unsigned len )
 283 {
 284    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 285    unsigned bits = (ptr[0] >> 4) & 0xff;
 286    unsigned j = 0;
 287
 288    PRINTF(stream, "%s (%d dwords, flags: %x):\n", name, len, bits);
 289    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 290
 291    if (bits & (1<<0)) {
 292       PRINTF(stream, "\t  LIS0: 0x%08x\n", ptr[j]);
 293       PRINTF(stream, "\t vb address: 0x%08x\n", (ptr[j] & ~0x3));
 294       BITS(stream, ptr[j], 0, 0, "vb invalidate disable");
 295       j++;
 296    }
 297    if (bits & (1<<1)) {
 298       PRINTF(stream, "\t  LIS1: 0x%08x\n", ptr[j]);
 299       BITS(stream, ptr[j], 29, 24, "vb dword width");
 300       BITS(stream, ptr[j], 21, 16, "vb dword pitch");
 301       BITS(stream, ptr[j], 15, 0, "vb max index");
 302       j++;
 303    }
 304    if (bits & (1<<2)) {
 305       int i;
 306       PRINTF(stream, "\t  LIS2: 0x%08x\n", ptr[j]);
 307       for (i = 0; i < 8; i++) {
 308          unsigned tc = (ptr[j] >> (i * 4)) & 0xf;
 309          if (tc != 0xf)
 310             BITS(stream, tc, 3, 0, "tex coord %d", i);
 311       }
 312       j++;
 313    }
 314    if (bits & (1<<3)) {
 315       PRINTF(stream, "\t  LIS3: 0x%08x\n", ptr[j]);
 316       j++;
 317    }
 318    if (bits & (1<<4)) {
 319       PRINTF(stream, "\t  LIS4: 0x%08x\n", ptr[j]);
 320       BITS(stream, ptr[j], 31, 23, "point width");
 321       BITS(stream, ptr[j], 22, 19, "line width");
 322       FLAG(stream, ptr[j], 18, "alpha flatshade");
 323       FLAG(stream, ptr[j], 17, "fog flatshade");
 324       FLAG(stream, ptr[j], 16, "spec flatshade");
 325       FLAG(stream, ptr[j], 15, "rgb flatshade");
 326       BITS(stream, ptr[j], 14, 13, "cull mode");
 327       FLAG(stream, ptr[j], 12, "vfmt: point width");
 328       FLAG(stream, ptr[j], 11, "vfmt: specular/fog");
 329       FLAG(stream, ptr[j], 10, "vfmt: rgba");
 330       FLAG(stream, ptr[j], 9, "vfmt: depth offset");
 331       BITS(stream, ptr[j], 8, 6, "vfmt: position (2==xyzw)");
 332       FLAG(stream, ptr[j], 5, "force dflt diffuse");
 333       FLAG(stream, ptr[j], 4, "force dflt specular");
 334       FLAG(stream, ptr[j], 3, "local depth offset enable");
 335       FLAG(stream, ptr[j], 2, "vfmt: fp32 fog coord");
 336       FLAG(stream, ptr[j], 1, "sprite point");
 337       FLAG(stream, ptr[j], 0, "antialiasing");
 338       j++;
 339    }
 340    if (bits & (1<<5)) {
 341       PRINTF(stream, "\t  LIS5: 0x%08x\n", ptr[j]);
 342       BITS(stream, ptr[j], 31, 28, "rgba write disables");
 343       FLAG(stream, ptr[j], 27,     "force dflt point width");
 344       FLAG(stream, ptr[j], 26,     "last pixel enable");
 345       FLAG(stream, ptr[j], 25,     "global z offset enable");
 346       FLAG(stream, ptr[j], 24,     "fog enable");
 347       BITS(stream, ptr[j], 23, 16, "stencil ref");
 348       BITS(stream, ptr[j], 15, 13, "stencil test");
 349       BITS(stream, ptr[j], 12, 10, "stencil fail op");
 350       BITS(stream, ptr[j], 9, 7,   "stencil pass z fail op");
 351       BITS(stream, ptr[j], 6, 4,   "stencil pass z pass op");
 352       FLAG(stream, ptr[j], 3,      "stencil write enable");
 353       FLAG(stream, ptr[j], 2,      "stencil test enable");
 354       FLAG(stream, ptr[j], 1,      "color dither enable");
 355       FLAG(stream, ptr[j], 0,      "logiop enable");
 356       j++;
 357    }
 358    if (bits & (1<<6)) {
 359       PRINTF(stream, "\t  LIS6: 0x%08x\n", ptr[j]);
 360       FLAG(stream, ptr[j], 31,      "alpha test enable");
 361       BITS(stream, ptr[j], 30, 28,  "alpha func");
 362       BITS(stream, ptr[j], 27, 20,  "alpha ref");
 363       FLAG(stream, ptr[j], 19,      "depth test enable");
 364       BITS(stream, ptr[j], 18, 16,  "depth func");
 365       FLAG(stream, ptr[j], 15,      "blend enable");
 366       BITS(stream, ptr[j], 14, 12,  "blend func");
 367       BITS(stream, ptr[j], 11, 8,   "blend src factor");
 368       BITS(stream, ptr[j], 7,  4,   "blend dst factor");
 369       FLAG(stream, ptr[j], 3,       "depth write enable");
 370       FLAG(stream, ptr[j], 2,       "color write enable");
 371       BITS(stream, ptr[j], 1,  0,   "provoking vertex");
 372       j++;
 373    }
 374
 375
 376    PRINTF(stream, "\n");
 377
 378    assert(j == len);
 379
 380    stream->offset += len * sizeof(unsigned);
 381
 382    return TRUE;
 383 }
 384
 385
 386
 387 static boolean debug_load_indirect( struct debug_stream *stream,
 388                                       const char *name,
 389                                       unsigned len )
 390 {
 391    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 392    unsigned bits = (ptr[0] >> 8) & 0x3f;
 393    unsigned i, j = 0;
 394
 395    PRINTF(stream, "%s (%d dwords):\n", name, len);
 396    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 397
 398    for (i = 0; i < 6; i++) {
 399       if (bits & (1<<i)) {
 400          switch (1<<(8+i)) {
 401          case LI0_STATE_STATIC_INDIRECT:
 402             PRINTF(stream, "        STATIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 403             PRINTF(stream, "                0x%08x\n", ptr[j++]);
 404             break;
 405          case LI0_STATE_DYNAMIC_INDIRECT:
 406             PRINTF(stream, "       DYNAMIC: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 407             break;
 408          case LI0_STATE_SAMPLER:
 409             PRINTF(stream, "       SAMPLER: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 410             PRINTF(stream, "                0x%08x\n", ptr[j++]);
 411             break;
 412          case LI0_STATE_MAP:
 413             PRINTF(stream, "           MAP: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 414             PRINTF(stream, "                0x%08x\n", ptr[j++]);
 415             break;
 416          case LI0_STATE_PROGRAM:
 417             PRINTF(stream, "       PROGRAM: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 418             PRINTF(stream, "                0x%08x\n", ptr[j++]);
 419             break;
 420          case LI0_STATE_CONSTANTS:
 421             PRINTF(stream, "     CONSTANTS: 0x%08x | %x\n", ptr[j]&~3, ptr[j]&3); j++;
 422             PRINTF(stream, "                0x%08x\n", ptr[j++]);
 423             break;
 424          default:
 425             assert(0);
 426             break;
 427          }
 428       }
 429    }
 430
 431    if (bits == 0) {
 432       PRINTF(stream, "\t  DUMMY: 0x%08x\n", ptr[j++]);
 433    }
 434
 435    PRINTF(stream, "\n");
 436
 437
 438    assert(j == len);
 439
 440    stream->offset += len * sizeof(unsigned);
 441
 442    return TRUE;
 443 }
 444
 445 static void BR13( struct debug_stream *stream,
 446                   unsigned val )
 447 {
 448    PRINTF(stream, "\t0x%08x\n",  val);
 449    FLAG(stream, val, 30, "clipping enable");
 450    BITS(stream, val, 25, 24, "color depth (3==32bpp)");
 451    BITS(stream, val, 23, 16, "raster op");
 452    BITS(stream, val, 15, 0,  "dest pitch");
 453 }
 454
 455
 456 static void BR22( struct debug_stream *stream,
 457                   unsigned val )
 458 {
 459    PRINTF(stream, "\t0x%08x\n",  val);
 460    BITS(stream, val, 31, 16, "dest y1");
 461    BITS(stream, val, 15, 0,  "dest x1");
 462 }
 463
 464 static void BR23( struct debug_stream *stream,
 465                   unsigned val )
 466 {
 467    PRINTF(stream, "\t0x%08x\n",  val);
 468    BITS(stream, val, 31, 16, "dest y2");
 469    BITS(stream, val, 15, 0,  "dest x2");
 470 }
 471
 472 static void BR09( struct debug_stream *stream,
 473                   unsigned val )
 474 {
 475    PRINTF(stream, "\t0x%08x -- dest address\n",  val);
 476 }
 477
 478 static void BR26( struct debug_stream *stream,
 479                   unsigned val )
 480 {
 481    PRINTF(stream, "\t0x%08x\n",  val);
 482    BITS(stream, val, 31, 16, "src y1");
 483    BITS(stream, val, 15, 0,  "src x1");
 484 }
 485
 486 static void BR11( struct debug_stream *stream,
 487                   unsigned val )
 488 {
 489    PRINTF(stream, "\t0x%08x\n",  val);
 490    BITS(stream, val, 15, 0,  "src pitch");
 491 }
 492
 493 static void BR12( struct debug_stream *stream,
 494                   unsigned val )
 495 {
 496    PRINTF(stream, "\t0x%08x -- src address\n",  val);
 497 }
 498
 499 static void BR16( struct debug_stream *stream,
 500                   unsigned val )
 501 {
 502    PRINTF(stream, "\t0x%08x -- color\n",  val);
 503 }
 504
 505 static boolean debug_copy_blit( struct debug_stream *stream,
 506                                   const char *name,
 507                                   unsigned len )
 508 {
 509    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 510    int j = 0;
 511
 512    PRINTF(stream, "%s (%d dwords):\n", name, len);
 513    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 514
 515    BR13(stream, ptr[j++]);
 516    BR22(stream, ptr[j++]);
 517    BR23(stream, ptr[j++]);
 518    BR09(stream, ptr[j++]);
 519    BR26(stream, ptr[j++]);
 520    BR11(stream, ptr[j++]);
 521    BR12(stream, ptr[j++]);
 522
 523    stream->offset += len * sizeof(unsigned);
 524    assert(j == len);
 525    return TRUE;
 526 }
 527
 528 static boolean debug_color_blit( struct debug_stream *stream,
 529                                   const char *name,
 530                                   unsigned len )
 531 {
 532    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 533    int j = 0;
 534
 535    PRINTF(stream, "%s (%d dwords):\n", name, len);
 536    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 537
 538    BR13(stream, ptr[j++]);
 539    BR22(stream, ptr[j++]);
 540    BR23(stream, ptr[j++]);
 541    BR09(stream, ptr[j++]);
 542    BR16(stream, ptr[j++]);
 543
 544    stream->offset += len * sizeof(unsigned);
 545    assert(j == len);
 546    return TRUE;
 547 }
 548
 549 static boolean debug_modes4( struct debug_stream *stream,
 550                                   const char *name,
 551                                   unsigned len )
 552 {
 553    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 554    int j = 0;
 555
 556    PRINTF(stream, "%s (%d dwords):\n", name, len);
 557    PRINTF(stream, "\t0x%08x\n",  ptr[j]);
 558    BITS(stream, ptr[j], 21, 18, "logicop func");
 559    FLAG(stream, ptr[j], 17, "stencil test mask modify-enable");
 560    FLAG(stream, ptr[j], 16, "stencil write mask modify-enable");
 561    BITS(stream, ptr[j], 15, 8, "stencil test mask");
 562    BITS(stream, ptr[j], 7, 0,  "stencil write mask");
 563    j++;
 564
 565    stream->offset += len * sizeof(unsigned);
 566    assert(j == len);
 567    return TRUE;
 568 }
 569
 570 static boolean debug_map_state( struct debug_stream *stream,
 571                                   const char *name,
 572                                   unsigned len )
 573 {
 574    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 575    unsigned j = 0;
 576
 577    PRINTF(stream, "%s (%d dwords):\n", name, len);
 578    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 579
 580    {
 581       PRINTF(stream, "\t0x%08x\n",  ptr[j]);
 582       BITS(stream, ptr[j], 15, 0,   "map mask");
 583       j++;
 584    }
 585
 586    while (j < len) {
 587       {
 588          PRINTF(stream, "\t  TMn.0: 0x%08x\n", ptr[j]);
 589          PRINTF(stream, "\t map address: 0x%08x\n", (ptr[j] & ~0x3));
 590          FLAG(stream, ptr[j], 1, "vertical line stride");
 591          FLAG(stream, ptr[j], 0, "vertical line stride offset");
 592          j++;
 593       }
 594
 595       {
 596          PRINTF(stream, "\t  TMn.1: 0x%08x\n", ptr[j]);
 597          BITS(stream, ptr[j], 31, 21, "height");
 598          BITS(stream, ptr[j], 20, 10, "width");
 599          BITS(stream, ptr[j], 9, 7, "surface format");
 600          BITS(stream, ptr[j], 6, 3, "texel format");
 601          FLAG(stream, ptr[j], 2, "use fence regs");
 602          FLAG(stream, ptr[j], 1, "tiled surface");
 603          FLAG(stream, ptr[j], 0, "tile walk ymajor");
 604          j++;
 605       }
 606       {
 607          PRINTF(stream, "\t  TMn.2: 0x%08x\n", ptr[j]);
 608          BITS(stream, ptr[j], 31, 21, "dword pitch");
 609          BITS(stream, ptr[j], 20, 15, "cube face enables");
 610          BITS(stream, ptr[j], 14, 9, "max lod");
 611          FLAG(stream, ptr[j], 8,     "mip layout right");
 612          BITS(stream, ptr[j], 7, 0, "depth");
 613          j++;
 614       }
 615    }
 616
 617    stream->offset += len * sizeof(unsigned);
 618    assert(j == len);
 619    return TRUE;
 620 }
 621
 622 static boolean debug_sampler_state( struct debug_stream *stream,
 623                                   const char *name,
 624                                   unsigned len )
 625 {
 626    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 627    unsigned j = 0;
 628
 629    PRINTF(stream, "%s (%d dwords):\n", name, len);
 630    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 631
 632    {
 633       PRINTF(stream, "\t0x%08x\n",  ptr[j]);
 634       BITS(stream, ptr[j], 15, 0,   "sampler mask");
 635       j++;
 636    }
 637
 638    while (j < len) {
 639       {
 640          PRINTF(stream, "\t  TSn.0: 0x%08x\n", ptr[j]);
 641          FLAG(stream, ptr[j], 31, "reverse gamma");
 642          FLAG(stream, ptr[j], 30, "planar to packed");
 643          FLAG(stream, ptr[j], 29, "yuv->rgb");
 644          BITS(stream, ptr[j], 28, 27, "chromakey index");
 645          BITS(stream, ptr[j], 26, 22, "base mip level");
 646          BITS(stream, ptr[j], 21, 20, "mip mode filter");
 647          BITS(stream, ptr[j], 19, 17, "mag mode filter");
 648          BITS(stream, ptr[j], 16, 14, "min mode filter");
 649          BITS(stream, ptr[j], 13, 5,  "lod bias (s4.4)");
 650          FLAG(stream, ptr[j], 4,      "shadow enable");
 651          FLAG(stream, ptr[j], 3,      "max-aniso-4");
 652          BITS(stream, ptr[j], 2, 0,   "shadow func");
 653          j++;
 654       }
 655
 656       {
 657          PRINTF(stream, "\t  TSn.1: 0x%08x\n", ptr[j]);
 658          BITS(stream, ptr[j], 31, 24, "min lod");
 659          MBZ( ptr[j], 23, 18 );
 660          FLAG(stream, ptr[j], 17,     "kill pixel enable");
 661          FLAG(stream, ptr[j], 16,     "keyed tex filter mode");
 662          FLAG(stream, ptr[j], 15,     "chromakey enable");
 663          BITS(stream, ptr[j], 14, 12, "tcx wrap mode");
 664          BITS(stream, ptr[j], 11, 9,  "tcy wrap mode");
 665          BITS(stream, ptr[j], 8,  6,  "tcz wrap mode");
 666          FLAG(stream, ptr[j], 5,      "normalized coords");
 667          BITS(stream, ptr[j], 4,  1,  "map (surface) index");
 668          FLAG(stream, ptr[j], 0,      "EAST deinterlacer enable");
 669          j++;
 670       }
 671       {
 672          PRINTF(stream, "\t  TSn.2: 0x%08x  (default color)\n", ptr[j]);
 673          j++;
 674       }
 675    }
 676
 677    stream->offset += len * sizeof(unsigned);
 678    assert(j == len);
 679    return TRUE;
 680 }
 681
 682 static boolean debug_dest_vars( struct debug_stream *stream,
 683                                   const char *name,
 684                                   unsigned len )
 685 {
 686    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 687    int j = 0;
 688
 689    PRINTF(stream, "%s (%d dwords):\n", name, len);
 690    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 691
 692    {
 693       PRINTF(stream, "\t0x%08x\n",  ptr[j]);
 694       FLAG(stream, ptr[j], 31,     "early classic ztest");
 695       FLAG(stream, ptr[j], 30,     "opengl tex default color");
 696       FLAG(stream, ptr[j], 29,     "bypass iz");
 697       FLAG(stream, ptr[j], 28,     "lod preclamp");
 698       BITS(stream, ptr[j], 27, 26, "dither pattern");
 699       FLAG(stream, ptr[j], 25,     "linear gamma blend");
 700       FLAG(stream, ptr[j], 24,     "debug dither");
 701       BITS(stream, ptr[j], 23, 20, "dstorg x");
 702       BITS(stream, ptr[j], 19, 16, "dstorg y");
 703       MBZ (ptr[j], 15, 15 );
 704       BITS(stream, ptr[j], 14, 12, "422 write select");
 705       BITS(stream, ptr[j], 11, 8,  "cbuf format");
 706       BITS(stream, ptr[j], 3, 2,   "zbuf format");
 707       FLAG(stream, ptr[j], 1,      "vert line stride");
 708       FLAG(stream, ptr[j], 1,      "vert line stride offset");
 709       j++;
 710    }
 711
 712    stream->offset += len * sizeof(unsigned);
 713    assert(j == len);
 714    return TRUE;
 715 }
 716
 717 static boolean debug_buf_info( struct debug_stream *stream,
 718                                   const char *name,
 719                                   unsigned len )
 720 {
 721    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 722    int j = 0;
 723
 724    PRINTF(stream, "%s (%d dwords):\n", name, len);
 725    PRINTF(stream, "\t0x%08x\n",  ptr[j++]);
 726
 727    {
 728       PRINTF(stream, "\t0x%08x\n",  ptr[j]);
 729       BITS(stream, ptr[j], 28, 28, "aux buffer id");
 730       BITS(stream, ptr[j], 27, 24, "buffer id (7=depth, 3=back)");
 731       FLAG(stream, ptr[j], 23,     "use fence regs");
 732       FLAG(stream, ptr[j], 22,     "tiled surface");
 733       FLAG(stream, ptr[j], 21,     "tile walk ymajor");
 734       MBZ (ptr[j], 20, 14);
 735       BITS(stream, ptr[j], 13, 2,  "dword pitch");
 736       MBZ (ptr[j], 2,  0);
 737       j++;
 738    }
 739
 740    PRINTF(stream, "\t0x%08x -- buffer base address\n",  ptr[j++]);
 741
 742    stream->offset += len * sizeof(unsigned);
 743    assert(j == len);
 744    return TRUE;
 745 }
 746
 747 static boolean i915_debug_packet( struct debug_stream *stream )
 748 {
 749    unsigned *ptr = (unsigned *)(stream->ptr + stream->offset);
 750    unsigned cmd = *ptr;
 751
 752    switch (((cmd >> 29) & 0x7)) {
 753    case 0x0:
 754       switch ((cmd >> 23) & 0x3f) {
 755       case 0x0:
 756          return debug(stream, "MI_NOOP", 1);
 757       case 0x3:
 758          return debug(stream, "MI_WAIT_FOR_EVENT", 1);
 759       case 0x4:
 760          return debug(stream, "MI_FLUSH", 1);
 761       case 0xA:
 762          debug(stream, "MI_BATCH_BUFFER_END", 1);
 763          return FALSE;
 764       case 0x22:
 765          return debug(stream, "MI_LOAD_REGISTER_IMM", 3);
 766       case 0x31:
 767          return debug_chain(stream, "MI_BATCH_BUFFER_START", 2);
 768       default:
 769          (void)debug(stream, "UNKNOWN 0x0 case!", 1);
 770          assert(0);
 771          break;
 772       }
 773       break;
 774    case 0x1:
 775       (void) debug(stream, "UNKNOWN 0x1 case!", 1);
 776       assert(0);
 777       break;
 778    case 0x2:
 779       switch ((cmd >> 22) & 0xff) {
 780       case 0x50:
 781          return debug_color_blit(stream, "XY_COLOR_BLT", (cmd & 0xff) + 2);
 782       case 0x53:
 783          return debug_copy_blit(stream, "XY_SRC_COPY_BLT", (cmd & 0xff) + 2);
 784       default:
 785          return debug(stream, "blit command", (cmd & 0xff) + 2);
 786       }
 787       break;
 788    case 0x3:
 789       switch ((cmd >> 24) & 0x1f) {
 790       case 0x6:
 791          return debug(stream, "3DSTATE_ANTI_ALIASING", 1);
 792       case 0x7:
 793          return debug(stream, "3DSTATE_RASTERIZATION_RULES", 1);
 794       case 0x8:
 795          return debug(stream, "3DSTATE_BACKFACE_STENCIL_OPS", 2);
 796       case 0x9:
 797          return debug(stream, "3DSTATE_BACKFACE_STENCIL_MASKS", 1);
 798       case 0xb:
 799          return debug(stream, "3DSTATE_INDEPENDENT_ALPHA_BLEND", 1);
 800       case 0xc:
 801          return debug(stream, "3DSTATE_MODES5", 1);
 802       case 0xd:
 803          return debug_modes4(stream, "3DSTATE_MODES4", 1);
 804       case 0x15:
 805          return debug(stream, "3DSTATE_FOG_COLOR", 1);
 806       case 0x16:
 807          return debug(stream, "3DSTATE_COORD_SET_BINDINGS", 1);
 808       case 0x1c:
 809          /* 3DState16NP */
 810          switch((cmd >> 19) & 0x1f) {
 811          case 0x10:
 812             return debug(stream, "3DSTATE_SCISSOR_ENABLE", 1);
 813          case 0x11:
 814             return debug(stream, "3DSTATE_DEPTH_SUBRECTANGLE_DISABLE", 1);
 815          default:
 816             (void) debug(stream, "UNKNOWN 0x1c case!", 1);
 817             assert(0);
 818             break;
 819          }
 820          break;
 821       case 0x1d:
 822          /* 3DStateMW */
 823          switch ((cmd >> 16) & 0xff) {
 824          case 0x0:
 825             return debug_map_state(stream, "3DSTATE_MAP_STATE", (cmd & 0x1f) + 2);
 826          case 0x1:
 827             return debug_sampler_state(stream, "3DSTATE_SAMPLER_STATE", (cmd & 0x1f) + 2);
 828          case 0x4:
 829             return debug_load_immediate(stream, "3DSTATE_LOAD_STATE_IMMEDIATE", (cmd & 0xf) + 2);
 830          case 0x5:
 831             return debug_program(stream, "3DSTATE_PIXEL_SHADER_PROGRAM", (cmd & 0x1ff) + 2);
 832          case 0x6:
 833             return debug(stream, "3DSTATE_PIXEL_SHADER_CONSTANTS", (cmd & 0xff) + 2);
 834          case 0x7:
 835             return debug_load_indirect(stream, "3DSTATE_LOAD_INDIRECT", (cmd & 0xff) + 2);
 836          case 0x80:
 837             return debug(stream, "3DSTATE_DRAWING_RECTANGLE", (cmd & 0xffff) + 2);
 838          case 0x81:
 839             return debug(stream, "3DSTATE_SCISSOR_RECTANGLE", (cmd & 0xffff) + 2);
 840          case 0x83:
 841             return debug(stream, "3DSTATE_SPAN_STIPPLE", (cmd & 0xffff) + 2);
 842          case 0x85:
 843             return debug_dest_vars(stream, "3DSTATE_DEST_BUFFER_VARS", (cmd & 0xffff) + 2);
 844          case 0x88:
 845             return debug(stream, "3DSTATE_CONSTANT_BLEND_COLOR", (cmd & 0xffff) + 2);
 846          case 0x89:
 847             return debug(stream, "3DSTATE_FOG_MODE", (cmd & 0xffff) + 2);
 848          case 0x8e:
 849             return debug_buf_info(stream, "3DSTATE_BUFFER_INFO", (cmd & 0xffff) + 2);
 850          case 0x97:
 851             return debug(stream, "3DSTATE_DEPTH_OFFSET_SCALE", (cmd & 0xffff) + 2);
 852          case 0x98:
 853             return debug(stream, "3DSTATE_DEFAULT_Z", (cmd & 0xffff) + 2);
 854          case 0x99:
 855             return debug(stream, "3DSTATE_DEFAULT_DIFFUSE", (cmd & 0xffff) + 2);
 856          case 0x9a:
 857             return debug(stream, "3DSTATE_DEFAULT_SPECULAR", (cmd & 0xffff) + 2);
 858          case 0x9c:
 859             return debug(stream, "3DSTATE_CLEAR_PARAMETERS", (cmd & 0xffff) + 2);
 860          default:
 861             assert(0);
 862             return 0;
 863          }
 864          break;
 865       case 0x1e:
 866          if (cmd & (1 << 23))
 867             return debug(stream, "???", (cmd & 0xffff) + 1);
 868          else
 869             return debug(stream, "", 1);
 870          break;
 871       case 0x1f:
 872          if ((cmd & (1 << 23)) == 0)
 873             return debug_prim(stream, "3DPRIM (inline)", 1, (cmd & 0x1ffff) + 2);
 874          else if (cmd & (1 << 17))
 875          {
 876             if ((cmd & 0xffff) == 0)
 877                return debug_variable_length_prim(stream);
 878             else
 879                return debug_prim(stream, "3DPRIM (indexed)", 0, (((cmd & 0xffff) + 1) / 2) + 1);
 880          }
 881          else
 882             return debug_prim(stream, "3DPRIM  (indirect sequential)", 0, 2);
 883          break;
 884       default:
 885          return debug(stream, "", 0);
 886       }
 887       break;
 888    default:
 889       assert(0);
 890       return 0;
 891    }
 892
 893    assert(0);
 894    return 0;
 895 }
 896
 897
 898
 899 void
 900 i915_dump_batchbuffer( struct i915_winsys_batchbuffer *batch )
 901 {
 902    struct debug_stream stream;
 903    unsigned *start = (unsigned*)batch->map;
 904    unsigned *end = (unsigned*)batch->ptr;
 905    unsigned long bytes = (unsigned long) (end - start) * 4;
 906    boolean done = FALSE;
 907
 908    stream.offset = 0;
 909    stream.ptr = (char *)start;
 910    stream.print_addresses = 0;
 911
 912    if (!start || !end) {
 913       debug_printf( "\n\nBATCH: ???\n");
 914       return;
 915    }
 916
 917    debug_printf( "\n\nBATCH: (%d)\n", (int)bytes / 4);
 918
 919    while (!done &&
 920           stream.offset < bytes)
 921    {
 922       if (!i915_debug_packet( &stream ))
 923          break;
 924
 925       assert(stream.offset <= bytes &&
 926              stream.offset >= 0);
 927    }
 928
 929    debug_printf( "END-BATCH\n\n\n");
 930 }
 931
 932
 933
 934 /***********************************************************************
 935  * Dirty state atom dumping
 936  */
 937
 938 void
 939 i915_dump_dirty(struct i915_context *i915, const char *func)
 940 {
 941    struct {
 942       unsigned dirty;
 943       const char *name;
 944    } l[] = {
 945       {I915_NEW_VIEWPORT,      "viewport"},
 946       {I915_NEW_RASTERIZER,    "rasterizer"},
 947       {I915_NEW_FS,            "fs"},
 948       {I915_NEW_BLEND,         "blend"},
 949       {I915_NEW_CLIP,          "clip"},
 950       {I915_NEW_SCISSOR,       "scissor"},
 951       {I915_NEW_STIPPLE,       "stipple"},
 952       {I915_NEW_FRAMEBUFFER,   "framebuffer"},
 953       {I915_NEW_ALPHA_TEST,    "alpha_test"},
 954       {I915_NEW_DEPTH_STENCIL, "depth_stencil"},
 955       {I915_NEW_SAMPLER,       "sampler"},
 956       {I915_NEW_SAMPLER_VIEW,  "sampler_view"},
 957       {I915_NEW_VS_CONSTANTS,  "vs_const"},
 958       {I915_NEW_FS_CONSTANTS,  "fs_const"},
 959       {I915_NEW_VBO,           "vbo"},
 960       {I915_NEW_VS,            "vs"},
 961       {0, NULL},
 962    };
 963    int i;
 964
 965    debug_printf("%s: ", func);
 966    for (i = 0; l[i].name; i++)
 967       if (i915->dirty & l[i].dirty)
 968          debug_printf("%s ", l[i].name);
 969    debug_printf("\n");
 970 }
 971
 972 void
 973 i915_dump_hardware_dirty(struct i915_context *i915, const char *func)
 974 {
 975    struct {
 976       unsigned dirty;
 977       const char *name;
 978    } l[] = {
 979       {I915_HW_STATIC,    "static"},
 980       {I915_HW_DYNAMIC,   "dynamic"},
 981       {I915_HW_SAMPLER,   "sampler"},
 982       {I915_HW_MAP,       "map"},
 983       {I915_HW_PROGRAM,   "program"},
 984       {I915_HW_CONSTANTS, "constants"},
 985       {I915_HW_IMMEDIATE, "immediate"},
 986       {I915_HW_INVARIANT, "invariant"},
 987       {0, NULL},
 988    };
 989    int i;
 990
 991    debug_printf("%s: ", func);
 992    for (i = 0; l[i].name; i++)
 993       if (i915->hardware_dirty & l[i].dirty)
 994          debug_printf("%s ", l[i].name);
 995    debug_printf("\n");
 996 }