?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / workbench / libs / mesa / src / gallium / drivers / i915 / i915_debug.c
blobc4eed473e90cd17fe062e6da2d5098d3176833d6
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 }
Mirror of AROS' svn.