projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'asm-shader-rework-1'
[mesa.git] / src / mesa / drivers / dri / r300 / r300_state.c
1 /*
2 Copyright (C) The Weather Channel, Inc. 2002.
3 Copyright (C) 2004 Nicolai Haehnle.
4 All Rights Reserved.
5
6 The Weather Channel (TM) funded Tungsten Graphics to develop the
7 initial release of the Radeon 8500 driver under the XFree86 license.
8 This notice must be preserved.
9
10 Permission is hereby granted, free of charge, to any person obtaining
11 a copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sublicense, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
17
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial
20 portions of the Software.
21
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
26 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29
30 **************************************************************************/
31
32 /**
33 * \file
34 *
35 * \author Nicolai Haehnle <prefect_@gmx.net>
36 */
37
38 #include "main/glheader.h"
39 #include "main/state.h"
40 #include "main/imports.h"
41 #include "main/enums.h"
42 #include "main/macros.h"
43 #include "main/context.h"
44 #include "main/dd.h"
45 #include "main/framebuffer.h"
46 #include "main/simple_list.h"
47 #include "main/api_arrayelt.h"
48 #include "main/texformat.h"
49
50 #include "swrast/swrast.h"
51 #include "swrast_setup/swrast_setup.h"
52 #include "shader/prog_parameter.h"
53 #include "shader/prog_statevars.h"
54 #include "vbo/vbo.h"
55 #include "tnl/tnl.h"
56 #include "tnl/t_vp_build.h"
57
58 #include "r300_context.h"
59 #include "r300_ioctl.h"
60 #include "r300_state.h"
61 #include "r300_reg.h"
62 #include "r300_emit.h"
63 #include "r300_tex.h"
64 #include "r300_fragprog_common.h"
65 #include "r300_render.h"
66 #include "r300_vertprog.h"
67
68 #include "drirenderbuffer.h"
69
70 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
71 {
72 r300ContextPtr rmesa = R300_CONTEXT(ctx);
73
74 R300_STATECHANGE(rmesa, blend_color);
75
76 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
77 GLuint r = IROUND(cf[0]*1023.0f);
78 GLuint g = IROUND(cf[1]*1023.0f);
79 GLuint b = IROUND(cf[2]*1023.0f);
80 GLuint a = IROUND(cf[3]*1023.0f);
81
82 rmesa->hw.blend_color.cmd[1] = r | (a << 16);
83 rmesa->hw.blend_color.cmd[2] = b | (g << 16);
84 } else {
85 GLubyte color[4];
86 CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
87 CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
88 CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
89 CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
90
91 rmesa->hw.blend_color.cmd[1] = PACK_COLOR_8888(color[3], color[0],
92 color[1], color[2]);
93 }
94 }
95
96 /**
97 * Calculate the hardware blend factor setting. This same function is used
98 * for source and destination of both alpha and RGB.
99 *
100 * \returns
101 * The hardware register value for the specified blend factor. This value
102 * will need to be shifted into the correct position for either source or
103 * destination factor.
104 *
105 * \todo
106 * Since the two cases where source and destination are handled differently
107 * are essentially error cases, they should never happen. Determine if these
108 * cases can be removed.
109 */
110 static int blend_factor(GLenum factor, GLboolean is_src)
111 {
112 switch (factor) {
113 case GL_ZERO:
114 return R300_BLEND_GL_ZERO;
115 break;
116 case GL_ONE:
117 return R300_BLEND_GL_ONE;
118 break;
119 case GL_DST_COLOR:
120 return R300_BLEND_GL_DST_COLOR;
121 break;
122 case GL_ONE_MINUS_DST_COLOR:
123 return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
124 break;
125 case GL_SRC_COLOR:
126 return R300_BLEND_GL_SRC_COLOR;
127 break;
128 case GL_ONE_MINUS_SRC_COLOR:
129 return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
130 break;
131 case GL_SRC_ALPHA:
132 return R300_BLEND_GL_SRC_ALPHA;
133 break;
134 case GL_ONE_MINUS_SRC_ALPHA:
135 return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
136 break;
137 case GL_DST_ALPHA:
138 return R300_BLEND_GL_DST_ALPHA;
139 break;
140 case GL_ONE_MINUS_DST_ALPHA:
141 return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
142 break;
143 case GL_SRC_ALPHA_SATURATE:
144 return (is_src) ? R300_BLEND_GL_SRC_ALPHA_SATURATE :
145 R300_BLEND_GL_ZERO;
146 break;
147 case GL_CONSTANT_COLOR:
148 return R300_BLEND_GL_CONST_COLOR;
149 break;
150 case GL_ONE_MINUS_CONSTANT_COLOR:
151 return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
152 break;
153 case GL_CONSTANT_ALPHA:
154 return R300_BLEND_GL_CONST_ALPHA;
155 break;
156 case GL_ONE_MINUS_CONSTANT_ALPHA:
157 return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
158 break;
159 default:
160 fprintf(stderr, "unknown blend factor %x\n", factor);
161 return (is_src) ? R300_BLEND_GL_ONE : R300_BLEND_GL_ZERO;
162 break;
163 }
164 }
165
166 /**
167 * Sets both the blend equation and the blend function.
168 * This is done in a single
169 * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
170 * change the interpretation of the blend function.
171 * Also, make sure that blend function and blend equation are set to their
172 * default value if color blending is not enabled, since at least blend
173 * equations GL_MIN and GL_FUNC_REVERSE_SUBTRACT will cause wrong results
174 * otherwise for unknown reasons.
175 */
176
177 /* helper function */
178 static void r300SetBlendCntl(r300ContextPtr r300, int func, int eqn,
179 int cbits, int funcA, int eqnA)
180 {
181 GLuint new_ablend, new_cblend;
182
183 #if 0
184 fprintf(stderr,
185 "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n",
186 eqnA, funcA, eqn, func, cbits);
187 #endif
188 new_ablend = eqnA | funcA;
189 new_cblend = eqn | func;
190
191 /* Some blend factor combinations don't seem to work when the
192 * BLEND_NO_SEPARATE bit is set.
193 *
194 * Especially problematic candidates are the ONE_MINUS_* flags,
195 * but I can't see a real pattern.
196 */
197 #if 0
198 if (new_ablend == new_cblend) {
199 new_cblend |= R300_DISCARD_SRC_PIXELS_SRC_ALPHA_0;
200 }
201 #endif
202 new_cblend |= cbits;
203
204 if ((new_ablend != r300->hw.bld.cmd[R300_BLD_ABLEND]) ||
205 (new_cblend != r300->hw.bld.cmd[R300_BLD_CBLEND])) {
206 R300_STATECHANGE(r300, bld);
207 r300->hw.bld.cmd[R300_BLD_ABLEND] = new_ablend;
208 r300->hw.bld.cmd[R300_BLD_CBLEND] = new_cblend;
209 }
210 }
211
212 static void r300SetBlendState(GLcontext * ctx)
213 {
214 r300ContextPtr r300 = R300_CONTEXT(ctx);
215 int func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
216 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
217 int eqn = R300_COMB_FCN_ADD_CLAMP;
218 int funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
219 (R300_BLEND_GL_ZERO << R300_DST_BLEND_SHIFT);
220 int eqnA = R300_COMB_FCN_ADD_CLAMP;
221
222 if (RGBA_LOGICOP_ENABLED(ctx) || !ctx->Color.BlendEnabled) {
223 r300SetBlendCntl(r300, func, eqn, 0, func, eqn);
224 return;
225 }
226
227 func =
228 (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
229 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
230 GL_FALSE) <<
231 R300_DST_BLEND_SHIFT);
232
233 switch (ctx->Color.BlendEquationRGB) {
234 case GL_FUNC_ADD:
235 eqn = R300_COMB_FCN_ADD_CLAMP;
236 break;
237
238 case GL_FUNC_SUBTRACT:
239 eqn = R300_COMB_FCN_SUB_CLAMP;
240 break;
241
242 case GL_FUNC_REVERSE_SUBTRACT:
243 eqn = R300_COMB_FCN_RSUB_CLAMP;
244 break;
245
246 case GL_MIN:
247 eqn = R300_COMB_FCN_MIN;
248 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
249 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
250 break;
251
252 case GL_MAX:
253 eqn = R300_COMB_FCN_MAX;
254 func = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
255 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
256 break;
257
258 default:
259 fprintf(stderr,
260 "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
261 __FUNCTION__, __LINE__, ctx->Color.BlendEquationRGB);
262 return;
263 }
264
265 funcA =
266 (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
267 R300_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
268 GL_FALSE) <<
269 R300_DST_BLEND_SHIFT);
270
271 switch (ctx->Color.BlendEquationA) {
272 case GL_FUNC_ADD:
273 eqnA = R300_COMB_FCN_ADD_CLAMP;
274 break;
275
276 case GL_FUNC_SUBTRACT:
277 eqnA = R300_COMB_FCN_SUB_CLAMP;
278 break;
279
280 case GL_FUNC_REVERSE_SUBTRACT:
281 eqnA = R300_COMB_FCN_RSUB_CLAMP;
282 break;
283
284 case GL_MIN:
285 eqnA = R300_COMB_FCN_MIN;
286 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
287 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
288 break;
289
290 case GL_MAX:
291 eqnA = R300_COMB_FCN_MAX;
292 funcA = (R300_BLEND_GL_ONE << R300_SRC_BLEND_SHIFT) |
293 (R300_BLEND_GL_ONE << R300_DST_BLEND_SHIFT);
294 break;
295
296 default:
297 fprintf(stderr,
298 "[%s:%u] Invalid A blend equation (0x%04x).\n",
299 __FUNCTION__, __LINE__, ctx->Color.BlendEquationA);
300 return;
301 }
302
303 r300SetBlendCntl(r300,
304 func, eqn,
305 (R300_SEPARATE_ALPHA_ENABLE |
306 R300_READ_ENABLE |
307 R300_ALPHA_BLEND_ENABLE), funcA, eqnA);
308 }
309
310 static void r300BlendEquationSeparate(GLcontext * ctx,
311 GLenum modeRGB, GLenum modeA)
312 {
313 r300SetBlendState(ctx);
314 }
315
316 static void r300BlendFuncSeparate(GLcontext * ctx,
317 GLenum sfactorRGB, GLenum dfactorRGB,
318 GLenum sfactorA, GLenum dfactorA)
319 {
320 r300SetBlendState(ctx);
321 }
322
323 /**
324 * Translate LogicOp enums into hardware representation.
325 * Both use a very logical bit-wise layout, but unfortunately the order
326 * of bits is reversed.
327 */
328 static GLuint translate_logicop(GLenum logicop)
329 {
330 GLuint bits = logicop - GL_CLEAR;
331 bits = ((bits & 1) << 3) | ((bits & 2) << 1) | ((bits & 4) >> 1) | ((bits & 8) >> 3);
332 return bits << R300_RB3D_ROPCNTL_ROP_SHIFT;
333 }
334
335 /**
336 * Used internally to update the r300->hw hardware state to match the
337 * current OpenGL state.
338 */
339 static void r300SetLogicOpState(GLcontext *ctx)
340 {
341 r300ContextPtr r300 = R300_CONTEXT(ctx);
342 R300_STATECHANGE(r300, rop);
343 if (RGBA_LOGICOP_ENABLED(ctx)) {
344 r300->hw.rop.cmd[1] = R300_RB3D_ROPCNTL_ROP_ENABLE |
345 translate_logicop(ctx->Color.LogicOp);
346 } else {
347 r300->hw.rop.cmd[1] = 0;
348 }
349 }
350
351 /**
352 * Called by Mesa when an application program changes the LogicOp state
353 * via glLogicOp.
354 */
355 static void r300LogicOpcode(GLcontext *ctx, GLenum logicop)
356 {
357 if (RGBA_LOGICOP_ENABLED(ctx))
358 r300SetLogicOpState(ctx);
359 }
360
361 static void r300ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *eq )
362 {
363 r300ContextPtr rmesa = R300_CONTEXT(ctx);
364 GLint p;
365 GLint *ip;
366
367 /* no VAP UCP on non-TCL chipsets */
368 if (!rmesa->options.hw_tcl_enabled)
369 return;
370
371 p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
372 ip = (GLint *)ctx->Transform._ClipUserPlane[p];
373
374 R300_STATECHANGE( rmesa, vpucp[p] );
375 rmesa->hw.vpucp[p].cmd[R300_VPUCP_X] = ip[0];
376 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Y] = ip[1];
377 rmesa->hw.vpucp[p].cmd[R300_VPUCP_Z] = ip[2];
378 rmesa->hw.vpucp[p].cmd[R300_VPUCP_W] = ip[3];
379 }
380
381 static void r300SetClipPlaneState(GLcontext * ctx, GLenum cap, GLboolean state)
382 {
383 r300ContextPtr r300 = R300_CONTEXT(ctx);
384 GLuint p;
385
386 /* no VAP UCP on non-TCL chipsets */
387 if (!r300->options.hw_tcl_enabled)
388 return;
389
390 p = cap - GL_CLIP_PLANE0;
391 R300_STATECHANGE(r300, vap_clip_cntl);
392 if (state) {
393 r300->hw.vap_clip_cntl.cmd[1] |= (R300_VAP_UCP_ENABLE_0 << p);
394 r300ClipPlane(ctx, cap, NULL);
395 } else {
396 r300->hw.vap_clip_cntl.cmd[1] &= ~(R300_VAP_UCP_ENABLE_0 << p);
397 }
398 }
399
400 /**
401 * Update our tracked culling state based on Mesa's state.
402 */
403 static void r300UpdateCulling(GLcontext * ctx)
404 {
405 r300ContextPtr r300 = R300_CONTEXT(ctx);
406 uint32_t val = 0;
407
408 if (ctx->Polygon.CullFlag) {
409 switch (ctx->Polygon.CullFaceMode) {
410 case GL_FRONT:
411 val = R300_CULL_FRONT;
412 break;
413 case GL_BACK:
414 val = R300_CULL_BACK;
415 break;
416 case GL_FRONT_AND_BACK:
417 val = R300_CULL_FRONT | R300_CULL_BACK;
418 break;
419 default:
420 break;
421 }
422 }
423
424 switch (ctx->Polygon.FrontFace) {
425 case GL_CW:
426 val |= R300_FRONT_FACE_CW;
427 break;
428 case GL_CCW:
429 val |= R300_FRONT_FACE_CCW;
430 break;
431 default:
432 break;
433 }
434
435 /* Winding is inverted when rendering to FBO */
436 if (ctx->DrawBuffer && ctx->DrawBuffer->Name)
437 val ^= R300_FRONT_FACE_CW;
438
439 R300_STATECHANGE(r300, cul);
440 r300->hw.cul.cmd[R300_CUL_CULL] = val;
441 }
442
443 static void r300SetPolygonOffsetState(GLcontext * ctx, GLboolean state)
444 {
445 r300ContextPtr r300 = R300_CONTEXT(ctx);
446
447 R300_STATECHANGE(r300, occlusion_cntl);
448 if (state) {
449 r300->hw.occlusion_cntl.cmd[1] |= (3 << 0);
450 } else {
451 r300->hw.occlusion_cntl.cmd[1] &= ~(3 << 0);
452 }
453 }
454
455 static GLboolean current_fragment_program_writes_depth(GLcontext* ctx)
456 {
457 r300ContextPtr r300 = R300_CONTEXT(ctx);
458
459 return ctx->FragmentProgram._Current && r300->selected_fp->code.writes_depth;
460 }
461
462 static void r300SetEarlyZState(GLcontext * ctx)
463 {
464 r300ContextPtr r300 = R300_CONTEXT(ctx);
465 GLuint topZ = R300_ZTOP_ENABLE;
466 GLuint w_fmt, fgdepthsrc;
467
468 if (ctx->Color.AlphaEnabled && ctx->Color.AlphaFunc != GL_ALWAYS)
469 topZ = R300_ZTOP_DISABLE;
470 else if (current_fragment_program_writes_depth(ctx))
471 topZ = R300_ZTOP_DISABLE;
472 else if (ctx->FragmentProgram._Current && ctx->FragmentProgram._Current->UsesKill)
473 topZ = R300_ZTOP_DISABLE;
474 else if (r300->radeon.query.current)
475 topZ = R300_ZTOP_DISABLE;
476
477 if (topZ != r300->hw.zstencil_format.cmd[2]) {
478 /* Note: This completely reemits the stencil format.
479 * I have not tested whether this is strictly necessary,
480 * or if emitting a write to ZB_ZTOP is enough.
481 */
482 R300_STATECHANGE(r300, zstencil_format);
483 r300->hw.zstencil_format.cmd[2] = topZ;
484 }
485
486 /* w_fmt value is set to get best performance
487 * see p.130 R5xx 3D acceleration guide v1.3 */
488 if (current_fragment_program_writes_depth(ctx)) {
489 fgdepthsrc = R300_FG_DEPTH_SRC_SHADER;
490 w_fmt = R300_W_FMT_W24 | R300_W_SRC_US;
491 } else {
492 fgdepthsrc = R300_FG_DEPTH_SRC_SCAN;
493 w_fmt = R300_W_FMT_W0 | R300_W_SRC_US;
494 }
495
496 if (w_fmt != r300->hw.us_out_fmt.cmd[5]) {
497 R300_STATECHANGE(r300, us_out_fmt);
498 r300->hw.us_out_fmt.cmd[5] = w_fmt;
499 }
500
501 if (fgdepthsrc != r300->hw.fg_depth_src.cmd[1]) {
502 R300_STATECHANGE(r300, fg_depth_src);
503 r300->hw.fg_depth_src.cmd[1] = fgdepthsrc;
504 }
505 }
506
507 static void r300SetAlphaState(GLcontext * ctx)
508 {
509 r300ContextPtr r300 = R300_CONTEXT(ctx);
510 GLubyte refByte;
511 uint32_t pp_misc = 0x0;
512 GLboolean really_enabled = ctx->Color.AlphaEnabled;
513
514 CLAMPED_FLOAT_TO_UBYTE(refByte, ctx->Color.AlphaRef);
515
516 switch (ctx->Color.AlphaFunc) {
517 case GL_NEVER:
518 pp_misc |= R300_FG_ALPHA_FUNC_NEVER;
519 break;
520 case GL_LESS:
521 pp_misc |= R300_FG_ALPHA_FUNC_LESS;
522 break;
523 case GL_EQUAL:
524 pp_misc |= R300_FG_ALPHA_FUNC_EQUAL;
525 break;
526 case GL_LEQUAL:
527 pp_misc |= R300_FG_ALPHA_FUNC_LE;
528 break;
529 case GL_GREATER:
530 pp_misc |= R300_FG_ALPHA_FUNC_GREATER;
531 break;
532 case GL_NOTEQUAL:
533 pp_misc |= R300_FG_ALPHA_FUNC_NOTEQUAL;
534 break;
535 case GL_GEQUAL:
536 pp_misc |= R300_FG_ALPHA_FUNC_GE;
537 break;
538 case GL_ALWAYS:
539 /*pp_misc |= FG_ALPHA_FUNC_ALWAYS; */
540 really_enabled = GL_FALSE;
541 break;
542 }
543
544 if (really_enabled) {
545 pp_misc |= R300_FG_ALPHA_FUNC_ENABLE;
546 pp_misc |= R500_FG_ALPHA_FUNC_8BIT;
547 pp_misc |= (refByte & R300_FG_ALPHA_FUNC_VAL_MASK);
548 } else {
549 pp_misc = 0x0;
550 }
551
552 R300_STATECHANGE(r300, at);
553 r300->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
554 r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
555 }
556
557 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
558 {
559 (void)func;
560 (void)ref;
561 r300SetAlphaState(ctx);
562 }
563
564 static int translate_func(int func)
565 {
566 switch (func) {
567 case GL_NEVER:
568 return R300_ZS_NEVER;
569 case GL_LESS:
570 return R300_ZS_LESS;
571 case GL_EQUAL:
572 return R300_ZS_EQUAL;
573 case GL_LEQUAL:
574 return R300_ZS_LEQUAL;
575 case GL_GREATER:
576 return R300_ZS_GREATER;
577 case GL_NOTEQUAL:
578 return R300_ZS_NOTEQUAL;
579 case GL_GEQUAL:
580 return R300_ZS_GEQUAL;
581 case GL_ALWAYS:
582 return R300_ZS_ALWAYS;
583 }
584 return 0;
585 }
586
587 static void r300SetDepthState(GLcontext * ctx)
588 {
589 r300ContextPtr r300 = R300_CONTEXT(ctx);
590
591 R300_STATECHANGE(r300, zs);
592 r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_STENCIL_ENABLE|R300_STENCIL_FRONT_BACK;
593 r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_Z_FUNC_SHIFT);
594
595 if (ctx->Depth.Test) {
596 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_ENABLE;
597 if (ctx->Depth.Mask)
598 r300->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_Z_WRITE_ENABLE;
599 r300->hw.zs.cmd[R300_ZS_CNTL_1] |=
600 translate_func(ctx->Depth.Func) << R300_Z_FUNC_SHIFT;
601 }
602 }
603
604 static void r300CatchStencilFallback(GLcontext *ctx)
605 {
606 const unsigned back = ctx->Stencil._BackFace;
607
608 if (ctx->Stencil._Enabled && (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
609 || ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
610 || ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
611 r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_TRUE);
612 } else {
613 r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
614 }
615 }
616
617 static void r300SetStencilState(GLcontext * ctx, GLboolean state)
618 {
619 r300ContextPtr r300 = R300_CONTEXT(ctx);
620 GLboolean hw_stencil = GL_FALSE;
621
622 r300CatchStencilFallback(ctx);
623
624 if (ctx->DrawBuffer) {
625 struct radeon_renderbuffer *rrbStencil
626 = radeon_get_renderbuffer(ctx->DrawBuffer, BUFFER_STENCIL);
627 hw_stencil = (rrbStencil && rrbStencil->bo);
628 }
629
630 if (hw_stencil) {
631 R300_STATECHANGE(r300, zs);
632 if (state) {
633 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
634 R300_STENCIL_ENABLE;
635 } else {
636 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
637 ~R300_STENCIL_ENABLE;
638 }
639 }
640 }
641
642 static void r300UpdatePolygonMode(GLcontext * ctx)
643 {
644 r300ContextPtr r300 = R300_CONTEXT(ctx);
645 uint32_t hw_mode = R300_GA_POLY_MODE_DISABLE;
646
647 /* Only do something if a polygon mode is wanted, default is GL_FILL */
648 if (ctx->Polygon.FrontMode != GL_FILL ||
649 ctx->Polygon.BackMode != GL_FILL) {
650 GLenum f, b;
651
652 /* Handle GL_CW (clock wise and GL_CCW (counter clock wise)
653 * correctly by selecting the correct front and back face
654 */
655 if (ctx->Polygon.FrontFace == GL_CCW) {
656 f = ctx->Polygon.FrontMode;
657 b = ctx->Polygon.BackMode;
658 } else {
659 f = ctx->Polygon.BackMode;
660 b = ctx->Polygon.FrontMode;
661 }
662
663 /* Enable polygon mode */
664 hw_mode |= R300_GA_POLY_MODE_DUAL;
665
666 switch (f) {
667 case GL_LINE:
668 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_LINE;
669 break;
670 case GL_POINT:
671 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_POINT;
672 break;
673 case GL_FILL:
674 hw_mode |= R300_GA_POLY_MODE_FRONT_PTYPE_TRI;
675 break;
676 }
677
678 switch (b) {
679 case GL_LINE:
680 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_LINE;
681 break;
682 case GL_POINT:
683 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_POINT;
684 break;
685 case GL_FILL:
686 hw_mode |= R300_GA_POLY_MODE_BACK_PTYPE_TRI;
687 break;
688 }
689 }
690
691 if (r300->hw.polygon_mode.cmd[1] != hw_mode) {
692 R300_STATECHANGE(r300, polygon_mode);
693 r300->hw.polygon_mode.cmd[1] = hw_mode;
694 }
695
696 r300->hw.polygon_mode.cmd[2] = 0x00000001;
697 r300->hw.polygon_mode.cmd[3] = 0x00000000;
698 }
699
700 /**
701 * Change the culling mode.
702 *
703 * \note Mesa already filters redundant calls to this function.
704 */
705 static void r300CullFace(GLcontext * ctx, GLenum mode)
706 {
707 (void)mode;
708
709 r300UpdateCulling(ctx);
710 }
711
712 /**
713 * Change the polygon orientation.
714 *
715 * \note Mesa already filters redundant calls to this function.
716 */
717 static void r300FrontFace(GLcontext * ctx, GLenum mode)
718 {
719 (void)mode;
720
721 r300UpdateCulling(ctx);
722 r300UpdatePolygonMode(ctx);
723 }
724
725 /**
726 * Change the depth testing function.
727 *
728 * \note Mesa already filters redundant calls to this function.
729 */
730 static void r300DepthFunc(GLcontext * ctx, GLenum func)
731 {
732 (void)func;
733 r300SetDepthState(ctx);
734 }
735
736 /**
737 * Enable/Disable depth writing.
738 *
739 * \note Mesa already filters redundant calls to this function.
740 */
741 static void r300DepthMask(GLcontext * ctx, GLboolean mask)
742 {
743 (void)mask;
744 r300SetDepthState(ctx);
745 }
746
747 /**
748 * Handle glColorMask()
749 */
750 static void r300ColorMask(GLcontext * ctx,
751 GLboolean r, GLboolean g, GLboolean b, GLboolean a)
752 {
753 r300ContextPtr r300 = R300_CONTEXT(ctx);
754 int mask = (r ? RB3D_COLOR_CHANNEL_MASK_RED_MASK0 : 0) |
755 (g ? RB3D_COLOR_CHANNEL_MASK_GREEN_MASK0 : 0) |
756 (b ? RB3D_COLOR_CHANNEL_MASK_BLUE_MASK0 : 0) |
757 (a ? RB3D_COLOR_CHANNEL_MASK_ALPHA_MASK0 : 0);
758
759 if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
760 R300_STATECHANGE(r300, cmk);
761 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
762 }
763 }
764
765 /* =============================================================
766 * Point state
767 */
768 static void r300PointSize(GLcontext * ctx, GLfloat size)
769 {
770 r300ContextPtr r300 = R300_CONTEXT(ctx);
771
772 /* We need to clamp to user defined range here, because
773 * the HW clamping happens only for per vertex point size. */
774 size = CLAMP(size, ctx->Point.MinSize, ctx->Point.MaxSize);
775
776 /* same size limits for AA, non-AA points */
777 size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
778
779 R300_STATECHANGE(r300, ps);
780 r300->hw.ps.cmd[R300_PS_POINTSIZE] =
781 ((int)(size * 6) << R300_POINTSIZE_X_SHIFT) |
782 ((int)(size * 6) << R300_POINTSIZE_Y_SHIFT);
783 }
784
785 static void r300PointParameter(GLcontext * ctx, GLenum pname, const GLfloat * param)
786 {
787 r300ContextPtr r300 = R300_CONTEXT(ctx);
788
789 switch (pname) {
790 case GL_POINT_SIZE_MIN:
791 R300_STATECHANGE(r300, ga_point_minmax);
792 r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MIN_MASK;
793 r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MinSize * 6.0);
794 break;
795 case GL_POINT_SIZE_MAX:
796 R300_STATECHANGE(r300, ga_point_minmax);
797 r300->hw.ga_point_minmax.cmd[1] &= ~R300_GA_POINT_MINMAX_MAX_MASK;
798 r300->hw.ga_point_minmax.cmd[1] |= (GLuint)(ctx->Point.MaxSize * 6.0)
799 << R300_GA_POINT_MINMAX_MAX_SHIFT;
800 break;
801 case GL_POINT_DISTANCE_ATTENUATION:
802 break;
803 case GL_POINT_FADE_THRESHOLD_SIZE:
804 break;
805 default:
806 break;
807 }
808 }
809
810 /* =============================================================
811 * Line state
812 */
813 static void r300LineWidth(GLcontext * ctx, GLfloat widthf)
814 {
815 r300ContextPtr r300 = R300_CONTEXT(ctx);
816
817 widthf = CLAMP(widthf,
818 ctx->Const.MinPointSize,
819 ctx->Const.MaxPointSize);
820 R300_STATECHANGE(r300, lcntl);
821 r300->hw.lcntl.cmd[1] =
822 R300_LINE_CNT_HO | R300_LINE_CNT_VE | (int)(widthf * 6.0);
823 }
824
825 static void r300PolygonMode(GLcontext * ctx, GLenum face, GLenum mode)
826 {
827 (void)face;
828 (void)mode;
829
830 r300UpdatePolygonMode(ctx);
831 }
832
833 /* =============================================================
834 * Stencil
835 */
836
837 static int translate_stencil_op(int op)
838 {
839 switch (op) {
840 case GL_KEEP:
841 return R300_ZS_KEEP;
842 case GL_ZERO:
843 return R300_ZS_ZERO;
844 case GL_REPLACE:
845 return R300_ZS_REPLACE;
846 case GL_INCR:
847 return R300_ZS_INCR;
848 case GL_DECR:
849 return R300_ZS_DECR;
850 case GL_INCR_WRAP_EXT:
851 return R300_ZS_INCR_WRAP;
852 case GL_DECR_WRAP_EXT:
853 return R300_ZS_DECR_WRAP;
854 case GL_INVERT:
855 return R300_ZS_INVERT;
856 default:
857 WARN_ONCE("Do not know how to translate stencil op");
858 return R300_ZS_KEEP;
859 }
860 return 0;
861 }
862
863 static void r300ShadeModel(GLcontext * ctx, GLenum mode)
864 {
865 r300ContextPtr rmesa = R300_CONTEXT(ctx);
866
867 R300_STATECHANGE(rmesa, shade);
868 rmesa->hw.shade.cmd[1] = 0x00000002;
869 R300_STATECHANGE(rmesa, shade2);
870 switch (mode) {
871 case GL_FLAT:
872 rmesa->hw.shade2.cmd[1] = R300_RE_SHADE_MODEL_FLAT;
873 break;
874 case GL_SMOOTH:
875 rmesa->hw.shade2.cmd[1] = R300_RE_SHADE_MODEL_SMOOTH;
876 break;
877 default:
878 return;
879 }
880 rmesa->hw.shade2.cmd[2] = 0x00000000;
881 rmesa->hw.shade2.cmd[3] = 0x00000000;
882 }
883
884 static void r300StencilFuncSeparate(GLcontext * ctx, GLenum face,
885 GLenum func, GLint ref, GLuint mask)
886 {
887 r300ContextPtr rmesa = R300_CONTEXT(ctx);
888 GLuint refmask;
889 GLuint flag;
890 const unsigned back = ctx->Stencil._BackFace;
891
892 r300CatchStencilFallback(ctx);
893
894 refmask = ((ctx->Stencil.Ref[0] & 0xff) << R300_STENCILREF_SHIFT)
895 | ((ctx->Stencil.ValueMask[0] & 0xff) << R300_STENCILMASK_SHIFT);
896
897 R300_STATECHANGE(rmesa, zs);
898 rmesa->hw.zs.cmd[R300_ZS_CNTL_0] |= R300_STENCIL_FRONT_BACK;
899 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~((R300_ZS_MASK <<
900 R300_S_FRONT_FUNC_SHIFT)
901 | (R300_ZS_MASK <<
902 R300_S_BACK_FUNC_SHIFT));
903
904 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
905 ~((R300_STENCILREF_MASK << R300_STENCILREF_SHIFT) |
906 (R300_STENCILREF_MASK << R300_STENCILMASK_SHIFT));
907
908 flag = translate_func(ctx->Stencil.Function[0]);
909 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
910 (flag << R300_S_FRONT_FUNC_SHIFT);
911
912 flag = translate_func(ctx->Stencil.Function[back]);
913
914 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
915 (flag << R300_S_BACK_FUNC_SHIFT);
916 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
917 }
918
919 static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
920 {
921 r300ContextPtr rmesa = R300_CONTEXT(ctx);
922
923 r300CatchStencilFallback(ctx);
924
925 R300_STATECHANGE(rmesa, zs);
926 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=
927 ~(R300_STENCILREF_MASK <<
928 R300_STENCILWRITEMASK_SHIFT);
929 rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |=
930 (ctx->Stencil.
931 WriteMask[0] & R300_STENCILREF_MASK) <<
932 R300_STENCILWRITEMASK_SHIFT;
933 }
934
935 static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
936 GLenum fail, GLenum zfail, GLenum zpass)
937 {
938 r300ContextPtr rmesa = R300_CONTEXT(ctx);
939 const unsigned back = ctx->Stencil._BackFace;
940
941 r300CatchStencilFallback(ctx);
942
943 R300_STATECHANGE(rmesa, zs);
944 /* It is easier to mask what's left.. */
945 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &=
946 (R300_ZS_MASK << R300_Z_FUNC_SHIFT) |
947 (R300_ZS_MASK << R300_S_FRONT_FUNC_SHIFT) |
948 (R300_ZS_MASK << R300_S_BACK_FUNC_SHIFT);
949
950 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
951 (translate_stencil_op(ctx->Stencil.FailFunc[0]) <<
952 R300_S_FRONT_SFAIL_OP_SHIFT)
953 | (translate_stencil_op(ctx->Stencil.ZFailFunc[0]) <<
954 R300_S_FRONT_ZFAIL_OP_SHIFT)
955 | (translate_stencil_op(ctx->Stencil.ZPassFunc[0]) <<
956 R300_S_FRONT_ZPASS_OP_SHIFT);
957
958 rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
959 (translate_stencil_op(ctx->Stencil.FailFunc[back]) <<
960 R300_S_BACK_SFAIL_OP_SHIFT)
961 | (translate_stencil_op(ctx->Stencil.ZFailFunc[back]) <<
962 R300_S_BACK_ZFAIL_OP_SHIFT)
963 | (translate_stencil_op(ctx->Stencil.ZPassFunc[back]) <<
964 R300_S_BACK_ZPASS_OP_SHIFT);
965 }
966
967 /* =============================================================
968 * Window position and viewport transformation
969 */
970
971 static void r300UpdateWindow(GLcontext * ctx)
972 {
973 r300ContextPtr rmesa = R300_CONTEXT(ctx);
974 __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
975 GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
976 GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
977 const GLfloat *v = ctx->Viewport._WindowMap.m;
978 const GLfloat depthScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
979 const GLboolean render_to_fbo = (ctx->DrawBuffer->Name != 0);
980 GLfloat y_scale, y_bias;
981
982 if (render_to_fbo) {
983 y_scale = 1.0;
984 y_bias = 0;
985 } else {
986 y_scale = -1.0;
987 y_bias = yoffset;
988 }
989
990 GLfloat sx = v[MAT_SX];
991 GLfloat tx = v[MAT_TX] + xoffset;
992 GLfloat sy = v[MAT_SY] * y_scale;
993 GLfloat ty = (v[MAT_TY] * y_scale) + y_bias;
994 GLfloat sz = v[MAT_SZ] * depthScale;
995 GLfloat tz = v[MAT_TZ] * depthScale;
996
997 R300_STATECHANGE(rmesa, vpt);
998
999 rmesa->hw.vpt.cmd[R300_VPT_XSCALE] = r300PackFloat32(sx);
1000 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
1001 rmesa->hw.vpt.cmd[R300_VPT_YSCALE] = r300PackFloat32(sy);
1002 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
1003 rmesa->hw.vpt.cmd[R300_VPT_ZSCALE] = r300PackFloat32(sz);
1004 rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
1005 }
1006
1007 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
1008 GLsizei width, GLsizei height)
1009 {
1010 /* Don't pipeline viewport changes, conflict with window offset
1011 * setting below. Could apply deltas to rescue pipelined viewport
1012 * values, or keep the originals hanging around.
1013 */
1014 r300UpdateWindow(ctx);
1015
1016 radeon_viewport(ctx, x, y, width, height);
1017 }
1018
1019 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
1020 {
1021 r300UpdateWindow(ctx);
1022 }
1023
1024 void r300UpdateViewportOffset(GLcontext * ctx)
1025 {
1026 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1027 __DRIdrawablePrivate *dPriv = radeon_get_drawable(&rmesa->radeon);
1028 GLfloat xoffset = (GLfloat) dPriv->x;
1029 GLfloat yoffset = (GLfloat) dPriv->y + dPriv->h;
1030 const GLfloat *v = ctx->Viewport._WindowMap.m;
1031
1032 GLfloat tx = v[MAT_TX] + xoffset;
1033 GLfloat ty = (-v[MAT_TY]) + yoffset;
1034
1035 if (rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] != r300PackFloat32(tx) ||
1036 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] != r300PackFloat32(ty)) {
1037 /* Note: this should also modify whatever data the context reset
1038 * code uses...
1039 */
1040 R300_STATECHANGE(rmesa, vpt);
1041 rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
1042 rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
1043
1044 }
1045
1046 radeonUpdateScissor(ctx);
1047 }
1048
1049 /**
1050 * Update R300's own internal state parameters.
1051 * For now just STATE_R300_WINDOW_DIMENSION
1052 */
1053 static void r300UpdateStateParameters(GLcontext * ctx, GLuint new_state)
1054 {
1055 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1056 struct gl_program_parameter_list *paramList;
1057
1058 if (!(new_state & (_NEW_BUFFERS | _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS)))
1059 return;
1060
1061 if (!ctx->FragmentProgram._Current || !rmesa->selected_fp)
1062 return;
1063
1064 paramList = ctx->FragmentProgram._Current->Base.Parameters;
1065
1066 if (!paramList)
1067 return;
1068
1069 _mesa_load_state_parameters(ctx, paramList);
1070 }
1071
1072 /* =============================================================
1073 * Polygon state
1074 */
1075 static void r300PolygonOffset(GLcontext * ctx, GLfloat factor, GLfloat units)
1076 {
1077 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1078 GLfloat constant = units;
1079
1080 switch (ctx->Visual.depthBits) {
1081 case 16:
1082 constant *= 4.0;
1083 break;
1084 case 24:
1085 constant *= 2.0;
1086 break;
1087 }
1088
1089 factor *= 12.0;
1090
1091 /* fprintf(stderr, "%s f:%f u:%f\n", __FUNCTION__, factor, constant); */
1092
1093 R300_STATECHANGE(rmesa, zbs);
1094 rmesa->hw.zbs.cmd[R300_ZBS_T_FACTOR] = r300PackFloat32(factor);
1095 rmesa->hw.zbs.cmd[R300_ZBS_T_CONSTANT] = r300PackFloat32(constant);
1096 rmesa->hw.zbs.cmd[R300_ZBS_W_FACTOR] = r300PackFloat32(factor);
1097 rmesa->hw.zbs.cmd[R300_ZBS_W_CONSTANT] = r300PackFloat32(constant);
1098 }
1099
1100 /* Routing and texture-related */
1101
1102 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1103 * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1104 * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1105 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1106 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1107 * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1108 * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1109 * combinations where only one of them is nearest.
1110 */
1111 static unsigned long gen_fixed_filter(unsigned long f)
1112 {
1113 unsigned long mag, min, needs_fixing = 0;
1114 //return f;
1115
1116 /* We ignore MIRROR bit so we dont have to do everything twice */
1117 if ((f & ((7 - 1) << R300_TX_WRAP_S_SHIFT)) ==
1118 (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)) {
1119 needs_fixing |= 1;
1120 }
1121 if ((f & ((7 - 1) << R300_TX_WRAP_T_SHIFT)) ==
1122 (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)) {
1123 needs_fixing |= 2;
1124 }
1125 if ((f & ((7 - 1) << R300_TX_WRAP_R_SHIFT)) ==
1126 (R300_TX_CLAMP << R300_TX_WRAP_R_SHIFT)) {
1127 needs_fixing |= 4;
1128 }
1129
1130 if (!needs_fixing)
1131 return f;
1132
1133 mag = f & R300_TX_MAG_FILTER_MASK;
1134 min = f & (R300_TX_MIN_FILTER_MASK|R300_TX_MIN_FILTER_MIP_MASK);
1135
1136 /* TODO: Check for anisto filters too */
1137 if ((mag != R300_TX_MAG_FILTER_NEAREST)
1138 && (min != R300_TX_MIN_FILTER_NEAREST))
1139 return f;
1140
1141 /* r300 cant handle these modes hence we force nearest to linear */
1142 if ((mag == R300_TX_MAG_FILTER_NEAREST)
1143 && (min != R300_TX_MIN_FILTER_NEAREST)) {
1144 f &= ~R300_TX_MAG_FILTER_NEAREST;
1145 f |= R300_TX_MAG_FILTER_LINEAR;
1146 return f;
1147 }
1148
1149 if ((min == R300_TX_MIN_FILTER_NEAREST)
1150 && (mag != R300_TX_MAG_FILTER_NEAREST)) {
1151 f &= ~R300_TX_MIN_FILTER_NEAREST;
1152 f |= R300_TX_MIN_FILTER_LINEAR;
1153 return f;
1154 }
1155
1156 /* Both are nearest */
1157 if (needs_fixing & 1) {
1158 f &= ~((7 - 1) << R300_TX_WRAP_S_SHIFT);
1159 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
1160 }
1161 if (needs_fixing & 2) {
1162 f &= ~((7 - 1) << R300_TX_WRAP_T_SHIFT);
1163 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
1164 }
1165 if (needs_fixing & 4) {
1166 f &= ~((7 - 1) << R300_TX_WRAP_R_SHIFT);
1167 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_R_SHIFT;
1168 }
1169 return f;
1170 }
1171
1172 static void r300SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
1173 {
1174 r300ContextPtr r300 = R300_CONTEXT(ctx);
1175 int i;
1176 struct r300_fragment_program_code *code = &r300->selected_fp->code.code.r300;
1177
1178 R300_STATECHANGE(r300, fpt);
1179
1180 for (i = 0; i < code->tex.length; i++) {
1181 int unit;
1182 int opcode;
1183 unsigned long val;
1184
1185 unit = code->tex.inst[i] >> R300_TEX_ID_SHIFT;
1186 unit &= 15;
1187
1188 val = code->tex.inst[i];
1189 val &= ~R300_TEX_ID_MASK;
1190
1191 opcode =
1192 (val & R300_TEX_INST_MASK) >> R300_TEX_INST_SHIFT;
1193 if (opcode == R300_TEX_OP_KIL) {
1194 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1195 } else {
1196 if (tmu_mappings[unit] >= 0) {
1197 val |=
1198 tmu_mappings[unit] <<
1199 R300_TEX_ID_SHIFT;
1200 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1201 } else {
1202 // We get here when the corresponding texture image is incomplete
1203 // (e.g. incomplete mipmaps etc.)
1204 r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
1205 }
1206 }
1207 }
1208
1209 r300->hw.fpt.cmd[R300_FPT_CMD_0] =
1210 cmdpacket0(r300->radeon.radeonScreen,
1211 R300_US_TEX_INST_0, code->tex.length);
1212 }
1213
1214 static void r500SetupFragmentShaderTextures(GLcontext *ctx, int *tmu_mappings)
1215 {
1216 r300ContextPtr r300 = R300_CONTEXT(ctx);
1217 int i;
1218 struct r500_fragment_program_code *code = &r300->selected_fp->code.code.r500;
1219
1220 /* find all the texture instructions and relocate the texture units */
1221 for (i = 0; i < code->inst_end + 1; i++) {
1222 if ((code->inst[i].inst0 & 0x3) == R500_INST_TYPE_TEX) {
1223 uint32_t val;
1224 int unit, opcode, new_unit;
1225
1226 val = code->inst[i].inst1;
1227
1228 unit = (val >> 16) & 0xf;
1229
1230 val &= ~(0xf << 16);
1231
1232 opcode = val & (0x7 << 22);
1233 if (opcode == R500_TEX_INST_TEXKILL) {
1234 new_unit = 0;
1235 } else {
1236 if (tmu_mappings[unit] >= 0) {
1237 new_unit = tmu_mappings[unit];
1238 } else {
1239 new_unit = 0;
1240 }
1241 }
1242 val |= R500_TEX_ID(new_unit);
1243 code->inst[i].inst1 = val;
1244 }
1245 }
1246 }
1247
1248 static GLuint translate_lod_bias(GLfloat bias)
1249 {
1250 GLint b = (int)(bias*32);
1251 if (b >= (1 << 9))
1252 b = (1 << 9)-1;
1253 else if (b < -(1 << 9))
1254 b = -(1 << 9);
1255 return (((GLuint)b) << R300_LOD_BIAS_SHIFT) & R300_LOD_BIAS_MASK;
1256 }
1257
1258
1259 static void r300SetupTextures(GLcontext * ctx)
1260 {
1261 int i, mtu;
1262 struct radeon_tex_obj *t;
1263 r300ContextPtr r300 = R300_CONTEXT(ctx);
1264 int hw_tmu = 0;
1265 int last_hw_tmu = -1; /* -1 translates into no setup costs for fields */
1266 int tmu_mappings[R300_MAX_TEXTURE_UNITS] = { -1, };
1267
1268 R300_STATECHANGE(r300, txe);
1269 R300_STATECHANGE(r300, tex.filter);
1270 R300_STATECHANGE(r300, tex.filter_1);
1271 R300_STATECHANGE(r300, tex.size);
1272 R300_STATECHANGE(r300, tex.format);
1273 R300_STATECHANGE(r300, tex.pitch);
1274 R300_STATECHANGE(r300, tex.offset);
1275 R300_STATECHANGE(r300, tex.chroma_key);
1276 R300_STATECHANGE(r300, tex.border_color);
1277
1278 r300->hw.txe.cmd[R300_TXE_ENABLE] = 0x0;
1279
1280 mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1281 if (RADEON_DEBUG & DEBUG_STATE)
1282 fprintf(stderr, "mtu=%d\n", mtu);
1283
1284 if (mtu > R300_MAX_TEXTURE_UNITS) {
1285 fprintf(stderr,
1286 "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1287 mtu, R300_MAX_TEXTURE_UNITS);
1288 _mesa_exit(-1);
1289 }
1290
1291 /* We cannot let disabled tmu offsets pass DRM */
1292 for (i = 0; i < mtu; i++) {
1293 if (ctx->Texture.Unit[i]._ReallyEnabled) {
1294 tmu_mappings[i] = hw_tmu;
1295
1296 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
1297 if (!t)
1298 continue;
1299
1300 if ((t->pp_txformat & 0xffffff00) == 0xffffff00) {
1301 WARN_ONCE
1302 ("unknown texture format (entry %x) encountered. Help me !\n",
1303 t->pp_txformat & 0xff);
1304 }
1305
1306 if (RADEON_DEBUG & DEBUG_STATE)
1307 fprintf(stderr,
1308 "Activating texture unit %d\n", i);
1309
1310 r300->hw.txe.cmd[R300_TXE_ENABLE] |= (1 << hw_tmu);
1311
1312 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0 +
1313 hw_tmu] =
1314 gen_fixed_filter(t->pp_txfilter) | (hw_tmu << 28);
1315 /* Note: There is a LOD bias per texture unit and a LOD bias
1316 * per texture object. We add them here to get the correct behaviour.
1317 * (The per-texture object LOD bias was introduced in OpenGL 1.4
1318 * and is not present in the EXT_texture_object extension).
1319 */
1320 r300->hw.tex.filter_1.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1321 t->pp_txfilter_1 |
1322 translate_lod_bias(ctx->Texture.Unit[i].LodBias + t->base.LodBias);
1323 r300->hw.tex.size.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1324 t->pp_txsize;
1325 r300->hw.tex.format.cmd[R300_TEX_VALUE_0 +
1326 hw_tmu] = t->pp_txformat;
1327 r300->hw.tex.pitch.cmd[R300_TEX_VALUE_0 + hw_tmu] =
1328 t->pp_txpitch;
1329 r300->hw.textures[hw_tmu] = t;
1330
1331 if (t->tile_bits & R300_TXO_MACRO_TILE) {
1332 WARN_ONCE("macro tiling enabled!\n");
1333 }
1334
1335 if (t->tile_bits & R300_TXO_MICRO_TILE) {
1336 WARN_ONCE("micro tiling enabled!\n");
1337 }
1338
1339 r300->hw.tex.chroma_key.cmd[R300_TEX_VALUE_0 +
1340 hw_tmu] = 0x0;
1341 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0 +
1342 hw_tmu] =
1343 t->pp_border_color;
1344
1345 last_hw_tmu = hw_tmu;
1346
1347 hw_tmu++;
1348 }
1349 }
1350
1351 /* R3xx and R4xx chips require that the texture unit corresponding to
1352 * KIL instructions is really enabled.
1353 *
1354 * We do some fakery here and in the state atom emit logic to enable
1355 * the texture without tripping up the CS checker in the kernel.
1356 */
1357 if (r300->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV515) {
1358 if (ctx->FragmentProgram._Current->UsesKill && last_hw_tmu < 0) {
1359 last_hw_tmu++;
1360
1361 r300->hw.txe.cmd[R300_TXE_ENABLE] |= 1;
1362
1363 r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0] = 0;
1364 r300->hw.tex.chroma_key.cmd[R300_TEX_VALUE_0] = 0;
1365 r300->hw.tex.filter.cmd[R300_TEX_VALUE_0] = 0;
1366 r300->hw.tex.filter_1.cmd[R300_TEX_VALUE_0] = 0;
1367 r300->hw.tex.size.cmd[R300_TEX_VALUE_0] = 0; /* 1x1 texture */
1368 r300->hw.tex.format.cmd[R300_TEX_VALUE_0] = 0; /* A8 format */
1369 r300->hw.tex.pitch.cmd[R300_TEX_VALUE_0] = 0;
1370 }
1371 }
1372
1373 r300->hw.tex.filter.cmd[R300_TEX_CMD_0] =
1374 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FILTER0_0, last_hw_tmu + 1);
1375 r300->hw.tex.filter_1.cmd[R300_TEX_CMD_0] =
1376 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FILTER1_0, last_hw_tmu + 1);
1377 r300->hw.tex.size.cmd[R300_TEX_CMD_0] =
1378 cmdpacket0(r300->radeon.radeonScreen, R300_TX_SIZE_0, last_hw_tmu + 1);
1379 r300->hw.tex.format.cmd[R300_TEX_CMD_0] =
1380 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FORMAT_0, last_hw_tmu + 1);
1381 r300->hw.tex.pitch.cmd[R300_TEX_CMD_0] =
1382 cmdpacket0(r300->radeon.radeonScreen, R300_TX_FORMAT2_0, last_hw_tmu + 1);
1383 r300->hw.tex.offset.cmd[R300_TEX_CMD_0] =
1384 cmdpacket0(r300->radeon.radeonScreen, R300_TX_OFFSET_0, last_hw_tmu + 1);
1385 r300->hw.tex.chroma_key.cmd[R300_TEX_CMD_0] =
1386 cmdpacket0(r300->radeon.radeonScreen, R300_TX_CHROMA_KEY_0, last_hw_tmu + 1);
1387 r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] =
1388 cmdpacket0(r300->radeon.radeonScreen, R300_TX_BORDER_COLOR_0, last_hw_tmu + 1);
1389
1390 r300->vtbl.SetupFragmentShaderTextures(ctx, tmu_mappings);
1391
1392 if (RADEON_DEBUG & DEBUG_STATE)
1393 fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n",
1394 r300->hw.txe.cmd[R300_TXE_ENABLE], last_hw_tmu);
1395 }
1396
1397 union r300_outputs_written {
1398 GLuint vp_outputs; /* hw_tcl_on */
1399 DECLARE_RENDERINPUTS(index_bitset); /* !hw_tcl_on */
1400 };
1401
1402 #define R300_OUTPUTS_WRITTEN_TEST(ow, vp_result, tnl_attrib) \
1403 ((hw_tcl_on) ? (ow).vp_outputs & (1 << (vp_result)) : \
1404 RENDERINPUTS_TEST( (ow.index_bitset), (tnl_attrib) ))
1405
1406 static void r300SetupRSUnit(GLcontext * ctx)
1407 {
1408 r300ContextPtr r300 = R300_CONTEXT(ctx);
1409 union r300_outputs_written OutputsWritten;
1410 GLuint InputsRead;
1411 int fp_reg, high_rr;
1412 int col_ip, tex_ip;
1413 int rs_tex_count = 0;
1414 int i, col_fmt, hw_tcl_on;
1415
1416 hw_tcl_on = r300->options.hw_tcl_enabled;
1417
1418 if (hw_tcl_on)
1419 OutputsWritten.vp_outputs = r300->selected_vp->code.OutputsWritten;
1420 else
1421 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->render_inputs_bitset);
1422
1423 InputsRead = r300->selected_fp->InputsRead;
1424
1425 R300_STATECHANGE(r300, ri);
1426 R300_STATECHANGE(r300, rc);
1427 R300_STATECHANGE(r300, rr);
1428
1429 fp_reg = col_ip = tex_ip = col_fmt = 0;
1430
1431 r300->hw.rc.cmd[1] = 0;
1432 r300->hw.rc.cmd[2] = 0;
1433 for (i=0; i<R300_RR_CMDSIZE-1; ++i)
1434 r300->hw.rr.cmd[R300_RR_INST_0 + i] = 0;
1435
1436 for (i=0; i<R300_RI_CMDSIZE-1; ++i)
1437 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = 0;
1438
1439
1440 if (InputsRead & FRAG_BIT_COL0) {
1441 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1442 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R300_RS_COL_PTR(col_ip) | R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1443 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R300_RS_INST_COL_ID(col_ip) | R300_RS_INST_COL_CN_WRITE | R300_RS_INST_COL_ADDR(fp_reg);
1444 InputsRead &= ~FRAG_BIT_COL0;
1445 ++col_ip;
1446 ++fp_reg;
1447 } else {
1448 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1449 }
1450 }
1451
1452 if (InputsRead & FRAG_BIT_COL1) {
1453 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1454 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R300_RS_COL_PTR(col_ip) | R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1455 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R300_RS_INST_COL_ID(col_ip) | R300_RS_INST_COL_CN_WRITE | R300_RS_INST_COL_ADDR(fp_reg);
1456 InputsRead &= ~FRAG_BIT_COL1;
1457 ++col_ip;
1458 ++fp_reg;
1459 } else {
1460 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1461 }
1462 }
1463
1464 /* We always route 4 texcoord components */
1465 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1466 if (! ( InputsRead & FRAG_BIT_TEX(i) ) )
1467 continue;
1468
1469 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1470 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1471 continue;
1472 }
1473
1474 r300->hw.ri.cmd[R300_RI_INTERP_0 + tex_ip] |= R300_RS_SEL_S(0) | R300_RS_SEL_T(1) | R300_RS_SEL_R(2) | R300_RS_SEL_Q(3) | R300_RS_TEX_PTR(rs_tex_count);
1475 r300->hw.rr.cmd[R300_RR_INST_0 + tex_ip] |= R300_RS_INST_TEX_ID(tex_ip) | R300_RS_INST_TEX_CN_WRITE | R300_RS_INST_TEX_ADDR(fp_reg);
1476 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1477 rs_tex_count += 4;
1478 ++tex_ip;
1479 ++fp_reg;
1480 }
1481
1482 /* Setup default color if no color or tex was set */
1483 if (rs_tex_count == 0 && col_ip == 0) {
1484 r300->hw.rr.cmd[R300_RR_INST_0] = R300_RS_INST_COL_ID(0) | R300_RS_INST_COL_ADDR(0);
1485 r300->hw.ri.cmd[R300_RI_INTERP_0] = R300_RS_COL_PTR(0) | R300_RS_COL_FMT(R300_RS_COL_FMT_0001);
1486 ++col_ip;
1487 }
1488
1489 high_rr = (col_ip > tex_ip) ? col_ip : tex_ip;
1490 r300->hw.rc.cmd[1] |= (rs_tex_count << R300_IT_COUNT_SHIFT) | (col_ip << R300_IC_COUNT_SHIFT) | R300_HIRES_EN;
1491 r300->hw.rc.cmd[2] |= high_rr - 1;
1492
1493 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R300_RS_INST_0, high_rr);
1494 r300->hw.ri.cmd[R300_RI_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R300_RS_IP_0, high_rr);
1495
1496 if (InputsRead)
1497 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1498 }
1499
1500 static void r500SetupRSUnit(GLcontext * ctx)
1501 {
1502 r300ContextPtr r300 = R300_CONTEXT(ctx);
1503 union r300_outputs_written OutputsWritten;
1504 GLuint InputsRead;
1505 int fp_reg, high_rr;
1506 int col_ip, tex_ip;
1507 int rs_tex_count = 0;
1508 int i, col_fmt, hw_tcl_on;
1509
1510 hw_tcl_on = r300->options.hw_tcl_enabled;
1511
1512 if (hw_tcl_on)
1513 OutputsWritten.vp_outputs = r300->selected_vp->code.OutputsWritten;
1514 else
1515 RENDERINPUTS_COPY(OutputsWritten.index_bitset, r300->render_inputs_bitset);
1516
1517 InputsRead = r300->selected_fp->InputsRead;
1518
1519 R300_STATECHANGE(r300, ri);
1520 R300_STATECHANGE(r300, rc);
1521 R300_STATECHANGE(r300, rr);
1522
1523 fp_reg = col_ip = tex_ip = col_fmt = 0;
1524
1525 r300->hw.rc.cmd[1] = 0;
1526 r300->hw.rc.cmd[2] = 0;
1527 for (i=0; i<R300_RR_CMDSIZE-1; ++i)
1528 r300->hw.rr.cmd[R300_RR_INST_0 + i] = 0;
1529
1530 for (i=0; i<R500_RI_CMDSIZE-1; ++i)
1531 r300->hw.ri.cmd[R300_RI_INTERP_0 + i] = 0;
1532
1533
1534 if (InputsRead & FRAG_BIT_COL0) {
1535 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0)) {
1536 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R500_RS_COL_PTR(col_ip) | R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1537 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R500_RS_INST_COL_ID(col_ip) | R500_RS_INST_COL_CN_WRITE | R500_RS_INST_COL_ADDR(fp_reg);
1538 InputsRead &= ~FRAG_BIT_COL0;
1539 ++col_ip;
1540 ++fp_reg;
1541 } else {
1542 WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
1543 }
1544 }
1545
1546 if (InputsRead & FRAG_BIT_COL1) {
1547 if (R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1)) {
1548 r300->hw.ri.cmd[R300_RI_INTERP_0 + col_ip] = R500_RS_COL_PTR(col_ip) | R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
1549 r300->hw.rr.cmd[R300_RR_INST_0 + col_ip] = R500_RS_INST_COL_ID(col_ip) | R500_RS_INST_COL_CN_WRITE | R500_RS_INST_COL_ADDR(fp_reg);
1550 InputsRead &= ~FRAG_BIT_COL1;
1551 ++col_ip;
1552 ++fp_reg;
1553 } else {
1554 WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
1555 }
1556 }
1557
1558 /* We always route 4 texcoord components */
1559 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
1560 if (! ( InputsRead & FRAG_BIT_TEX(i) ) )
1561 continue;
1562
1563 if (!R300_OUTPUTS_WRITTEN_TEST(OutputsWritten, VERT_RESULT_TEX0 + i, _TNL_ATTRIB_TEX(i))) {
1564 WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
1565 continue;
1566 }
1567
1568 r300->hw.ri.cmd[R300_RI_INTERP_0 + tex_ip] |= ((rs_tex_count + 0) << R500_RS_IP_TEX_PTR_S_SHIFT) |
1569 ((rs_tex_count + 1) << R500_RS_IP_TEX_PTR_T_SHIFT) |
1570 ((rs_tex_count + 2) << R500_RS_IP_TEX_PTR_R_SHIFT) |
1571 ((rs_tex_count + 3) << R500_RS_IP_TEX_PTR_Q_SHIFT);
1572
1573 r300->hw.rr.cmd[R300_RR_INST_0 + tex_ip] |= R500_RS_INST_TEX_ID(tex_ip) | R500_RS_INST_TEX_CN_WRITE | R500_RS_INST_TEX_ADDR(fp_reg);
1574 InputsRead &= ~(FRAG_BIT_TEX0 << i);
1575 rs_tex_count += 4;
1576 ++tex_ip;
1577 ++fp_reg;
1578 }
1579
1580 /* Setup default color if no color or tex was set */
1581 if (rs_tex_count == 0 && col_ip == 0) {
1582 r300->hw.rr.cmd[R300_RR_INST_0] = R500_RS_INST_COL_ID(0) | R500_RS_INST_COL_ADDR(0);
1583 r300->hw.ri.cmd[R300_RI_INTERP_0] = R500_RS_COL_PTR(0) | R500_RS_COL_FMT(R300_RS_COL_FMT_0001);
1584 ++col_ip;
1585 }
1586
1587 high_rr = (col_ip > tex_ip) ? col_ip : tex_ip;
1588 r300->hw.rc.cmd[1] = (rs_tex_count << R300_IT_COUNT_SHIFT) | (col_ip << R300_IC_COUNT_SHIFT) | R300_HIRES_EN;
1589 r300->hw.rc.cmd[2] = 0xC0 | (high_rr - 1);
1590
1591 r300->hw.rr.cmd[R300_RR_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R500_RS_INST_0, high_rr);
1592 r300->hw.ri.cmd[R300_RI_CMD_0] = cmdpacket0(r300->radeon.radeonScreen, R500_RS_IP_0, high_rr);
1593
1594 if (InputsRead)
1595 WARN_ONCE("Don't know how to satisfy InputsRead=0x%08x\n", InputsRead);
1596 }
1597
1598 #define MIN3(a, b, c) ((a) < (b) ? MIN2(a, c) : MIN2(b, c))
1599
1600 void r300VapCntl(r300ContextPtr rmesa, GLuint input_count,
1601 GLuint output_count, GLuint temp_count)
1602 {
1603 int vtx_mem_size;
1604 int pvs_num_slots;
1605 int pvs_num_cntrls;
1606
1607 /* Flush PVS engine before changing PVS_NUM_SLOTS, PVS_NUM_CNTRLS.
1608 * See r500 docs 6.5.2 - done in emit */
1609
1610 /* avoid division by zero */
1611 if (input_count == 0) input_count = 1;
1612 if (output_count == 0) output_count = 1;
1613 if (temp_count == 0) temp_count = 1;
1614
1615 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1616 vtx_mem_size = 128;
1617 else
1618 vtx_mem_size = 72;
1619
1620 pvs_num_slots = MIN3(10, vtx_mem_size/input_count, vtx_mem_size/output_count);
1621 pvs_num_cntrls = MIN2(6, vtx_mem_size/temp_count);
1622
1623 R300_STATECHANGE(rmesa, vap_cntl);
1624 if (rmesa->options.hw_tcl_enabled) {
1625 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] =
1626 (pvs_num_slots << R300_PVS_NUM_SLOTS_SHIFT) |
1627 (pvs_num_cntrls << R300_PVS_NUM_CNTLRS_SHIFT) |
1628 (12 << R300_VF_MAX_VTX_NUM_SHIFT);
1629 if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)
1630 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= R500_TCL_STATE_OPTIMIZATION;
1631 } else
1632 /* not sure about non-tcl */
1633 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] = ((10 << R300_PVS_NUM_SLOTS_SHIFT) |
1634 (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
1635 (5 << R300_VF_MAX_VTX_NUM_SHIFT));
1636
1637 if (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV515)
1638 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (2 << R300_PVS_NUM_FPUS_SHIFT);
1639 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV530) ||
1640 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV560) ||
1641 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV570))
1642 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (5 << R300_PVS_NUM_FPUS_SHIFT);
1643 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV410) ||
1644 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420))
1645 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (6 << R300_PVS_NUM_FPUS_SHIFT);
1646 else if ((rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R520) ||
1647 (rmesa->radeon.radeonScreen->chip_family == CHIP_FAMILY_R580))
1648 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (8 << R300_PVS_NUM_FPUS_SHIFT);
1649 else
1650 rmesa->hw.vap_cntl.cmd[R300_VAP_CNTL_INSTR] |= (4 << R300_PVS_NUM_FPUS_SHIFT);
1651
1652 }
1653
1654 /**
1655 * Enable/Disable states.
1656 *
1657 * \note Mesa already filters redundant calls to this function.
1658 */
1659 static void r300Enable(GLcontext * ctx, GLenum cap, GLboolean state)
1660 {
1661 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1662 if (RADEON_DEBUG & DEBUG_STATE)
1663 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
1664 _mesa_lookup_enum_by_nr(cap),
1665 state ? "GL_TRUE" : "GL_FALSE");
1666
1667 switch (cap) {
1668 case GL_ALPHA_TEST:
1669 r300SetAlphaState(ctx);
1670 break;
1671 case GL_COLOR_LOGIC_OP:
1672 r300SetLogicOpState(ctx);
1673 /* fall-through, because logic op overrides blending */
1674 case GL_BLEND:
1675 r300SetBlendState(ctx);
1676 break;
1677 case GL_CLIP_PLANE0:
1678 case GL_CLIP_PLANE1:
1679 case GL_CLIP_PLANE2:
1680 case GL_CLIP_PLANE3:
1681 case GL_CLIP_PLANE4:
1682 case GL_CLIP_PLANE5:
1683 r300SetClipPlaneState(ctx, cap, state);
1684 break;
1685 case GL_CULL_FACE:
1686 r300UpdateCulling(ctx);
1687 break;
1688 case GL_DEPTH_TEST:
1689 r300SetDepthState(ctx);
1690 break;
1691 case GL_LINE_SMOOTH:
1692 if (rmesa->options.conformance_mode)
1693 r300SwitchFallback(ctx, R300_FALLBACK_LINE_SMOOTH, ctx->Line.SmoothFlag);
1694 break;
1695 case GL_LINE_STIPPLE:
1696 if (rmesa->options.conformance_mode)
1697 r300SwitchFallback(ctx, R300_FALLBACK_LINE_STIPPLE, ctx->Line.StippleFlag);
1698 break;
1699 case GL_POINT_SMOOTH:
1700 if (rmesa->options.conformance_mode)
1701 r300SwitchFallback(ctx, R300_FALLBACK_POINT_SMOOTH, ctx->Point.SmoothFlag);
1702 break;
1703 case GL_POLYGON_SMOOTH:
1704 if (rmesa->options.conformance_mode)
1705 r300SwitchFallback(ctx, R300_FALLBACK_POLYGON_SMOOTH, ctx->Polygon.SmoothFlag);
1706 break;
1707 case GL_POLYGON_STIPPLE:
1708 if (rmesa->options.conformance_mode)
1709 r300SwitchFallback(ctx, R300_FALLBACK_POLYGON_STIPPLE, ctx->Polygon.StippleFlag);
1710 break;
1711 case GL_POLYGON_OFFSET_POINT:
1712 case GL_POLYGON_OFFSET_LINE:
1713 case GL_POLYGON_OFFSET_FILL:
1714 r300SetPolygonOffsetState(ctx, state);
1715 break;
1716 case GL_SCISSOR_TEST:
1717 radeon_firevertices(&rmesa->radeon);
1718 rmesa->radeon.state.scissor.enabled = state;
1719 radeonUpdateScissor( ctx );
1720 break;
1721 case GL_STENCIL_TEST:
1722 r300SetStencilState(ctx, state);
1723 break;
1724 default:
1725 break;
1726 }
1727 }
1728
1729 /**
1730 * Completely recalculates hardware state based on the Mesa state.
1731 */
1732 static void r300ResetHwState(r300ContextPtr r300)
1733 {
1734 GLcontext *ctx = r300->radeon.glCtx;
1735 int has_tcl;
1736
1737 has_tcl = r300->options.hw_tcl_enabled;
1738
1739 if (RADEON_DEBUG & DEBUG_STATE)
1740 fprintf(stderr, "%s\n", __FUNCTION__);
1741
1742 radeon_firevertices(&r300->radeon);
1743
1744 r300ColorMask(ctx,
1745 ctx->Color.ColorMask[RCOMP],
1746 ctx->Color.ColorMask[GCOMP],
1747 ctx->Color.ColorMask[BCOMP], ctx->Color.ColorMask[ACOMP]);
1748
1749 r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1750 r300DepthMask(ctx, ctx->Depth.Mask);
1751 r300DepthFunc(ctx, ctx->Depth.Func);
1752
1753 /* stencil */
1754 r300Enable(ctx, GL_STENCIL_TEST, ctx->Stencil._Enabled);
1755 r300StencilMaskSeparate(ctx, 0, ctx->Stencil.WriteMask[0]);
1756 r300StencilFuncSeparate(ctx, 0, ctx->Stencil.Function[0],
1757 ctx->Stencil.Ref[0], ctx->Stencil.ValueMask[0]);
1758 r300StencilOpSeparate(ctx, 0, ctx->Stencil.FailFunc[0],
1759 ctx->Stencil.ZFailFunc[0],
1760 ctx->Stencil.ZPassFunc[0]);
1761
1762 r300UpdateCulling(ctx);
1763
1764 r300SetBlendState(ctx);
1765 r300SetLogicOpState(ctx);
1766
1767 r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1768 r300Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);
1769
1770 r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1771 | R300_VPORT_X_OFFSET_ENA
1772 | R300_VPORT_Y_SCALE_ENA
1773 | R300_VPORT_Y_OFFSET_ENA
1774 | R300_VPORT_Z_SCALE_ENA
1775 | R300_VPORT_Z_OFFSET_ENA | R300_VTX_W0_FMT;
1776 r300->hw.vte.cmd[2] = 0x00000008;
1777
1778 r300->hw.vap_vf_max_vtx_indx.cmd[1] = 0x00FFFFFF;
1779 r300->hw.vap_vf_max_vtx_indx.cmd[2] = 0x00000000;
1780
1781 #ifdef MESA_LITTLE_ENDIAN
1782 r300->hw.vap_cntl_status.cmd[1] = R300_VC_NO_SWAP;
1783 #else
1784 r300->hw.vap_cntl_status.cmd[1] = R300_VC_32BIT_SWAP;
1785 #endif
1786
1787 /* disable VAP/TCL on non-TCL capable chips */
1788 if (!has_tcl)
1789 r300->hw.vap_cntl_status.cmd[1] |= R300_VAP_TCL_BYPASS;
1790
1791 r300->hw.vap_psc_sgn_norm_cntl.cmd[1] = 0xAAAAAAAA;
1792
1793 /* XXX: Other families? */
1794 if (has_tcl) {
1795 r300->hw.vap_clip_cntl.cmd[1] = R300_PS_UCP_MODE_DIST_COP;
1796
1797 r300->hw.vap_clip.cmd[1] = r300PackFloat32(1.0); /* X */
1798 r300->hw.vap_clip.cmd[2] = r300PackFloat32(1.0); /* X */
1799 r300->hw.vap_clip.cmd[3] = r300PackFloat32(1.0); /* Y */
1800 r300->hw.vap_clip.cmd[4] = r300PackFloat32(1.0); /* Y */
1801
1802 switch (r300->radeon.radeonScreen->chip_family) {
1803 case CHIP_FAMILY_R300:
1804 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_R300;
1805 break;
1806 default:
1807 r300->hw.vap_pvs_vtx_timeout_reg.cmd[1] = R300_2288_RV350;
1808 break;
1809 }
1810 }
1811
1812 r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1813 | R300_GB_LINE_STUFF_ENABLE
1814 | R300_GB_TRIANGLE_STUFF_ENABLE;
1815
1816 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1817 r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1818
1819 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] =
1820 R300_GB_TILE_ENABLE | R300_GB_TILE_SIZE_16 /*| R300_GB_SUBPIXEL_1_16*/;
1821 switch (r300->radeon.radeonScreen->num_gb_pipes) {
1822 case 1:
1823 default:
1824 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1825 R300_GB_TILE_PIPE_COUNT_RV300;
1826 break;
1827 case 2:
1828 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1829 R300_GB_TILE_PIPE_COUNT_R300;
1830 break;
1831 case 3:
1832 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1833 R300_GB_TILE_PIPE_COUNT_R420_3P;
1834 break;
1835 case 4:
1836 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] |=
1837 R300_GB_TILE_PIPE_COUNT_R420;
1838 break;
1839 }
1840
1841 /* XXX: Enable anti-aliasing? */
1842 r300->hw.gb_misc2.cmd[R300_GB_MISC2_AA_CONFIG] = GB_AA_CONFIG_AA_DISABLE;
1843 r300->hw.gb_misc2.cmd[R300_GB_MISC2_SELECT] = 0;
1844
1845 r300->hw.ga_point_s0.cmd[1] = r300PackFloat32(0.0);
1846 r300->hw.ga_point_s0.cmd[2] = r300PackFloat32(0.0);
1847 r300->hw.ga_point_s0.cmd[3] = r300PackFloat32(1.0);
1848 r300->hw.ga_point_s0.cmd[4] = r300PackFloat32(1.0);
1849
1850 r300->hw.ga_triangle_stipple.cmd[1] = 0x00050005;
1851
1852 r300PointSize(ctx, 1.0);
1853
1854 r300->hw.ga_point_minmax.cmd[1] = 0x18000006;
1855 r300->hw.ga_point_minmax.cmd[2] = 0x00020006;
1856 r300->hw.ga_point_minmax.cmd[3] = r300PackFloat32(1.0 / 192.0);
1857
1858 r300LineWidth(ctx, 1.0);
1859
1860 r300->hw.ga_line_stipple.cmd[1] = 0;
1861 r300->hw.ga_line_stipple.cmd[2] = r300PackFloat32(0.0);
1862 r300->hw.ga_line_stipple.cmd[3] = r300PackFloat32(1.0);
1863
1864 r300ShadeModel(ctx, ctx->Light.ShadeModel);
1865
1866 r300PolygonMode(ctx, GL_FRONT, ctx->Polygon.FrontMode);
1867 r300PolygonMode(ctx, GL_BACK, ctx->Polygon.BackMode);
1868 r300->hw.zbias_cntl.cmd[1] = 0x00000000;
1869
1870 r300PolygonOffset(ctx, ctx->Polygon.OffsetFactor,
1871 ctx->Polygon.OffsetUnits);
1872 r300Enable(ctx, GL_POLYGON_OFFSET_POINT, ctx->Polygon.OffsetPoint);
1873 r300Enable(ctx, GL_POLYGON_OFFSET_LINE, ctx->Polygon.OffsetLine);
1874 r300Enable(ctx, GL_POLYGON_OFFSET_FILL, ctx->Polygon.OffsetFill);
1875
1876 r300->hw.su_depth_scale.cmd[1] = 0x4B7FFFFF;
1877 r300->hw.su_depth_scale.cmd[2] = 0x00000000;
1878
1879 r300->hw.sc_hyperz.cmd[1] = 0x0000001C;
1880 r300->hw.sc_hyperz.cmd[2] = 0x2DA49525;
1881
1882 r300->hw.sc_screendoor.cmd[1] = 0x00FFFFFF;
1883
1884 r300->hw.us_out_fmt.cmd[1] = R500_OUT_FMT_C4_8 |
1885 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1886 r300->hw.us_out_fmt.cmd[2] = R500_OUT_FMT_UNUSED |
1887 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1888 r300->hw.us_out_fmt.cmd[3] = R500_OUT_FMT_UNUSED |
1889 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1890 r300->hw.us_out_fmt.cmd[4] = R500_OUT_FMT_UNUSED |
1891 R500_C0_SEL_B | R500_C1_SEL_G | R500_C2_SEL_R | R500_C3_SEL_A;
1892 r300->hw.us_out_fmt.cmd[5] = R300_W_FMT_W0 | R300_W_SRC_US;
1893
1894 /* disable fog unit */
1895 r300->hw.fogs.cmd[R300_FOGS_STATE] = 0;
1896 r300->hw.fg_depth_src.cmd[1] = R300_FG_DEPTH_SRC_SCAN;
1897
1898 r300->hw.rb3d_cctl.cmd[1] = 0;
1899
1900 r300BlendColor(ctx, ctx->Color.BlendColor);
1901
1902 r300->hw.rb3d_dither_ctl.cmd[1] = 0;
1903 r300->hw.rb3d_dither_ctl.cmd[2] = 0;
1904 r300->hw.rb3d_dither_ctl.cmd[3] = 0;
1905 r300->hw.rb3d_dither_ctl.cmd[4] = 0;
1906 r300->hw.rb3d_dither_ctl.cmd[5] = 0;
1907 r300->hw.rb3d_dither_ctl.cmd[6] = 0;
1908 r300->hw.rb3d_dither_ctl.cmd[7] = 0;
1909 r300->hw.rb3d_dither_ctl.cmd[8] = 0;
1910 r300->hw.rb3d_dither_ctl.cmd[9] = 0;
1911
1912 r300->hw.rb3d_aaresolve_ctl.cmd[1] = 0;
1913
1914 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[1] = 0x00000000;
1915 r300->hw.rb3d_discard_src_pixel_lte_threshold.cmd[2] = 0xffffffff;
1916
1917 r300->hw.zb_depthclearvalue.cmd[1] = 0;
1918
1919 r300->hw.zstencil_format.cmd[2] = R300_ZTOP_DISABLE;
1920 r300->hw.zstencil_format.cmd[3] = 0x00000003;
1921 r300->hw.zstencil_format.cmd[4] = 0x00000000;
1922 r300SetEarlyZState(ctx);
1923
1924 r300->hw.zb_zmask.cmd[1] = 0;
1925 r300->hw.zb_zmask.cmd[2] = 0;
1926
1927 r300->hw.zb_hiz_offset.cmd[1] = 0;
1928
1929 r300->hw.zb_hiz_pitch.cmd[1] = 0;
1930
1931 r300VapCntl(r300, 0, 0, 0);
1932 if (has_tcl) {
1933 r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1934 r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1935 r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1936 r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1937 }
1938
1939 r300->radeon.hw.all_dirty = GL_TRUE;
1940 }
1941
1942 void r300UpdateShaders(r300ContextPtr rmesa)
1943 {
1944 GLcontext *ctx = rmesa->radeon.glCtx;
1945
1946 /* should only happenen once, just after context is created */
1947 /* TODO: shouldn't we fallback to sw here? */
1948 if (!ctx->FragmentProgram._Current) {
1949 _mesa_fprintf(stderr, "No ctx->FragmentProgram._Current!!\n");
1950 return;
1951 }
1952
1953 {
1954 struct r300_fragment_program *fp;
1955
1956 fp = r300SelectAndTranslateFragmentShader(ctx);
1957
1958 r300SwitchFallback(ctx, R300_FALLBACK_FRAGMENT_PROGRAM, fp->error);
1959 }
1960
1961 if (rmesa->options.hw_tcl_enabled) {
1962 struct r300_vertex_program *vp;
1963
1964 if (rmesa->radeon.NewGLState) {
1965 int i;
1966 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
1967 rmesa->temp_attrib[i] =
1968 TNL_CONTEXT(ctx)->vb.AttribPtr[i];
1969 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
1970 &rmesa->dummy_attrib[i];
1971 }
1972
1973 _tnl_UpdateFixedFunctionProgram(ctx);
1974
1975 for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) {
1976 TNL_CONTEXT(ctx)->vb.AttribPtr[i] =
1977 rmesa->temp_attrib[i];
1978 }
1979 }
1980
1981 vp = r300SelectAndTranslateVertexShader(ctx);
1982
1983 r300SwitchFallback(ctx, R300_FALLBACK_VERTEX_PROGRAM, vp->error);
1984 }
1985
1986 r300UpdateStateParameters(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
1987 rmesa->radeon.NewGLState = 0;
1988 }
1989
1990 static const GLfloat *get_fragmentprogram_constant(GLcontext *ctx, GLuint index, GLfloat * buffer)
1991 {
1992 static const GLfloat dummy[4] = { 0, 0, 0, 0 };
1993 r300ContextPtr rmesa = R300_CONTEXT(ctx);
1994 struct rc_constant * rcc = &rmesa->selected_fp->code.constants.Constants[index];
1995
1996 switch(rcc->Type) {
1997 case RC_CONSTANT_EXTERNAL:
1998 return ctx->FragmentProgram._Current->Base.Parameters->ParameterValues[rcc->u.External];
1999 case RC_CONSTANT_IMMEDIATE:
2000 return rcc->u.Immediate;
2001 case RC_CONSTANT_STATE:
2002 switch(rcc->u.State[0]) {
2003 case RC_STATE_SHADOW_AMBIENT: {
2004 const int unit = (int) rcc->u.State[1];
2005 const struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current;
2006 if (texObj) {
2007 buffer[0] =
2008 buffer[1] =
2009 buffer[2] =
2010 buffer[3] = texObj->CompareFailValue;
2011 }
2012 return buffer;
2013 }
2014
2015 case RC_STATE_R300_WINDOW_DIMENSION: {
2016 __DRIdrawablePrivate * drawable = radeon_get_drawable(&rmesa->radeon);
2017 buffer[0] = drawable->w * 0.5f; /* width*0.5 */
2018 buffer[1] = drawable->h * 0.5f; /* height*0.5 */
2019 buffer[2] = 0.5F; /* for moving range [-1 1] -> [0 1] */
2020 buffer[3] = 1.0F; /* not used */
2021 return buffer;
2022 }
2023
2024 case RC_STATE_R300_TEXRECT_FACTOR: {
2025 struct gl_texture_object *t =
2026 ctx->Texture.Unit[rcc->u.State[1]].CurrentTex[TEXTURE_RECT_INDEX];
2027
2028 if (t && t->Image[0][t->BaseLevel]) {
2029 struct gl_texture_image *image =
2030 t->Image[0][t->BaseLevel];
2031 buffer[0] = 1.0 / image->Width2;
2032 buffer[1] = 1.0 / image->Height2;
2033 } else {
2034 buffer[0] = 1.0;
2035 buffer[1] = 1.0;
2036 }
2037 buffer[2] = 1.0;
2038 buffer[3] = 1.0;
2039 return buffer;
2040 }
2041 }
2042 }
2043
2044 return dummy;
2045 }
2046
2047
2048 static void r300SetupPixelShader(GLcontext *ctx)
2049 {
2050 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2051 struct r300_fragment_program *fp = rmesa->selected_fp;
2052 struct r300_fragment_program_code *code;
2053 int i;
2054
2055 code = &fp->code.code.r300;
2056
2057 R300_STATECHANGE(rmesa, fpi[0]);
2058 R300_STATECHANGE(rmesa, fpi[1]);
2059 R300_STATECHANGE(rmesa, fpi[2]);
2060 R300_STATECHANGE(rmesa, fpi[3]);
2061 rmesa->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_RGB_INST_0, code->alu.length);
2062 rmesa->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_RGB_ADDR_0, code->alu.length);
2063 rmesa->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_ALPHA_INST_0, code->alu.length);
2064 rmesa->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_US_ALU_ALPHA_ADDR_0, code->alu.length);
2065 for (i = 0; i < code->alu.length; i++) {
2066 rmesa->hw.fpi[0].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].rgb_inst;
2067 rmesa->hw.fpi[1].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].rgb_addr;
2068 rmesa->hw.fpi[2].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].alpha_inst;
2069 rmesa->hw.fpi[3].cmd[R300_FPI_INSTR_0 + i] = code->alu.inst[i].alpha_addr;
2070 }
2071
2072 R300_STATECHANGE(rmesa, fp);
2073 rmesa->hw.fp.cmd[R300_FP_CNTL0] = code->config;
2074 rmesa->hw.fp.cmd[R300_FP_CNTL1] = code->pixsize;
2075 rmesa->hw.fp.cmd[R300_FP_CNTL2] = code->code_offset;
2076 for (i = 0; i < 4; i++)
2077 rmesa->hw.fp.cmd[R300_FP_NODE0 + i] = code->code_addr[i];
2078
2079 R300_STATECHANGE(rmesa, fpp);
2080 rmesa->hw.fpp.cmd[R300_FPP_CMD_0] = cmdpacket0(rmesa->radeon.radeonScreen, R300_PFS_PARAM_0_X, fp->code.constants.Count * 4);
2081 for (i = 0; i < fp->code.constants.Count; i++) {
2082 GLfloat buffer[4];
2083 const GLfloat *constant = get_fragmentprogram_constant(ctx, i, buffer);
2084 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat24(constant[0]);
2085 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat24(constant[1]);
2086 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat24(constant[2]);
2087 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat24(constant[3]);
2088 }
2089 }
2090
2091 #define bump_r500fp_count(ptr, new_count) do{\
2092 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2093 int _nc=(new_count)/6; \
2094 assert(_nc < 256); \
2095 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2096 } while(0)
2097
2098 #define bump_r500fp_const_count(ptr, new_count) do{\
2099 drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
2100 int _nc=(new_count)/4; \
2101 assert(_nc < 256); \
2102 if(_nc>_p->r500fp.count)_p->r500fp.count=_nc;\
2103 } while(0)
2104
2105 static void r500SetupPixelShader(GLcontext *ctx)
2106 {
2107 r300ContextPtr rmesa = R300_CONTEXT(ctx);
2108 struct r300_fragment_program *fp = rmesa->selected_fp;
2109 int i;
2110 struct r500_fragment_program_code *code;
2111
2112 ((drm_r300_cmd_header_t *) rmesa->hw.r500fp.cmd)->r500fp.count = 0;
2113 ((drm_r300_cmd_header_t *) rmesa->hw.r500fp_const.cmd)->r500fp.count = 0;
2114
2115 code = &fp->code.code.r500;
2116
2117 R300_STATECHANGE(rmesa, fp);
2118 rmesa->hw.fp.cmd[R500_FP_PIXSIZE] = code->max_temp_idx;
2119
2120 rmesa->hw.fp.cmd[R500_FP_CODE_ADDR] =
2121 R500_US_CODE_START_ADDR(0) |
2122 R500_US_CODE_END_ADDR(code->inst_end);
2123 rmesa->hw.fp.cmd[R500_FP_CODE_RANGE] =
2124 R500_US_CODE_RANGE_ADDR(0) |
2125 R500_US_CODE_RANGE_SIZE(code->inst_end);
2126 rmesa->hw.fp.cmd[R500_FP_CODE_OFFSET] =
2127 R500_US_CODE_OFFSET_ADDR(0);
2128
2129 R300_STATECHANGE(rmesa, r500fp);
2130 /* Emit our shader... */
2131 for (i = 0; i < code->inst_end+1; i++) {
2132 rmesa->hw.r500fp.cmd[i*6+1] = code->inst[i].inst0;
2133 rmesa->hw.r500fp.cmd[i*6+2] = code->inst[i].inst1;
2134 rmesa->hw.r500fp.cmd[i*6+3] = code->inst[i].inst2;
2135 rmesa->hw.r500fp.cmd[i*6+4] = code->inst[i].inst3;
2136 rmesa->hw.r500fp.cmd[i*6+5] = code->inst[i].inst4;
2137 rmesa->hw.r500fp.cmd[i*6+6] = code->inst[i].inst5;
2138 }
2139
2140 bump_r500fp_count(rmesa->hw.r500fp.cmd, (code->inst_end + 1) * 6);
2141
2142 R300_STATECHANGE(rmesa, r500fp_const);
2143 for (i = 0; i < fp->code.constants.Count; i++) {
2144 GLfloat buffer[4];
2145 const GLfloat *constant = get_fragmentprogram_constant(ctx, i, buffer);
2146 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 0] = r300PackFloat32(constant[0]);
2147 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 1] = r300PackFloat32(constant[1]);
2148 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 2] = r300PackFloat32(constant[2]);
2149 rmesa->hw.r500fp_const.cmd[R300_FPP_PARAM_0 + 4 * i + 3] = r300PackFloat32(constant[3]);
2150 }
2151 bump_r500fp_const_count(rmesa->hw.r500fp_const.cmd, fp->code.constants.Count * 4);
2152 }
2153
2154 void r300SetupVAP(GLcontext *ctx, GLuint InputsRead, GLuint OutputsWritten)
2155 {
2156 r300ContextPtr rmesa = R300_CONTEXT( ctx );
2157 struct vertex_attribute *attrs = rmesa->vbuf.attribs;
2158 int i, j, reg_count;
2159 uint32_t *vir0 = &rmesa->hw.vir[0].cmd[1];
2160 uint32_t *vir1 = &rmesa->hw.vir[1].cmd[1];
2161
2162 for (i = 0; i < R300_VIR_CMDSIZE-1; ++i)
2163 vir0[i] = vir1[i] = 0;
2164
2165 for (i = 0, j = 0; i < rmesa->vbuf.num_attribs; ++i) {
2166 int tmp;
2167
2168 tmp = attrs[i].data_type | (attrs[i].dst_loc << R300_DST_VEC_LOC_SHIFT);
2169 if (attrs[i]._signed)
2170 tmp |= R300_SIGNED;
2171 if (attrs[i].normalize)
2172 tmp |= R300_NORMALIZE;
2173
2174 if (i % 2 == 0) {
2175 vir0[j] = tmp << R300_DATA_TYPE_0_SHIFT;
2176 vir1[j] = attrs[i].swizzle | (attrs[i].write_mask << R300_WRITE_ENA_SHIFT);
2177 } else {
2178 vir0[j] |= tmp << R300_DATA_TYPE_1_SHIFT;
2179 vir1[j] |= (attrs[i].swizzle | (attrs[i].write_mask << R300_WRITE_ENA_SHIFT)) << R300_SWIZZLE1_SHIFT;
2180 ++j;
2181 }
2182 }
2183
2184 reg_count = (rmesa->vbuf.num_attribs + 1) >> 1;
2185 if (rmesa->vbuf.num_attribs % 2 != 0) {
2186 vir0[reg_count-1] |= R300_LAST_VEC << R300_DATA_TYPE_0_SHIFT;
2187 } else {
2188 vir0[reg_count-1] |= R300_LAST_VEC << R300_DATA_TYPE_1_SHIFT;
2189 }
2190
2191 R300_STATECHANGE(rmesa, vir[0]);
2192 R300_STATECHANGE(rmesa, vir[1]);
2193 R300_STATECHANGE(rmesa, vof);
2194 R300_STATECHANGE(rmesa, vic);
2195
2196 if (rmesa->radeon.radeonScreen->kernel_mm) {
2197 rmesa->hw.vir[0].cmd[0] &= 0xC000FFFF;
2198 rmesa->hw.vir[1].cmd[0] &= 0xC000FFFF;
2199 rmesa->hw.vir[0].cmd[0] |= (reg_count & 0x3FFF) << 16;
2200 rmesa->hw.vir[1].cmd[0] |= (reg_count & 0x3FFF) << 16;
2201 } else {
2202 ((drm_r300_cmd_header_t *) rmesa->hw.vir[0].cmd)->packet0.count = reg_count;
2203 ((drm_r300_cmd_header_t *) rmesa->hw.vir[1].cmd)->packet0.count = reg_count;
2204 }
2205
2206 rmesa->hw.vic.cmd[R300_VIC_CNTL_0] = r300VAPInputCntl0(ctx, InputsRead);
2207 rmesa->hw.vic.cmd[R300_VIC_CNTL_1] = r300VAPInputCntl1(ctx, InputsRead);
2208 rmesa->hw.vof.cmd[R300_VOF_CNTL_0] = r300VAPOutputCntl0(ctx, OutputsWritten);
2209 rmesa->hw.vof.cmd[R300_VOF_CNTL_1] = r300VAPOutputCntl1(ctx, OutputsWritten);
2210 }
2211
2212 void r300UpdateShaderStates(r300ContextPtr rmesa)
2213 {
2214 GLcontext *ctx;
2215 ctx = rmesa->radeon.glCtx;
2216
2217 /* should only happenen once, just after context is created */
2218 if (!ctx->FragmentProgram._Current)
2219 return;
2220
2221 r300SetEarlyZState(ctx);
2222
2223 r300SetupTextures(ctx);
2224
2225 rmesa->vtbl.SetupPixelShader(ctx);
2226
2227 rmesa->vtbl.SetupRSUnit(ctx);
2228
2229 if (rmesa->options.hw_tcl_enabled) {
2230 r300SetupVertexProgram(rmesa);
2231 }
2232 }
2233
2234 /**
2235 * Called by Mesa after an internal state update.
2236 */
2237 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
2238 {
2239 r300ContextPtr r300 = R300_CONTEXT(ctx);
2240
2241 _swrast_InvalidateState(ctx, new_state);
2242 _swsetup_InvalidateState(ctx, new_state);
2243 _vbo_InvalidateState(ctx, new_state);
2244 _tnl_InvalidateState(ctx, new_state);
2245
2246 if (new_state & _NEW_BUFFERS) {
2247 _mesa_update_framebuffer(ctx);
2248 /* this updates the DrawBuffer's Width/Height if it's a FBO */
2249 _mesa_update_draw_buffer_bounds(ctx);
2250
2251 R300_STATECHANGE(r300, cb);
2252 R300_STATECHANGE(r300, zb);
2253 }
2254
2255 r300->radeon.NewGLState |= new_state;
2256 }
2257
2258 /**
2259 * Calculate initial hardware state and register state functions.
2260 * Assumes that the command buffer and state atoms have been
2261 * initialized already.
2262 */
2263 void r300InitState(r300ContextPtr r300)
2264 {
2265 r300ResetHwState(r300);
2266 }
2267
2268 static void r300RenderMode(GLcontext * ctx, GLenum mode)
2269 {
2270 r300SwitchFallback(ctx, R300_FALLBACK_RENDER_MODE, ctx->RenderMode != GL_RENDER);
2271 }
2272
2273 /**
2274 * Initialize driver's state callback functions
2275 */
2276 void r300InitStateFuncs(struct dd_function_table *functions)
2277 {
2278
2279 functions->UpdateState = r300InvalidateState;
2280 functions->AlphaFunc = r300AlphaFunc;
2281 functions->BlendColor = r300BlendColor;
2282 functions->BlendEquationSeparate = r300BlendEquationSeparate;
2283 functions->BlendFuncSeparate = r300BlendFuncSeparate;
2284 functions->Enable = r300Enable;
2285 functions->ColorMask = r300ColorMask;
2286 functions->DepthFunc = r300DepthFunc;
2287 functions->DepthMask = r300DepthMask;
2288 functions->CullFace = r300CullFace;
2289 functions->FrontFace = r300FrontFace;
2290 functions->ShadeModel = r300ShadeModel;
2291 functions->LogicOpcode = r300LogicOpcode;
2292
2293 /* ARB_point_parameters */
2294 functions->PointParameterfv = r300PointParameter;
2295
2296 /* Stencil related */
2297 functions->StencilFuncSeparate = r300StencilFuncSeparate;
2298 functions->StencilMaskSeparate = r300StencilMaskSeparate;
2299 functions->StencilOpSeparate = r300StencilOpSeparate;
2300
2301 /* Viewport related */
2302 functions->Viewport = r300Viewport;
2303 functions->DepthRange = r300DepthRange;
2304 functions->PointSize = r300PointSize;
2305 functions->LineWidth = r300LineWidth;
2306
2307 functions->PolygonOffset = r300PolygonOffset;
2308 functions->PolygonMode = r300PolygonMode;
2309
2310 functions->RenderMode = r300RenderMode;
2311
2312 functions->ClipPlane = r300ClipPlane;
2313 functions->Scissor = radeonScissor;
2314
2315 functions->DrawBuffer = radeonDrawBuffer;
2316 functions->ReadBuffer = radeonReadBuffer;
2317 }
2318
2319 void r300InitShaderFunctions(r300ContextPtr r300)
2320 {
2321 if (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
2322 r300->vtbl.SetupRSUnit = r500SetupRSUnit;
2323 r300->vtbl.SetupPixelShader = r500SetupPixelShader;
2324 r300->vtbl.SetupFragmentShaderTextures = r500SetupFragmentShaderTextures;
2325 } else {
2326 r300->vtbl.SetupRSUnit = r300SetupRSUnit;
2327 r300->vtbl.SetupPixelShader = r300SetupPixelShader;
2328 r300->vtbl.SetupFragmentShaderTextures = r300SetupFragmentShaderTextures;
2329 }
2330 }