2 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
4 The Weather Channel (TM) funded Tungsten Graphics to develop the
5 initial release of the Radeon 8500 driver under the XFree86 license.
6 This notice must be preserved.
8 Permission is hereby granted, free of charge, to any person obtaining
9 a copy of this software and associated documentation files (the
10 "Software"), to deal in the Software without restriction, including
11 without limitation the rights to use, copy, modify, merge, publish,
12 distribute, sublicense, and/or sell copies of the Software, and to
13 permit persons to whom the Software is furnished to do so, subject to
14 the following conditions:
16 The above copyright notice and this permission notice (including the
17 next paragraph) shall be included in all copies or substantial
18 portions of the Software.
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
33 * \author Keith Whitwell <keith@tungstengraphics.com>
36 #include "main/glheader.h"
37 #include "main/mtypes.h"
38 #include "main/colormac.h"
39 #include "main/imports.h"
40 #include "main/macros.h"
41 #include "main/image.h"
43 #include "swrast_setup/swrast_setup.h"
44 #include "math/m_translate.h"
46 #include "tnl/t_context.h"
48 #include "r300_context.h"
49 #include "radeon_ioctl.h"
50 #include "r300_state.h"
51 #include "r300_emit.h"
52 #include "r300_ioctl.h"
58 #if SWIZZLE_X != R300_INPUT_ROUTE_SELECT_X || \
59 SWIZZLE_Y != R300_INPUT_ROUTE_SELECT_Y || \
60 SWIZZLE_Z != R300_INPUT_ROUTE_SELECT_Z || \
61 SWIZZLE_W != R300_INPUT_ROUTE_SELECT_W || \
62 SWIZZLE_ZERO != R300_INPUT_ROUTE_SELECT_ZERO || \
63 SWIZZLE_ONE != R300_INPUT_ROUTE_SELECT_ONE
64 #error Cannot change these!
67 #define DEBUG_ALL DEBUG_VERTS
69 #if defined(USE_X86_ASM)
70 #define COPY_DWORDS( dst, src, nr ) \
73 __asm__ __volatile__( "rep ; movsl" \
74 : "=%c" (__tmp), "=D" (dst), "=S" (__tmp) \
80 #define COPY_DWORDS( dst, src, nr ) \
83 for ( j = 0 ; j < nr ; j++ ) \
84 dst[j] = ((int *)src)[j]; \
89 static void r300EmitVec4(GLcontext
* ctx
, struct r300_dma_region
*rvb
,
90 GLvoid
* data
, int stride
, int count
)
93 int *out
= (int *)(rvb
->address
+ rvb
->start
);
95 if (RADEON_DEBUG
& DEBUG_VERTS
)
96 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
97 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
100 COPY_DWORDS(out
, data
, count
);
102 for (i
= 0; i
< count
; i
++) {
103 out
[0] = *(int *)data
;
109 static void r300EmitVec8(GLcontext
* ctx
, struct r300_dma_region
*rvb
,
110 GLvoid
* data
, int stride
, int count
)
113 int *out
= (int *)(rvb
->address
+ rvb
->start
);
115 if (RADEON_DEBUG
& DEBUG_VERTS
)
116 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
117 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
120 COPY_DWORDS(out
, data
, count
* 2);
122 for (i
= 0; i
< count
; i
++) {
123 out
[0] = *(int *)data
;
124 out
[1] = *(int *)(data
+ 4);
130 static void r300EmitVec12(GLcontext
* ctx
, struct r300_dma_region
*rvb
,
131 GLvoid
* data
, int stride
, int count
)
134 int *out
= (int *)(rvb
->address
+ rvb
->start
);
136 if (RADEON_DEBUG
& DEBUG_VERTS
)
137 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
138 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
141 COPY_DWORDS(out
, data
, count
* 3);
143 for (i
= 0; i
< count
; i
++) {
144 out
[0] = *(int *)data
;
145 out
[1] = *(int *)(data
+ 4);
146 out
[2] = *(int *)(data
+ 8);
152 static void r300EmitVec16(GLcontext
* ctx
, struct r300_dma_region
*rvb
,
153 GLvoid
* data
, int stride
, int count
)
156 int *out
= (int *)(rvb
->address
+ rvb
->start
);
158 if (RADEON_DEBUG
& DEBUG_VERTS
)
159 fprintf(stderr
, "%s count %d stride %d out %p data %p\n",
160 __FUNCTION__
, count
, stride
, (void *)out
, (void *)data
);
163 COPY_DWORDS(out
, data
, count
* 4);
165 for (i
= 0; i
< count
; i
++) {
166 out
[0] = *(int *)data
;
167 out
[1] = *(int *)(data
+ 4);
168 out
[2] = *(int *)(data
+ 8);
169 out
[3] = *(int *)(data
+ 12);
175 static void r300EmitVec(GLcontext
* ctx
, struct r300_dma_region
*rvb
,
176 GLvoid
* data
, int size
, int stride
, int count
)
178 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
181 r300AllocDmaRegion(rmesa
, rvb
, size
* 4, 4);
183 rvb
->aos_offset
= GET_START(rvb
);
186 r300AllocDmaRegion(rmesa
, rvb
, size
* count
* 4, 4);
187 rvb
->aos_offset
= GET_START(rvb
);
188 rvb
->aos_stride
= size
;
193 r300EmitVec4(ctx
, rvb
, data
, stride
, count
);
196 r300EmitVec8(ctx
, rvb
, data
, stride
, count
);
199 r300EmitVec12(ctx
, rvb
, data
, stride
, count
);
202 r300EmitVec16(ctx
, rvb
, data
, stride
, count
);
210 #define DW_SIZE(x) ((inputs[tab[(x)]] << R300_DST_VEC_LOC_SHIFT) | \
211 (attribptr[tab[(x)]]->size - 1) << R300_DATA_TYPE_0_SHIFT)
213 GLuint
r300VAPInputRoute0(uint32_t * dst
, GLvector4f
** attribptr
,
214 int *inputs
, GLint
* tab
, GLuint nr
)
218 /* type, inputs, stop bit, size */
219 for (i
= 0; i
< nr
; i
+= 2) {
220 /* make sure input is valid, would lockup the gpu */
221 assert(inputs
[tab
[i
]] != -1);
222 dw
= (R300_SIGNED
| DW_SIZE(i
));
224 dw
|= R300_LAST_VEC
<< R300_DATA_TYPE_0_SHIFT
;
226 assert(inputs
[tab
[i
+ 1]] != -1);
228 DW_SIZE(i
+ 1)) << R300_DATA_TYPE_1_SHIFT
;
230 dw
|= R300_LAST_VEC
<< R300_DATA_TYPE_1_SHIFT
;
236 return (nr
+ 1) >> 1;
239 static GLuint
r300VAPInputRoute1Swizzle(int swizzle
[4])
241 return (swizzle
[0] << R300_SWIZZLE_SELECT_X_SHIFT
) |
242 (swizzle
[1] << R300_SWIZZLE_SELECT_Y_SHIFT
) |
243 (swizzle
[2] << R300_SWIZZLE_SELECT_Z_SHIFT
) |
244 (swizzle
[3] << R300_SWIZZLE_SELECT_W_SHIFT
);
247 GLuint
r300VAPInputRoute1(uint32_t * dst
, int swizzle
[][4], GLuint nr
)
251 for (i
= 0; i
< nr
; i
+= 2) {
252 dw
= (r300VAPInputRoute1Swizzle(swizzle
[i
]) |
253 ((R300_WRITE_ENA_X
| R300_WRITE_ENA_Y
|
254 R300_WRITE_ENA_Z
| R300_WRITE_ENA_W
) << R300_WRITE_ENA_SHIFT
)) << R300_SWIZZLE0_SHIFT
;
256 dw
|= (r300VAPInputRoute1Swizzle(swizzle
[i
+ 1]) |
257 ((R300_WRITE_ENA_X
| R300_WRITE_ENA_Y
|
258 R300_WRITE_ENA_Z
| R300_WRITE_ENA_W
) << R300_WRITE_ENA_SHIFT
)) << R300_SWIZZLE1_SHIFT
;
263 return (nr
+ 1) >> 1;
266 GLuint
r300VAPInputCntl0(GLcontext
* ctx
, GLuint InputsRead
)
268 /* No idea what this value means. I have seen other values written to
269 * this register... */
273 GLuint
r300VAPInputCntl1(GLcontext
* ctx
, GLuint InputsRead
)
275 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
278 if (InputsRead
& (1 << VERT_ATTRIB_POS
))
279 vic_1
|= R300_INPUT_CNTL_POS
;
281 if (InputsRead
& (1 << VERT_ATTRIB_NORMAL
))
282 vic_1
|= R300_INPUT_CNTL_NORMAL
;
284 if (InputsRead
& (1 << VERT_ATTRIB_COLOR0
))
285 vic_1
|= R300_INPUT_CNTL_COLOR
;
287 rmesa
->state
.texture
.tc_count
= 0;
288 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++)
289 if (InputsRead
& (1 << (VERT_ATTRIB_TEX0
+ i
))) {
290 rmesa
->state
.texture
.tc_count
++;
291 vic_1
|= R300_INPUT_CNTL_TC0
<< i
;
297 GLuint
r300VAPOutputCntl0(GLcontext
* ctx
, GLuint OutputsWritten
)
301 if (OutputsWritten
& (1 << VERT_RESULT_HPOS
))
302 ret
|= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
;
304 if (OutputsWritten
& (1 << VERT_RESULT_COL0
))
305 ret
|= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT
;
307 if (OutputsWritten
& (1 << VERT_RESULT_COL1
))
308 ret
|= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT
;
310 if (OutputsWritten
& (1 << VERT_RESULT_BFC0
)
311 || OutputsWritten
& (1 << VERT_RESULT_BFC1
))
313 R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT
|
314 R300_VAP_OUTPUT_VTX_FMT_0__COLOR_2_PRESENT
|
315 R300_VAP_OUTPUT_VTX_FMT_0__COLOR_3_PRESENT
;
317 if (OutputsWritten
& (1 << VERT_RESULT_PSIZ
))
318 ret
|= R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT
;
323 GLuint
r300VAPOutputCntl1(GLcontext
* ctx
, GLuint OutputsWritten
)
325 GLuint i
, ret
= 0, first_free_texcoord
= 0;
327 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
328 if (OutputsWritten
& (1 << (VERT_RESULT_TEX0
+ i
))) {
329 ret
|= (4 << (3 * i
));
330 ++first_free_texcoord
;
334 if (OutputsWritten
& (1 << VERT_RESULT_FOGC
)) {
335 if (first_free_texcoord
> 8) {
336 fprintf(stderr
, "\tout of free texcoords to write fog coord\n");
339 ret
|= 4 << (3 * first_free_texcoord
);
345 /* Emit vertex data to GART memory
346 * Route inputs to the vertex processor
347 * This function should never return R300_FALLBACK_TCL when using software tcl.
349 int r300EmitArrays(GLcontext
* ctx
)
351 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
352 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
353 struct vertex_buffer
*vb
= &tnl
->vb
;
355 GLuint count
= vb
->Count
;
357 GLuint InputsRead
= 0, OutputsWritten
= 0;
359 int vir_inputs
[VERT_ATTRIB_MAX
];
360 GLint tab
[VERT_ATTRIB_MAX
];
361 int swizzle
[VERT_ATTRIB_MAX
][4];
362 struct r300_vertex_program
*prog
=
363 (struct r300_vertex_program
*)CURRENT_VERTEX_SHADER(ctx
);
366 inputs
= prog
->inputs
;
367 InputsRead
= prog
->key
.InputsRead
;
368 OutputsWritten
= prog
->key
.OutputsWritten
;
370 inputs
= rmesa
->state
.sw_tcl_inputs
;
372 DECLARE_RENDERINPUTS(render_inputs_bitset
);
373 RENDERINPUTS_COPY(render_inputs_bitset
, tnl
->render_inputs_bitset
);
375 vb
->AttribPtr
[VERT_ATTRIB_POS
] = vb
->ClipPtr
;
377 assert(RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_POS
));
378 assert(RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_NORMAL
) == 0);
379 //assert(RENDERINPUTS_TEST(render_inputs_bitset, _TNL_ATTRIB_COLOR0));
381 if (RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_POS
)) {
382 InputsRead
|= 1 << VERT_ATTRIB_POS
;
383 OutputsWritten
|= 1 << VERT_RESULT_HPOS
;
386 if (RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_COLOR0
)) {
387 InputsRead
|= 1 << VERT_ATTRIB_COLOR0
;
388 OutputsWritten
|= 1 << VERT_RESULT_COL0
;
391 if (RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_COLOR1
)) {
392 InputsRead
|= 1 << VERT_ATTRIB_COLOR1
;
393 OutputsWritten
|= 1 << VERT_RESULT_COL1
;
396 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
397 if (RENDERINPUTS_TEST(render_inputs_bitset
, _TNL_ATTRIB_TEX(i
))) {
398 InputsRead
|= 1 << (VERT_ATTRIB_TEX0
+ i
);
399 OutputsWritten
|= 1 << (VERT_RESULT_TEX0
+ i
);
403 for (i
= 0, nr
= 0; i
< VERT_ATTRIB_MAX
; i
++) {
404 if (InputsRead
& (1 << i
)) {
411 /* Fixed, apply to vir0 only */
412 memcpy(vir_inputs
, inputs
, VERT_ATTRIB_MAX
* sizeof(int));
414 if (InputsRead
& VERT_ATTRIB_POS
)
415 inputs
[VERT_ATTRIB_POS
] = 0;
416 if (InputsRead
& (1 << VERT_ATTRIB_COLOR0
))
417 inputs
[VERT_ATTRIB_COLOR0
] = 2;
418 if (InputsRead
& (1 << VERT_ATTRIB_COLOR1
))
419 inputs
[VERT_ATTRIB_COLOR1
] = 3;
420 for (i
= VERT_ATTRIB_TEX0
; i
<= VERT_ATTRIB_TEX7
; i
++)
421 if (InputsRead
& (1 << i
))
422 inputs
[i
] = 6 + (i
- VERT_ATTRIB_TEX0
);
424 RENDERINPUTS_COPY(rmesa
->state
.render_inputs_bitset
, render_inputs_bitset
);
428 assert(OutputsWritten
);
430 for (i
= 0, nr
= 0; i
< VERT_ATTRIB_MAX
; i
++) {
431 if (InputsRead
& (1 << i
)) {
436 if (nr
> R300_MAX_AOS_ARRAYS
) {
437 return R300_FALLBACK_TCL
;
440 for (i
= 0; i
< nr
; i
++) {
441 int ci
, fix
, found
= 0;
443 swizzle
[i
][0] = SWIZZLE_ZERO
;
444 swizzle
[i
][1] = SWIZZLE_ZERO
;
445 swizzle
[i
][2] = SWIZZLE_ZERO
;
446 swizzle
[i
][3] = SWIZZLE_ONE
;
448 for (ci
= 0; ci
< vb
->AttribPtr
[tab
[i
]]->size
; ci
++) {
452 if (r300IsGartMemory(rmesa
, vb
->AttribPtr
[tab
[i
]]->data
, 4)) {
453 if (vb
->AttribPtr
[tab
[i
]]->stride
% 4) {
454 return R300_FALLBACK_TCL
;
456 rmesa
->state
.aos
[i
].address
= (void *)(vb
->AttribPtr
[tab
[i
]]->data
);
457 rmesa
->state
.aos
[i
].start
= 0;
458 rmesa
->state
.aos
[i
].aos_offset
= r300GartOffsetFromVirtual(rmesa
, vb
->AttribPtr
[tab
[i
]]->data
);
459 rmesa
->state
.aos
[i
].aos_stride
= vb
->AttribPtr
[tab
[i
]]->stride
/ 4;
460 rmesa
->state
.aos
[i
].aos_size
= vb
->AttribPtr
[tab
[i
]]->size
;
462 r300EmitVec(ctx
, &rmesa
->state
.aos
[i
],
463 vb
->AttribPtr
[tab
[i
]]->data
,
464 vb
->AttribPtr
[tab
[i
]]->size
,
465 vb
->AttribPtr
[tab
[i
]]->stride
, count
);
468 rmesa
->state
.aos
[i
].aos_size
= vb
->AttribPtr
[tab
[i
]]->size
;
470 for (fix
= 0; fix
<= 4 - vb
->AttribPtr
[tab
[i
]]->size
; fix
++) {
471 if ((rmesa
->state
.aos
[i
].aos_offset
- _mesa_sizeof_type(GL_FLOAT
) * fix
) % 4) {
480 WARN_ONCE("Feeling lucky?\n");
482 rmesa
->state
.aos
[i
].aos_offset
-= _mesa_sizeof_type(GL_FLOAT
) * fix
;
483 for (ci
= 0; ci
< vb
->AttribPtr
[tab
[i
]]->size
; ci
++) {
484 swizzle
[i
][ci
] += fix
;
488 ("Cannot handle offset %x with stride %d, comp %d\n",
489 rmesa
->state
.aos
[i
].aos_offset
,
490 rmesa
->state
.aos
[i
].aos_stride
,
491 vb
->AttribPtr
[tab
[i
]]->size
);
492 return R300_FALLBACK_TCL
;
496 /* Setup INPUT_ROUTE. */
497 R300_STATECHANGE(rmesa
, vir
[0]);
498 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[0].cmd
)->packet0
.count
=
499 r300VAPInputRoute0(&rmesa
->hw
.vir
[0].cmd
[R300_VIR_CNTL_0
],
500 vb
->AttribPtr
, inputs
, tab
, nr
);
501 R300_STATECHANGE(rmesa
, vir
[1]);
502 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[1].cmd
)->packet0
.count
=
503 r300VAPInputRoute1(&rmesa
->hw
.vir
[1].cmd
[R300_VIR_CNTL_0
], swizzle
,
506 /* Setup INPUT_CNTL. */
507 R300_STATECHANGE(rmesa
, vic
);
508 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_0
] = r300VAPInputCntl0(ctx
, InputsRead
);
509 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_1
] = r300VAPInputCntl1(ctx
, InputsRead
);
511 /* Setup OUTPUT_VTX_FMT. */
512 R300_STATECHANGE(rmesa
, vof
);
513 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_0
] =
514 r300VAPOutputCntl0(ctx
, OutputsWritten
);
515 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_1
] =
516 r300VAPOutputCntl1(ctx
, OutputsWritten
);
518 rmesa
->state
.aos_count
= nr
;
520 return R300_FALLBACK_NONE
;
524 void r300UseArrays(GLcontext
* ctx
)
526 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
529 if (rmesa
->state
.elt_dma
.buf
)
530 r300_mem_use(rmesa
, rmesa
->state
.elt_dma
.buf
->id
);
532 for (i
= 0; i
< rmesa
->state
.aos_count
; i
++) {
533 if (rmesa
->state
.aos
[i
].buf
)
534 r300_mem_use(rmesa
, rmesa
->state
.aos
[i
].buf
->id
);
539 void r300ReleaseArrays(GLcontext
* ctx
)
541 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
544 r300ReleaseDmaRegion(rmesa
, &rmesa
->state
.elt_dma
, __FUNCTION__
);
545 for (i
= 0; i
< rmesa
->state
.aos_count
; i
++) {
546 r300ReleaseDmaRegion(rmesa
, &rmesa
->state
.aos
[i
], __FUNCTION__
);
550 void r300EmitCacheFlush(r300ContextPtr rmesa
)
552 int cmd_reserved
= 0;
555 drm_radeon_cmd_header_t
*cmd
= NULL
;
557 reg_start(R300_RB3D_DSTCACHE_CTLSTAT
, 0);
558 e32(R300_RB3D_DSTCACHE_CTLSTAT_DC_FREE_FREE_3D_TAGS
|
559 R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D
);
561 reg_start(R300_ZB_ZCACHE_CTLSTAT
, 0);
562 e32(R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE
|
563 R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE
);