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  * Authors:
  34  *   Nicolai Haehnle <prefect_@gmx.net>
  35  */
  36
  37 #include "glheader.h"
  38 #include "state.h"
  39 #include "imports.h"
  40 #include "enums.h"
  41 #include "macros.h"
  42 #include "context.h"
  43 #include "dd.h"
  44 #include "simple_list.h"
  45
  46 #include "api_arrayelt.h"
  47 #include "swrast/swrast.h"
  48 #include "swrast_setup/swrast_setup.h"
  49 #include "array_cache/acache.h"
  50 #include "tnl/tnl.h"
  51 #include "texformat.h"
  52
  53 #include "radeon_ioctl.h"
  54 #include "radeon_state.h"
  55 #include "r300_context.h"
  56 #include "r300_ioctl.h"
  57 #include "r300_state.h"
  58 #include "r300_reg.h"
  59 #include "r300_program.h"
  60 #include "r300_emit.h"
  61 #include "r300_fixed_pipelines.h"
  62
  63
  64 static void r300AlphaFunc(GLcontext * ctx, GLenum func, GLfloat ref)
  65 {
  66         r300ContextPtr rmesa = R300_CONTEXT(ctx);
  67         int pp_misc = rmesa->hw.at.cmd[R300_AT_ALPHA_TEST];
  68         GLubyte refByte;
  69
  70         CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
  71
  72         R300_STATECHANGE(rmesa, at);
  73
  74         pp_misc &= ~(R300_ALPHA_TEST_OP_MASK | R300_REF_ALPHA_MASK);
  75         pp_misc |= (refByte & R300_REF_ALPHA_MASK);
  76
  77         switch (func) {
  78         case GL_NEVER:
  79                 pp_misc |= R300_ALPHA_TEST_FAIL;
  80                 break;
  81         case GL_LESS:
  82                 pp_misc |= R300_ALPHA_TEST_LESS;
  83                 break;
  84         case GL_EQUAL:
  85                 pp_misc |= R300_ALPHA_TEST_EQUAL;
  86                 break;
  87         case GL_LEQUAL:
  88                 pp_misc |= R300_ALPHA_TEST_LEQUAL;
  89                 break;
  90         case GL_GREATER:
  91                 pp_misc |= R300_ALPHA_TEST_GREATER;
  92                 break;
  93         case GL_NOTEQUAL:
  94                 pp_misc |= R300_ALPHA_TEST_NEQUAL;
  95                 break;
  96         case GL_GEQUAL:
  97                 pp_misc |= R300_ALPHA_TEST_GEQUAL;
  98                 break;
  99         case GL_ALWAYS:
 100                 pp_misc |= R300_ALPHA_TEST_PASS;
 101                 break;
 102         }
 103
 104         rmesa->hw.at.cmd[R300_AT_ALPHA_TEST] = pp_misc;
 105 }
 106
 107 static void r300BlendColor(GLcontext * ctx, const GLfloat cf[4])
 108 {
 109         GLubyte color[4];
 110         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 111         fprintf(stderr, "%s:%s is not implemented yet. Fixme !\n", __FILE__, __FUNCTION__);
 112         #if 0
 113         R200_STATECHANGE(rmesa, ctx);
 114         CLAMPED_FLOAT_TO_UBYTE(color[0], cf[0]);
 115         CLAMPED_FLOAT_TO_UBYTE(color[1], cf[1]);
 116         CLAMPED_FLOAT_TO_UBYTE(color[2], cf[2]);
 117         CLAMPED_FLOAT_TO_UBYTE(color[3], cf[3]);
 118         if (rmesa->radeon.radeonScreen->drmSupportsBlendColor)
 119                 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCOLOR] =
 120                     radeonPackColor(4, color[0], color[1], color[2], color[3]);
 121         #endif
 122 }
 123
 124 /**
 125  * Calculate the hardware blend factor setting.  This same function is used
 126  * for source and destination of both alpha and RGB.
 127  *
 128  * \returns
 129  * The hardware register value for the specified blend factor.  This value
 130  * will need to be shifted into the correct position for either source or
 131  * destination factor.
 132  *
 133  * \todo
 134  * Since the two cases where source and destination are handled differently
 135  * are essentially error cases, they should never happen.  Determine if these
 136  * cases can be removed.
 137  */
 138 static int blend_factor(GLenum factor, GLboolean is_src)
 139 {
 140         int func;
 141
 142         switch (factor) {
 143         case GL_ZERO:
 144                 func = R200_BLEND_GL_ZERO;
 145                 break;
 146         case GL_ONE:
 147                 func = R200_BLEND_GL_ONE;
 148                 break;
 149         case GL_DST_COLOR:
 150                 func = R200_BLEND_GL_DST_COLOR;
 151                 break;
 152         case GL_ONE_MINUS_DST_COLOR:
 153                 func = R200_BLEND_GL_ONE_MINUS_DST_COLOR;
 154                 break;
 155         case GL_SRC_COLOR:
 156                 func = R200_BLEND_GL_SRC_COLOR;
 157                 break;
 158         case GL_ONE_MINUS_SRC_COLOR:
 159                 func = R200_BLEND_GL_ONE_MINUS_SRC_COLOR;
 160                 break;
 161         case GL_SRC_ALPHA:
 162                 func = R200_BLEND_GL_SRC_ALPHA;
 163                 break;
 164         case GL_ONE_MINUS_SRC_ALPHA:
 165                 func = R200_BLEND_GL_ONE_MINUS_SRC_ALPHA;
 166                 break;
 167         case GL_DST_ALPHA:
 168                 func = R200_BLEND_GL_DST_ALPHA;
 169                 break;
 170         case GL_ONE_MINUS_DST_ALPHA:
 171                 func = R200_BLEND_GL_ONE_MINUS_DST_ALPHA;
 172                 break;
 173         case GL_SRC_ALPHA_SATURATE:
 174                 func =
 175                     (is_src) ? R200_BLEND_GL_SRC_ALPHA_SATURATE :
 176                     R200_BLEND_GL_ZERO;
 177                 break;
 178         case GL_CONSTANT_COLOR:
 179                 func = R200_BLEND_GL_CONST_COLOR;
 180                 break;
 181         case GL_ONE_MINUS_CONSTANT_COLOR:
 182                 func = R200_BLEND_GL_ONE_MINUS_CONST_COLOR;
 183                 break;
 184         case GL_CONSTANT_ALPHA:
 185                 func = R200_BLEND_GL_CONST_ALPHA;
 186                 break;
 187         case GL_ONE_MINUS_CONSTANT_ALPHA:
 188                 func = R200_BLEND_GL_ONE_MINUS_CONST_ALPHA;
 189                 break;
 190         default:
 191                 func = (is_src) ? R200_BLEND_GL_ONE : R200_BLEND_GL_ZERO;
 192         }
 193         return func;
 194 }
 195
 196 /**
 197  * Sets both the blend equation and the blend function.
 198  * This is done in a single
 199  * function because some blend equations (i.e., \c GL_MIN and \c GL_MAX)
 200  * change the interpretation of the blend function.
 201  * Also, make sure that blend function and blend equation are set to their default
 202  * value if color blending is not enabled, since at least blend equations GL_MIN
 203  * and GL_FUNC_REVERSE_SUBTRACT will cause wrong results otherwise for
 204  * unknown reasons.
 205  */
 206
 207 /* helper function */
 208 static void r300_set_blend_cntl(r300ContextPtr rmesa, int func, int eqn, int cbits, int funcA, int eqnA)
 209 {
 210         GLuint new_ablend, new_cblend;
 211
 212         #if 0
 213         fprintf(stderr, "eqnA=%08x funcA=%08x eqn=%08x func=%08x cbits=%08x\n", eqnA, funcA, eqn, func, cbits);
 214         #endif
 215         new_ablend = eqnA | funcA;
 216         new_cblend = eqn | func;
 217         if(funcA == func){
 218                 new_cblend |=  R300_BLEND_NO_SEPARATE;
 219                 }
 220         new_cblend |= cbits;
 221
 222         if((new_ablend != rmesa->hw.bld.cmd[R300_BLD_ABLEND])
 223                 || (new_cblend != rmesa->hw.bld.cmd[R300_BLD_CBLEND])){
 224                 R300_STATECHANGE(rmesa, bld);
 225                 rmesa->hw.bld.cmd[R300_BLD_ABLEND]=new_ablend;
 226                 rmesa->hw.bld.cmd[R300_BLD_CBLEND]=new_cblend;
 227                 }
 228 }
 229
 230 static void r300_set_blend_state(GLcontext * ctx)
 231 {
 232         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 233         #if 0
 234         GLuint cntl = rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] &
 235             ~(R300_ROP_ENABLE | R300_ALPHA_BLEND_ENABLE |
 236               R300_SEPARATE_ALPHA_ENABLE);
 237         #endif
 238
 239         int func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 240             (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
 241         int eqn = R200_COMB_FCN_ADD_CLAMP;
 242         int funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 243             (R200_BLEND_GL_ZERO << R200_DST_BLEND_SHIFT);
 244         int eqnA = R200_COMB_FCN_ADD_CLAMP;
 245
 246
 247         if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
 248                 if (ctx->Color._LogicOpEnabled) {
 249                         #if 0
 250                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 251                             cntl | R300_ROP_ENABLE;
 252                         #endif
 253                         r300_set_blend_cntl(rmesa,
 254                                 func, eqn, 0,
 255                                 func, eqn);
 256                         return;
 257                 } else if (ctx->Color.BlendEnabled) {
 258                         #if 0
 259                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 260                             cntl | R300_ALPHA_BLEND_ENABLE |
 261                             R300_SEPARATE_ALPHA_ENABLE;
 262                         #endif
 263                 } else {
 264                         #if 0
 265                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
 266                         #endif
 267                         r300_set_blend_cntl(rmesa,
 268                                 func, eqn, 0,
 269                                 func, eqn);
 270                         return;
 271                 }
 272         } else {
 273                 if (ctx->Color._LogicOpEnabled) {
 274                         #if 0
 275                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 276                             cntl | R300_ROP_ENABLE;
 277                         rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 278                         #endif
 279                         return;
 280                 } else if (ctx->Color.BlendEnabled) {
 281                         #if 0
 282                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] =
 283                             cntl | R300_ALPHA_BLEND_ENABLE;
 284                         #endif
 285                 } else {
 286                         #if 0
 287                         rmesa->hw.ctx.cmd[CTX_RB3D_CNTL] = cntl;
 288                         rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 289                         #endif
 290                         r300_set_blend_cntl(rmesa,
 291                                 func, eqn, 0,
 292                                 func, eqn);
 293                         return;
 294                 }
 295         }
 296
 297         func =
 298             (blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE) <<
 299              R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstRGB,
 300                                                    GL_FALSE) <<
 301                                       R200_DST_BLEND_SHIFT);
 302
 303         switch (ctx->Color.BlendEquationRGB) {
 304         case GL_FUNC_ADD:
 305                 eqn = R300_COMB_FCN_ADD_CLAMP;
 306                 break;
 307
 308         case GL_FUNC_SUBTRACT:
 309                 eqn = R300_COMB_FCN_SUB_CLAMP;
 310                 break;
 311
 312         case GL_FUNC_REVERSE_SUBTRACT:
 313                 eqn = R200_COMB_FCN_RSUB_CLAMP;
 314                 break;
 315
 316         case GL_MIN:
 317                 eqn = R200_COMB_FCN_MIN;
 318                 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 319                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 320                 break;
 321
 322         case GL_MAX:
 323                 eqn = R200_COMB_FCN_MAX;
 324                 func = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 325                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 326                 break;
 327
 328         default:
 329                 fprintf(stderr,
 330                         "[%s:%u] Invalid RGB blend equation (0x%04x).\n",
 331                         __func__, __LINE__, ctx->Color.BlendEquationRGB);
 332                 return;
 333         }
 334
 335         if (!rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
 336                 #if 0
 337                 rmesa->hw.ctx.cmd[CTX_RB3D_BLENDCNTL] = eqn | func;
 338                 #endif
 339                 return;
 340         }
 341
 342         funcA =
 343             (blend_factor(ctx->Color.BlendSrcA, GL_TRUE) <<
 344              R200_SRC_BLEND_SHIFT) | (blend_factor(ctx->Color.BlendDstA,
 345                                                    GL_FALSE) <<
 346                                       R200_DST_BLEND_SHIFT);
 347
 348         switch (ctx->Color.BlendEquationA) {
 349         case GL_FUNC_ADD:
 350                 eqnA = R300_COMB_FCN_ADD_CLAMP;
 351                 break;
 352
 353         case GL_FUNC_SUBTRACT:
 354                 eqnA = R300_COMB_FCN_SUB_CLAMP;
 355                 break;
 356
 357         case GL_FUNC_REVERSE_SUBTRACT:
 358                 eqnA = R200_COMB_FCN_RSUB_CLAMP;
 359                 break;
 360
 361         case GL_MIN:
 362                 eqnA = R200_COMB_FCN_MIN;
 363                 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 364                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 365                 break;
 366
 367         case GL_MAX:
 368                 eqnA = R200_COMB_FCN_MAX;
 369                 funcA = (R200_BLEND_GL_ONE << R200_SRC_BLEND_SHIFT) |
 370                     (R200_BLEND_GL_ONE << R200_DST_BLEND_SHIFT);
 371                 break;
 372
 373         default:
 374                 fprintf(stderr, "[%s:%u] Invalid A blend equation (0x%04x).\n",
 375                         __func__, __LINE__, ctx->Color.BlendEquationA);
 376                 return;
 377         }
 378
 379         r300_set_blend_cntl(rmesa,
 380                 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
 381                 funcA, eqnA);
 382         r300_set_blend_cntl(rmesa,
 383                 func, eqn, R300_BLEND_UNKNOWN | R300_BLEND_ENABLE,
 384                 funcA, eqnA);
 385 }
 386
 387 static void r300BlendEquationSeparate(GLcontext * ctx,
 388                                       GLenum modeRGB, GLenum modeA)
 389 {
 390         r300_set_blend_state(ctx);
 391 }
 392
 393 static void r300BlendFuncSeparate(GLcontext * ctx,
 394                                   GLenum sfactorRGB, GLenum dfactorRGB,
 395                                   GLenum sfactorA, GLenum dfactorA)
 396 {
 397         r300_set_blend_state(ctx);
 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         R300_STATECHANGE(r300, cul);
 409         if (ctx->Polygon.CullFlag) {
 410                 if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
 411                         val = R300_CULL_FRONT|R300_CULL_BACK;
 412                 else if (ctx->Polygon.CullFaceMode == GL_FRONT)
 413                         val = R300_CULL_FRONT;
 414                 else
 415                         val = R300_CULL_BACK;
 416
 417                 if (ctx->Polygon.FrontFace == GL_CW)
 418                         val |= R300_FRONT_FACE_CW;
 419                 else
 420                         val |= R300_FRONT_FACE_CCW;
 421         }
 422
 423         r300->hw.cul.cmd[R300_CUL_CULL] = val;
 424 }
 425
 426
 427 /**
 428  * Handle glEnable()/glDisable().
 429  *
 430  * \note Mesa already filters redundant calls to glEnable/glDisable.
 431  */
 432 static void r300Enable(GLcontext* ctx, GLenum cap, GLboolean state)
 433 {
 434         r300ContextPtr r300 = R300_CONTEXT(ctx);
 435         uint32_t newval;
 436
 437         if (RADEON_DEBUG & DEBUG_STATE)
 438                 fprintf(stderr, "%s( %s = %s )\n", __FUNCTION__,
 439                         _mesa_lookup_enum_by_nr(cap),
 440                         state ? "GL_TRUE" : "GL_FALSE");
 441
 442         switch (cap) {
 443                 /* Fast track this one...
 444                  */
 445         case GL_TEXTURE_1D:
 446         case GL_TEXTURE_2D:
 447         case GL_TEXTURE_3D:
 448                 break;
 449
 450         case GL_ALPHA_TEST:
 451                 R200_STATECHANGE(r300, at);
 452                 if (state) {
 453                         r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
 454                             R300_ALPHA_TEST_ENABLE;
 455                 } else {
 456                         r300->hw.at.cmd[R300_AT_ALPHA_TEST] |=
 457                             ~R300_ALPHA_TEST_ENABLE;
 458                 }
 459                 break;
 460
 461         case GL_BLEND:
 462         case GL_COLOR_LOGIC_OP:
 463                 r300_set_blend_state(ctx);
 464                 break;
 465
 466         case GL_DEPTH_TEST:
 467                 R300_STATECHANGE(r300, zs);
 468
 469                 if (state) {
 470                         if (ctx->Depth.Mask)
 471                                 newval = R300_RB3D_Z_TEST_AND_WRITE;
 472                         else
 473                                 newval = R300_RB3D_Z_TEST;
 474                 } else
 475                         newval = 0;
 476
 477                 r300->hw.zs.cmd[R300_ZS_CNTL_0] = newval;
 478                 break;
 479
 480         case GL_STENCIL_TEST:
 481
 482                 {
 483                 static int stencil=1;
 484                 if(stencil){
 485                         fprintf(stderr, "%s:%s - do not know how to enable stencil. Help me !\n",
 486                                 __FILE__, __FUNCTION__);
 487                         stencil=0;
 488                         }
 489                 }
 490
 491                 if (r300->state.hw_stencil) {
 492                         //fprintf(stderr, "Stencil %s\n", state ? "enabled" : "disabled");
 493                         R300_STATECHANGE(r300, zs);
 494                         if (state) {
 495                                 r300->hw.zs.cmd[R300_ZS_CNTL_0] |=
 496                                     R300_RB3D_STENCIL_ENABLE;
 497                         } else {
 498                                 r300->hw.zs.cmd[R300_ZS_CNTL_0] &=
 499                                     ~R300_RB3D_STENCIL_ENABLE;
 500                         }
 501                 } else {
 502                         FALLBACK(&r300->radeon, RADEON_FALLBACK_STENCIL, state);
 503                 }
 504                 break;
 505
 506         case GL_CULL_FACE:
 507                 r300UpdateCulling(ctx);
 508                 break;
 509         case GL_VERTEX_PROGRAM_ARB:
 510                 //TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, state);
 511         break;
 512
 513         default:
 514                 radeonEnable(ctx, cap, state);
 515                 return;
 516         }
 517 }
 518
 519
 520 /**
 521  * Change the culling mode.
 522  *
 523  * \note Mesa already filters redundant calls to this function.
 524  */
 525 static void r300CullFace(GLcontext* ctx, GLenum mode)
 526 {
 527         (void)mode;
 528
 529         r300UpdateCulling(ctx);
 530 }
 531
 532
 533 /**
 534  * Change the polygon orientation.
 535  *
 536  * \note Mesa already filters redundant calls to this function.
 537  */
 538 static void r300FrontFace(GLcontext* ctx, GLenum mode)
 539 {
 540         (void)mode;
 541
 542         r300UpdateCulling(ctx);
 543 }
 544
 545
 546 /**
 547  * Change the depth testing function.
 548  *
 549  * \note Mesa already filters redundant calls to this function.
 550  */
 551 static void r300DepthFunc(GLcontext* ctx, GLenum func)
 552 {
 553         r300ContextPtr r300 = R300_CONTEXT(ctx);
 554
 555         R300_STATECHANGE(r300, zs);
 556
 557         r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
 558
 559         switch(func) {
 560         case GL_NEVER:
 561                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NEVER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 562                 break;
 563         case GL_LESS:
 564                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LESS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 565                 break;
 566         case GL_EQUAL:
 567                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_EQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 568                 break;
 569         case GL_LEQUAL:
 570                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_LEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 571                 break;
 572         case GL_GREATER:
 573                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GREATER << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 574                 break;
 575         case GL_NOTEQUAL:
 576                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_NOTEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 577                 break;
 578         case GL_GEQUAL:
 579                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_GEQUAL << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 580                 break;
 581         case GL_ALWAYS:
 582                 r300->hw.zs.cmd[R300_ZS_CNTL_1] |= R300_ZS_ALWAYS << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT;
 583                 break;
 584         }
 585
 586 }
 587
 588
 589 /**
 590  * Enable/Disable depth writing.
 591  *
 592  * \note Mesa already filters redundant calls to this function.
 593  */
 594 static void r300DepthMask(GLcontext* ctx, GLboolean mask)
 595 {
 596         r300ContextPtr r300 = R300_CONTEXT(ctx);
 597
 598         if (!ctx->Depth.Test)
 599                 return;
 600
 601         R300_STATECHANGE(r300, zs);
 602         r300->hw.zs.cmd[R300_ZS_CNTL_0] = mask
 603                 ? R300_RB3D_Z_TEST_AND_WRITE : R300_RB3D_Z_TEST;
 604 }
 605
 606
 607 /**
 608  * Handle glColorMask()
 609  */
 610 static void r300ColorMask(GLcontext* ctx,
 611                           GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 612 {
 613         r300ContextPtr r300 = R300_CONTEXT(ctx);
 614         int mask = (b << 0) | (g << 1) | (r << 2) | (a << 3);
 615
 616         if (mask != r300->hw.cmk.cmd[R300_CMK_COLORMASK]) {
 617                 R300_STATECHANGE(r300, cmk);
 618                 r300->hw.cmk.cmd[R300_CMK_COLORMASK] = mask;
 619         }
 620 }
 621
 622 /* =============================================================
 623  * Point state
 624  */
 625 static void r300PointSize(GLcontext * ctx, GLfloat size)
 626 {
 627         r300ContextPtr r300 = R300_CONTEXT(ctx);
 628
 629         /* This might need fixing later */
 630         R300_STATECHANGE(r300, vps);
 631         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
 632 }
 633 /* =============================================================
 634  * Stencil
 635  */
 636
 637  static int translate_stencil_func(int func)
 638  {
 639         switch (func) {
 640         case GL_NEVER:
 641                     return R300_ZS_NEVER;
 642                 break;
 643         case GL_LESS:
 644                     return R300_ZS_LESS;
 645                 break;
 646         case GL_EQUAL:
 647                     return R300_ZS_EQUAL;
 648                 break;
 649         case GL_LEQUAL:
 650                     return R300_ZS_LEQUAL;
 651                 break;
 652         case GL_GREATER:
 653                     return R300_ZS_GREATER;
 654                 break;
 655         case GL_NOTEQUAL:
 656                     return R300_ZS_NOTEQUAL;
 657                 break;
 658         case GL_GEQUAL:
 659                     return R300_ZS_GEQUAL;
 660                 break;
 661         case GL_ALWAYS:
 662                     return R300_ZS_ALWAYS;
 663                 break;
 664         }
 665  return 0;
 666  }
 667
 668  static int translate_stencil_op(int op)
 669 {
 670         switch (op) {
 671         case GL_KEEP:
 672                     return R300_ZS_KEEP;
 673         case GL_ZERO:
 674                     return R300_ZS_ZERO;
 675         case GL_REPLACE:
 676                     return R300_ZS_REPLACE;
 677         case GL_INCR:
 678                     return R300_ZS_INCR;
 679         case GL_DECR:
 680                     return R300_ZS_DECR;
 681         case GL_INCR_WRAP_EXT:
 682                     return R300_ZS_INCR_WRAP;
 683         case GL_DECR_WRAP_EXT:
 684                     return R300_ZS_DECR_WRAP;
 685         case GL_INVERT:
 686                     return R300_ZS_INVERT;
 687         }
 688 }
 689
 690 static void r300StencilFunc(GLcontext * ctx, GLenum func,
 691                             GLint ref, GLuint mask)
 692 {
 693         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 694         GLuint refmask = ((ctx->Stencil.Ref[0] << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
 695                           (ctx->Stencil.
 696                            ValueMask[0] << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
 697         GLuint flag;
 698
 699         R200_STATECHANGE(rmesa, zs);
 700
 701         rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(
 702                 (R300_ZS_MASK << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
 703                 | (R300_ZS_MASK << R300_RB3D_ZS1_BACK_FUNC_SHIFT));
 704         rmesa->hw.zs.cmd[R300_ZS_CNTL_2] &=  ~((R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_REF_SHIFT) |
 705                                                 (R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_MASK_SHIFT));
 706
 707         flag = translate_stencil_func(ctx->Stencil.Function[0]);
 708
 709         rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |= (flag << R300_RB3D_ZS1_FRONT_FUNC_SHIFT)
 710                                           | (flag << R300_RB3D_ZS1_BACK_FUNC_SHIFT);
 711         rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
 712 }
 713
 714 static void r300StencilMask(GLcontext * ctx, GLuint mask)
 715 {
 716         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 717
 718         R200_STATECHANGE(rmesa, zs);
 719         rmesa->hw.zs.cmd[R300_ZS_CNTL_2]  &= ~(R300_ZS_MASK << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT);
 720         rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= ctx->Stencil.WriteMask[0] << R300_RB3D_ZS2_STENCIL_WRITE_MASK_SHIFT;
 721 }
 722
 723
 724 static void r300StencilOp(GLcontext * ctx, GLenum fail,
 725                           GLenum zfail, GLenum zpass)
 726 {
 727         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 728
 729         R200_STATECHANGE(rmesa, zs);
 730                 /* It is easier to mask what's left.. */
 731         rmesa->hw.zs.cmd[R300_ZS_CNTL_1] &= (R300_ZS_MASK << R300_RB3D_ZS1_DEPTH_FUNC_SHIFT);
 732
 733         rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
 734                  (translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_FRONT_FAIL_OP_SHIFT)
 735                 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_FRONT_ZFAIL_OP_SHIFT)
 736                 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_FRONT_ZPASS_OP_SHIFT)
 737                 |(translate_stencil_op(ctx->Stencil.FailFunc[0]) << R300_RB3D_ZS1_BACK_FAIL_OP_SHIFT)
 738                 |(translate_stencil_op(ctx->Stencil.ZFailFunc[0]) << R300_RB3D_ZS1_BACK_ZFAIL_OP_SHIFT)
 739                 |(translate_stencil_op(ctx->Stencil.ZPassFunc[0]) << R300_RB3D_ZS1_BACK_ZPASS_OP_SHIFT);
 740
 741 }
 742
 743 static void r300ClearStencil(GLcontext * ctx, GLint s)
 744 {
 745         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 746
 747         /* Not sure whether this is correct.. */
 748         R200_STATECHANGE(rmesa, zs);
 749         rmesa->hw.zs.cmd[R300_ZS_CNTL_2] =
 750             ((GLuint) ctx->Stencil.Clear |
 751              (0xff << R200_STENCIL_MASK_SHIFT) |
 752              (ctx->Stencil.WriteMask[0] << R200_STENCIL_WRITEMASK_SHIFT));
 753 }
 754
 755 /* =============================================================
 756  * Window position and viewport transformation
 757  */
 758
 759 /*
 760  * To correctly position primitives:
 761  */
 762 #define SUBPIXEL_X 0.125
 763 #define SUBPIXEL_Y 0.125
 764
 765 void r300UpdateWindow(GLcontext * ctx)
 766 {
 767         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 768         __DRIdrawablePrivate *dPriv = rmesa->radeon.dri.drawable;
 769         GLfloat xoffset = dPriv ? (GLfloat) dPriv->x : 0;
 770         GLfloat yoffset = dPriv ? (GLfloat) dPriv->y + dPriv->h : 0;
 771         const GLfloat *v = ctx->Viewport._WindowMap.m;
 772
 773         GLfloat sx = v[MAT_SX];
 774         GLfloat tx = v[MAT_TX] + xoffset + SUBPIXEL_X;
 775         GLfloat sy = -v[MAT_SY];
 776         GLfloat ty = (-v[MAT_TY]) + yoffset + SUBPIXEL_Y;
 777         GLfloat sz = v[MAT_SZ] * rmesa->state.depth.scale;
 778         GLfloat tz = v[MAT_TZ] * rmesa->state.depth.scale;
 779
 780         R300_FIREVERTICES(rmesa);
 781         R300_STATECHANGE(rmesa, vpt);
 782
 783         rmesa->hw.vpt.cmd[R300_VPT_XSCALE]  = r300PackFloat32(sx);
 784         rmesa->hw.vpt.cmd[R300_VPT_XOFFSET] = r300PackFloat32(tx);
 785         rmesa->hw.vpt.cmd[R300_VPT_YSCALE]  = r300PackFloat32(sy);
 786         rmesa->hw.vpt.cmd[R300_VPT_YOFFSET] = r300PackFloat32(ty);
 787         rmesa->hw.vpt.cmd[R300_VPT_ZSCALE]  = r300PackFloat32(sz);
 788         rmesa->hw.vpt.cmd[R300_VPT_ZOFFSET] = r300PackFloat32(tz);
 789 }
 790
 791 static void r300Viewport(GLcontext * ctx, GLint x, GLint y,
 792                          GLsizei width, GLsizei height)
 793 {
 794         /* Don't pipeline viewport changes, conflict with window offset
 795          * setting below.  Could apply deltas to rescue pipelined viewport
 796          * values, or keep the originals hanging around.
 797          */
 798         R200_FIREVERTICES(R200_CONTEXT(ctx));
 799         r300UpdateWindow(ctx);
 800 }
 801
 802 static void r300DepthRange(GLcontext * ctx, GLclampd nearval, GLclampd farval)
 803 {
 804         r300UpdateWindow(ctx);
 805 }
 806
 807 /* Routing and texture-related */
 808
 809 void r300_setup_routing(GLcontext *ctx, GLboolean immediate)
 810 {
 811         int i, count=0,reg=0;
 812         GLuint dw, mask;
 813         TNLcontext *tnl = TNL_CONTEXT(ctx);
 814         struct vertex_buffer *VB = &tnl->vb;
 815         r300ContextPtr r300 = R300_CONTEXT(ctx);
 816
 817
 818         /* Stage 1 - input to VAP */
 819
 820         /* Assign register number automatically, retaining it in rmesa->state.reg */
 821
 822         /* Note: immediate vertex data includes all coordinates.
 823         To save bandwidth use either VBUF or state-based vertex generation */
 824
 825         #define CONFIGURE_AOS(v, o, r, f) \
 826                 {\
 827                 if (RADEON_DEBUG & DEBUG_STATE)fprintf(stderr, "Enabling "#r "\n"); \
 828                 if(immediate){ \
 829                         r300->state.aos[count].element_size=4; \
 830                         r300->state.aos[count].stride=4; \
 831                         r300->state.aos[count].ncomponents=4; \
 832                         } else { \
 833                         r300->state.aos[count].element_size=v->size; \
 834                         r300->state.aos[count].stride=v->size; \
 835                         r300->state.aos[count].ncomponents=v->size; \
 836                         } \
 837                 r300->state.aos[count].offset=o; \
 838                 r300->state.aos[count].reg=reg; \
 839                 r300->state.aos[count].format=(f); \
 840                 r300->state.vap_reg.r=reg; \
 841                 count++; \
 842                 reg++; \
 843                 }
 844
 845                 /* All offsets are 0 - for use by immediate mode.
 846                 Should change later to handle vertex buffers */
 847         if(tnl->render_inputs & _TNL_BIT_POS)
 848                 CONFIGURE_AOS(VB->ObjPtr, 0, i_coords, AOS_FORMAT_FLOAT);
 849         if(tnl->render_inputs & _TNL_BIT_NORMAL)
 850                 CONFIGURE_AOS(VB->NormalPtr, 0, i_normal, AOS_FORMAT_FLOAT);
 851
 852         if(tnl->render_inputs & _TNL_BIT_COLOR0)
 853                 CONFIGURE_AOS(VB->ColorPtr[0], 0, i_color[0], AOS_FORMAT_FLOAT_COLOR);
 854         if(tnl->render_inputs & _TNL_BIT_COLOR1)
 855                 CONFIGURE_AOS(VB->SecondaryColorPtr[0], 0, i_color[1], AOS_FORMAT_FLOAT_COLOR);
 856
 857         if(tnl->render_inputs & _TNL_BIT_FOG)
 858                 CONFIGURE_AOS(VB->FogCoordPtr, 0, i_fog, AOS_FORMAT_FLOAT);
 859
 860         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 861                 if(tnl->render_inputs & (_TNL_BIT_TEX0<<i))
 862                         CONFIGURE_AOS(VB->TexCoordPtr[i], 0, i_tex[i], AOS_FORMAT_FLOAT);
 863
 864         if(tnl->render_inputs & _TNL_BIT_INDEX)
 865                 CONFIGURE_AOS(VB->IndexPtr[0], 0, i_index, AOS_FORMAT_FLOAT);
 866         if(tnl->render_inputs & _TNL_BIT_POINTSIZE)
 867                 CONFIGURE_AOS(VB->PointSizePtr, 0, i_pointsize, AOS_FORMAT_FLOAT);
 868
 869         r300->state.aos_count=count;
 870
 871         if (RADEON_DEBUG & DEBUG_STATE)
 872                 fprintf(stderr, "aos_count=%d\n", count);
 873
 874         if(count>R300_MAX_AOS_ARRAYS){
 875                 fprintf(stderr, "Aieee ! AOS array count exceeded !\n");
 876                 exit(-1);
 877                 }
 878
 879         /* Implement AOS */
 880
 881         /* setup INPUT_ROUTE */
 882         R300_STATECHANGE(r300, vir[0]);
 883         for(i=0;i+1<count;i+=2){
 884                 dw=(r300->state.aos[i].ncomponents-1)
 885                 | ((r300->state.aos[i].reg)<<8)
 886                 | (r300->state.aos[i].format<<14)
 887                 | (((r300->state.aos[i+1].ncomponents-1)
 888                 | ((r300->state.aos[i+1].reg)<<8)
 889                 | (r300->state.aos[i+1].format<<14))<<16);
 890
 891                 if(i+2==count){
 892                         dw|=(1<<(13+16));
 893                         }
 894                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 895                 }
 896         if(count & 1){
 897                 dw=(r300->state.aos[count-1].ncomponents-1)
 898                 | (r300->state.aos[count-1].format<<14)
 899                 | ((r300->state.aos[count-1].reg)<<8)
 900                 | (1<<13);
 901                 r300->hw.vir[0].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 902                 //fprintf(stderr, "vir0 dw=%08x\n", dw);
 903                 }
 904         /* Set the rest of INPUT_ROUTE_0 to 0 */
 905         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[0].cmd[R300_VIR_CNTL_0+i]=(0x0);
 906         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = (count+1)>>1;
 907
 908
 909         /* Mesa assumes that all missing components are from (0, 0, 0, 1) */
 910         #define ALL_COMPONENTS ((R300_INPUT_ROUTE_SELECT_X<<R300_INPUT_ROUTE_X_SHIFT) \
 911                 | (R300_INPUT_ROUTE_SELECT_Y<<R300_INPUT_ROUTE_Y_SHIFT) \
 912                 | (R300_INPUT_ROUTE_SELECT_Z<<R300_INPUT_ROUTE_Z_SHIFT) \
 913                 | (R300_INPUT_ROUTE_SELECT_W<<R300_INPUT_ROUTE_W_SHIFT))
 914
 915         #define ALL_DEFAULT ((R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_X_SHIFT) \
 916                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Y_SHIFT) \
 917                 | (R300_INPUT_ROUTE_SELECT_ZERO<<R300_INPUT_ROUTE_Z_SHIFT) \
 918                 | (R300_INPUT_ROUTE_SELECT_ONE<<R300_INPUT_ROUTE_W_SHIFT))
 919
 920         R300_STATECHANGE(r300, vir[1]);
 921
 922         for(i=0;i+1<count;i+=2){
 923                 /* do i first.. */
 924                 mask=(1<<(r300->state.aos[i].ncomponents*3))-1;
 925                 dw=(ALL_COMPONENTS & mask)
 926                 | (ALL_DEFAULT & ~mask)
 927                 | R300_INPUT_ROUTE_ENABLE;
 928
 929                 /* i+1 */
 930                 mask=(1<<(r300->state.aos[i+1].ncomponents*3))-1;
 931                 dw|=(
 932                 (ALL_COMPONENTS & mask)
 933                 | (ALL_DEFAULT & ~mask)
 934                 | R300_INPUT_ROUTE_ENABLE
 935                 )<<16;
 936
 937                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(i>>1)]=dw;
 938                 }
 939         if(count & 1){
 940                 mask=(1<<(r300->state.aos[count-1].ncomponents*3))-1;
 941                 dw=(ALL_COMPONENTS & mask)
 942                 | (ALL_DEFAULT & ~mask)
 943                 | R300_INPUT_ROUTE_ENABLE;
 944                 r300->hw.vir[1].cmd[R300_VIR_CNTL_0+(count>>1)]=dw;
 945                 //fprintf(stderr, "vir1 dw=%08x\n", dw);
 946                 }
 947         /* Set the rest of INPUT_ROUTE_1 to 0 */
 948         //for(i=((count+1)>>1); i<8; i++)r300->hw.vir[1].cmd[R300_VIR_CNTL_0+i]=0x0;
 949         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = (count+1)>>1;
 950
 951         /* Set up input_cntl */
 952
 953         R300_STATECHANGE(r300, vic);
 954         r300->hw.vic.cmd[R300_VIC_CNTL_0]=0x5555;  /* Hard coded value, no idea what it means */
 955
 956         r300->hw.vic.cmd[R300_VIC_CNTL_1]=R300_INPUT_CNTL_POS
 957                                         | R300_INPUT_CNTL_COLOR;
 958
 959         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 960                 if(ctx->Texture.Unit[i].Enabled)
 961                         r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
 962
 963         /* Stage 3: VAP output */
 964         R300_STATECHANGE(r300, vof);
 965         r300->hw.vof.cmd[R300_VOF_CNTL_0]=R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
 966                                         | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
 967
 968         r300->hw.vof.cmd[R300_VOF_CNTL_1]=0;
 969         for(i=0;i < ctx->Const.MaxTextureUnits;i++)
 970                 if(ctx->Texture.Unit[i].Enabled)
 971                         r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
 972
 973 }
 974
 975 static r300TexObj default_tex_obj={
 976         filter:R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR,
 977         pitch: 0x8000,
 978         size: (0xff << R300_TX_WIDTHMASK_SHIFT)
 979               | (0xff << R300_TX_HEIGHTMASK_SHIFT)
 980               | (0x8 << R300_TX_SIZE_SHIFT),
 981         format: 0x88a0c,
 982         offset: 0x0,
 983         unknown4: 0x0,
 984         unknown5: 0x0
 985         };
 986
 987         /* there is probably a system to these value, but, for now,
 988            we just try by hand */
 989
 990 static int inline translate_src(int src)
 991 {
 992         switch (src) {
 993         case GL_TEXTURE:
 994                 return 1;
 995                 break;
 996         case GL_CONSTANT:
 997                 return 2;
 998                 break;
 999         case GL_PRIMARY_COLOR:
1000                 return 3;
1001                 break;
1002         case GL_PREVIOUS:
1003                 return 4;
1004                 break;
1005         case GL_ZERO:
1006                 return 5;
1007                 break;
1008         case GL_ONE:
1009                 return 6;
1010                 break;
1011         default:
1012                 return 0;
1013         }
1014 }
1015
1016 /* r300 doesnt handle GL_CLAMP and GL_MIRROR_CLAMP_EXT correctly when filter is NEAREST.
1017  * Since texwrap produces same results for GL_CLAMP and GL_CLAMP_TO_EDGE we use them instead.
1018  * We need to recalculate wrap modes whenever filter mode is changed because someone might do:
1019  * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1020  * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1021  * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1022  * Since r300 completely ignores R300_TX_CLAMP when either min or mag is nearest it cant handle
1023  * combinations where only one of them is nearest.
1024  */
1025 static unsigned long gen_fixed_filter(unsigned long f)
1026 {
1027         unsigned long mag, min, needs_fixing=0;
1028         //return f;
1029
1030         /* We ignore MIRROR bit so we dont have to do everything twice */
1031         if((f & ((7-1) << R300_TX_WRAP_S_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_S_SHIFT)){
1032                 needs_fixing |= 1;
1033         }
1034         if((f & ((7-1) << R300_TX_WRAP_T_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_T_SHIFT)){
1035                 needs_fixing |= 2;
1036         }
1037         if((f & ((7-1) << R300_TX_WRAP_Q_SHIFT)) == (R300_TX_CLAMP << R300_TX_WRAP_Q_SHIFT)){
1038                 needs_fixing |= 4;
1039         }
1040
1041         if(!needs_fixing)
1042                 return f;
1043
1044         mag=f & R300_TX_MAG_FILTER_MASK;
1045         min=f & R300_TX_MIN_FILTER_MASK;
1046
1047         /* TODO: Check for anisto filters too */
1048         if((mag != R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST))
1049                 return f;
1050
1051         /* r300 cant handle these modes hence we force nearest to linear */
1052         if((mag == R300_TX_MAG_FILTER_NEAREST) && (min != R300_TX_MIN_FILTER_NEAREST)){
1053                 f &= ~R300_TX_MAG_FILTER_NEAREST;
1054                 f |= R300_TX_MAG_FILTER_LINEAR;
1055                 return f;
1056         }
1057
1058         if((min == R300_TX_MIN_FILTER_NEAREST) && (mag != R300_TX_MAG_FILTER_NEAREST)){
1059                 f &= ~R300_TX_MIN_FILTER_NEAREST;
1060                 f |= R300_TX_MIN_FILTER_LINEAR;
1061                 return f;
1062         }
1063
1064         /* Both are nearest */
1065         if(needs_fixing & 1){
1066                 f &= ~((7-1) << R300_TX_WRAP_S_SHIFT);
1067                 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_S_SHIFT;
1068         }
1069         if(needs_fixing & 2){
1070                 f &= ~((7-1) << R300_TX_WRAP_T_SHIFT);
1071                 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_T_SHIFT;
1072         }
1073         if(needs_fixing & 4){
1074                 f &= ~((7-1) << R300_TX_WRAP_Q_SHIFT);
1075                 f |= R300_TX_CLAMP_TO_EDGE << R300_TX_WRAP_Q_SHIFT;
1076         }
1077         return f;
1078 }
1079
1080 void r300_setup_textures(GLcontext *ctx)
1081 {
1082         int i, mtu;
1083         struct r300_tex_obj *t;
1084         r300ContextPtr r300 = R300_CONTEXT(ctx);
1085         int max_texture_unit=-1; /* -1 translates into no setup costs for fields */
1086         struct gl_texture_unit *texUnit;
1087
1088         R300_STATECHANGE(r300, txe);
1089         R300_STATECHANGE(r300, tex.filter);
1090         R300_STATECHANGE(r300, tex.unknown1);
1091         R300_STATECHANGE(r300, tex.size);
1092         R300_STATECHANGE(r300, tex.format);
1093         R300_STATECHANGE(r300, tex.offset);
1094         R300_STATECHANGE(r300, tex.unknown4);
1095         R300_STATECHANGE(r300, tex.unknown5);
1096         //R300_STATECHANGE(r300, tex.border_color);
1097
1098         r300->state.texture.tc_count=0;
1099
1100         r300->hw.txe.cmd[R300_TXE_ENABLE]=0x0;
1101
1102         mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
1103         if (RADEON_DEBUG & DEBUG_STATE)
1104                 fprintf(stderr, "mtu=%d\n", mtu);
1105
1106         if(mtu>R300_MAX_TEXTURE_UNITS){
1107                 fprintf(stderr, "Aiiee ! mtu=%d is greater than R300_MAX_TEXTURE_UNITS=%d\n",
1108                         mtu, R300_MAX_TEXTURE_UNITS);
1109                 exit(-1);
1110                 }
1111         for(i=0;i<mtu;i++){
1112                 if(ctx->Texture.Unit[i].Enabled){
1113                         t=r300->state.texture.unit[i].texobj;
1114                         //fprintf(stderr, "format=%08x\n", r300->state.texture.unit[i].format);
1115                         r300->state.texture.tc_count++;
1116                         if(t==NULL){
1117                                 fprintf(stderr, "Texture unit %d enabled, but corresponding texobj is NULL, using default object.\n", i);
1118                                 //exit(-1);
1119                                 t=&default_tex_obj;
1120                                 }
1121                         //fprintf(stderr, "t->format=%08x\n", t->format);
1122                         if (RADEON_DEBUG & DEBUG_STATE)
1123                                 fprintf(stderr, "Activating texture unit %d\n", i);
1124                         max_texture_unit=i;
1125                         r300->hw.txe.cmd[R300_TXE_ENABLE]|=(1<<i);
1126
1127                         r300->hw.tex.filter.cmd[R300_TEX_VALUE_0+i]=gen_fixed_filter(t->filter);
1128                         /* No idea why linear filtered textures shake when puting random data */
1129                         /*r300->hw.tex.unknown1.cmd[R300_TEX_VALUE_0+i]=(rand()%0xffffffff) & (~0x1fff);*/
1130                         r300->hw.tex.size.cmd[R300_TEX_VALUE_0+i]=t->size;
1131                         r300->hw.tex.format.cmd[R300_TEX_VALUE_0+i]=t->format;
1132                         //fprintf(stderr, "t->format=%08x\n", t->format);
1133                         r300->hw.tex.offset.cmd[R300_TEX_VALUE_0+i]=r300->radeon.radeonScreen->fbLocation+t->offset;
1134                         r300->hw.tex.unknown4.cmd[R300_TEX_VALUE_0+i]=0x0;
1135                         r300->hw.tex.unknown5.cmd[R300_TEX_VALUE_0+i]=0x0;
1136                         //r300->hw.tex.border_color.cmd[R300_TEX_VALUE_0+i]=t->pp_border_color;
1137                         }
1138                 }
1139         ((drm_r300_cmd_header_t*)r300->hw.tex.filter.cmd)->unchecked_state.count = max_texture_unit+1;
1140         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown1.cmd)->unchecked_state.count = max_texture_unit+1;
1141         ((drm_r300_cmd_header_t*)r300->hw.tex.size.cmd)->unchecked_state.count = max_texture_unit+1;
1142         ((drm_r300_cmd_header_t*)r300->hw.tex.format.cmd)->unchecked_state.count = max_texture_unit+1;
1143         ((drm_r300_cmd_header_t*)r300->hw.tex.offset.cmd)->unchecked_state.count = max_texture_unit+1;
1144         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown4.cmd)->unchecked_state.count = max_texture_unit+1;
1145         ((drm_r300_cmd_header_t*)r300->hw.tex.unknown5.cmd)->unchecked_state.count = max_texture_unit+1;
1146         //((drm_r300_cmd_header_t*)r300->hw.tex.border_color.cmd)->unchecked_state.count = max_texture_unit+1;
1147
1148         if (RADEON_DEBUG & DEBUG_STATE)
1149                 fprintf(stderr, "TX_ENABLE: %08x  max_texture_unit=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], max_texture_unit);
1150 }
1151
1152 void r300_setup_rs_unit(GLcontext *ctx)
1153 {
1154         r300ContextPtr r300 = R300_CONTEXT(ctx);
1155         int i;
1156
1157         /* This needs to be rewritten - it is a hack at best */
1158
1159         R300_STATECHANGE(r300, ri);
1160         R300_STATECHANGE(r300, rc);
1161         R300_STATECHANGE(r300, rr);
1162
1163         for(i = 1; i <= 8; ++i)
1164                 r300->hw.ri.cmd[i] = 0x00d10000;
1165         r300->hw.ri.cmd[R300_RI_INTERP_1] |= R300_RS_INTERP_1_UNKNOWN;
1166         r300->hw.ri.cmd[R300_RI_INTERP_2] |= R300_RS_INTERP_2_UNKNOWN;
1167         r300->hw.ri.cmd[R300_RI_INTERP_3] |= R300_RS_INTERP_3_UNKNOWN;
1168
1169         #if 1
1170         for(i = 2; i <= 8; ++i)
1171                 r300->hw.ri.cmd[i] |= 4;
1172         #endif
1173
1174         for(i = 1; i <= 8; ++i)
1175                 r300->hw.rr.cmd[i] = 0;
1176         /* textures enabled ? */
1177         if(r300->state.texture.tc_count>0){
1178
1179                 /* This code only really works with one set of texture coordinates */
1180
1181                 /* The second constant is needed to get glxgears display anything .. */
1182                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7
1183                                 | R300_RS_CNTL_0_UNKNOWN_18
1184                                 | (r300->state.texture.tc_count<<R300_RS_CNTL_TC_CNT_SHIFT);
1185                 r300->hw.rc.cmd[2] = 0xc0;
1186
1187
1188                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1189                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x24008;
1190
1191                 } else {
1192
1193                 /* The second constant is needed to get glxgears display anything .. */
1194                 r300->hw.rc.cmd[1] = R300_RS_CNTL_0_UNKNOWN_7 | R300_RS_CNTL_0_UNKNOWN_18;
1195                 r300->hw.rc.cmd[2] = 0;
1196
1197                 ((drm_r300_cmd_header_t*)r300->hw.rr.cmd)->unchecked_state.count = 1;
1198                 r300->hw.rr.cmd[R300_RR_ROUTE_0] = 0x4000;
1199
1200                 }
1201 }
1202
1203 #define vpucount(ptr) (((drm_r300_cmd_header_t*)(ptr))->vpu.count)
1204
1205 #define bump_vpu_count(ptr, new_count)   do{\
1206         drm_r300_cmd_header_t* _p=((drm_r300_cmd_header_t*)(ptr));\
1207         int _nc=(new_count)/4; \
1208         if(_nc>_p->vpu.count)_p->vpu.count=_nc;\
1209         }while(0)
1210
1211 void static inline setup_vertex_shader_fragment(r300ContextPtr r300, int dest, struct r300_vertex_shader_fragment *vsf)
1212 {
1213         int i;
1214
1215         if(vsf->length==0)return;
1216
1217         if(vsf->length & 0x3){
1218                 fprintf(stderr,"VERTEX_SHADER_FRAGMENT must have length divisible by 4\n");
1219                 exit(-1);
1220                 }
1221
1222         switch((dest>>8) & 0xf){
1223         case 0:
1224                 R300_STATECHANGE(r300, vpi);
1225                 for(i=0;i<vsf->length;i++)
1226                         r300->hw.vpi.cmd[R300_VPI_INSTR_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1227                 bump_vpu_count(r300->hw.vpi.cmd, vsf->length+4*(dest & 0xff));
1228                 break;
1229
1230         case 2:
1231                 R300_STATECHANGE(r300, vpp);
1232                 for(i=0;i<vsf->length;i++)
1233                         r300->hw.vpp.cmd[R300_VPP_PARAM_0+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1234                 bump_vpu_count(r300->hw.vpp.cmd, vsf->length+4*(dest & 0xff));
1235                 break;
1236         case 4:
1237                 R300_STATECHANGE(r300, vps);
1238                 for(i=0;i<vsf->length;i++)
1239                         r300->hw.vps.cmd[1+i+4*(dest & 0xff)]=(vsf->body.d[i]);
1240                 bump_vpu_count(r300->hw.vps.cmd, vsf->length+4*(dest & 0xff));
1241                 break;
1242         default:
1243                 fprintf(stderr, "%s:%s don't know how to handle dest %04x\n", __FILE__, __FUNCTION__, dest);
1244                 exit(-1);
1245         }
1246 }
1247
1248
1249 void r300SetupVertexShader(r300ContextPtr rmesa)
1250 {
1251         GLcontext* ctx = rmesa->radeon.glCtx;
1252
1253         /* Reset state, in case we don't use something */
1254         ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1255         ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1256         ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1257
1258
1259 /* This needs to be replaced by vertex shader generation code */
1260
1261
1262         /* textures enabled ? */
1263         if(rmesa->state.texture.tc_count>0){
1264                 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1265                 } else {
1266                 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1267                 }
1268
1269
1270         rmesa->state.vertex_shader.matrix[0].length=16;
1271         memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1272
1273         setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->state.vertex_shader.program));
1274
1275         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->state.vertex_shader.matrix[0]));
1276         #if 0
1277         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX1, &(rmesa->state.vertex_shader.matrix[0]));
1278         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX2, &(rmesa->state.vertex_shader.matrix[0]));
1279
1280         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR0, &(rmesa->state.vertex_shader.vector[0]));
1281         setup_vertex_shader_fragment(rmesa, VSF_DEST_VECTOR1, &(rmesa->state.vertex_shader.vector[1]));
1282         #endif
1283
1284         #if 0
1285         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1286         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1287         #endif
1288
1289         R300_STATECHANGE(rmesa, pvs);
1290         rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(rmesa->state.vertex_shader.program_start << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1291                 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1292                 | (rmesa->state.vertex_shader.program_end << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1293         rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(rmesa->state.vertex_shader.param_offset << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1294                 | (rmesa->state.vertex_shader.param_count << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1295         rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(rmesa->state.vertex_shader.unknown_ptr2 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1296         | (rmesa->state.vertex_shader.unknown_ptr3 << 0);
1297
1298         /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1299         so I leave it as a reminder */
1300         #if 0
1301         reg_start(R300_VAP_PVS_WAITIDLE,0);
1302                 e32(0x00000000);
1303         #endif
1304 }
1305
1306 void r300SetupVertexProgram(r300ContextPtr rmesa)
1307 {
1308         GLcontext* ctx = rmesa->radeon.glCtx;
1309
1310         /* Reset state, in case we don't use something */
1311         ((drm_r300_cmd_header_t*)rmesa->hw.vpp.cmd)->vpu.count = 0;
1312         ((drm_r300_cmd_header_t*)rmesa->hw.vpi.cmd)->vpu.count = 0;
1313         ((drm_r300_cmd_header_t*)rmesa->hw.vps.cmd)->vpu.count = 0;
1314
1315 #if 0
1316 /* This needs to be replaced by vertex shader generation code */
1317
1318
1319         /* textures enabled ? */
1320         if(rmesa->state.texture.tc_count>0){
1321                 rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
1322                 } else {
1323                 rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
1324                 }
1325
1326
1327         rmesa->state.vertex_shader.matrix[0].length=16;
1328         memcpy(rmesa->state.vertex_shader.matrix[0].body.f, ctx->_ModelProjectMatrix.m, 16*4);
1329 #endif
1330
1331         setup_vertex_shader_fragment(rmesa, VSF_DEST_PROGRAM, &(rmesa->current_vp->program));
1332
1333         setup_vertex_shader_fragment(rmesa, VSF_DEST_MATRIX0, &(rmesa->current_vp->params));
1334
1335         #if 0
1336         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN1, &(rmesa->state.vertex_shader.unknown1));
1337         setup_vertex_shader_fragment(rmesa, VSF_DEST_UNKNOWN2, &(rmesa->state.vertex_shader.unknown2));
1338         #endif
1339
1340         R300_STATECHANGE(rmesa, pvs);
1341         rmesa->hw.pvs.cmd[R300_PVS_CNTL_1]=(0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT)
1342                 | (rmesa->state.vertex_shader.unknown_ptr1 << R300_PVS_CNTL_1_UNKNOWN_SHIFT)
1343                 | (rmesa->current_vp->program.length/4 << R300_PVS_CNTL_1_PROGRAM_END_SHIFT);
1344         rmesa->hw.pvs.cmd[R300_PVS_CNTL_2]=(0 << R300_PVS_CNTL_2_PARAM_OFFSET_SHIFT)
1345                 | (rmesa->current_vp->params.length/4 << R300_PVS_CNTL_2_PARAM_COUNT_SHIFT);
1346         rmesa->hw.pvs.cmd[R300_PVS_CNTL_3]=(0/*rmesa->state.vertex_shader.unknown_ptr2*/ << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT)
1347         | (rmesa->current_vp->program.length/4/*rmesa->state.vertex_shader.unknown_ptr3*/ << 0);
1348
1349         /* This is done for vertex shader fragments, but also needs to be done for vap_pvs,
1350         so I leave it as a reminder */
1351         #if 0
1352         reg_start(R300_VAP_PVS_WAITIDLE,0);
1353                 e32(0x00000000);
1354         #endif
1355 }
1356
1357 void r300SetupPixelShader(r300ContextPtr rmesa)
1358 {
1359 int i,k;
1360
1361         /* This needs to be replaced by pixel shader generation code */
1362
1363         /* textures enabled ? */
1364         if(rmesa->state.texture.tc_count>0){
1365                 rmesa->state.pixel_shader=SINGLE_TEXTURE_PIXEL_SHADER;
1366                 } else {
1367                 rmesa->state.pixel_shader=FLAT_COLOR_PIXEL_SHADER;
1368                 }
1369
1370         R300_STATECHANGE(rmesa, fpt);
1371         for(i=0;i<rmesa->state.pixel_shader.program.tex.length;i++)
1372                 rmesa->hw.fpt.cmd[R300_FPT_INSTR_0+i]=rmesa->state.pixel_shader.program.tex.inst[i];
1373         rmesa->hw.fpt.cmd[R300_FPT_CMD_0]=cmducs(R300_PFS_TEXI_0, rmesa->state.pixel_shader.program.tex.length);
1374
1375         #define OUTPUT_FIELD(st, reg, field)  \
1376                 R300_STATECHANGE(rmesa, st); \
1377                 for(i=0;i<rmesa->state.pixel_shader.program.alu.length;i++) \
1378                         rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rmesa->state.pixel_shader.program.alu.inst[i].field;\
1379                 rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmducs(reg, rmesa->state.pixel_shader.program.alu.length);
1380
1381         OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
1382         OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
1383         OUTPUT_FIELD(fpi[2], R300_PFS_INSTR2_0, inst2);
1384         OUTPUT_FIELD(fpi[3], R300_PFS_INSTR3_0, inst3);
1385         #undef OUTPUT_FIELD
1386
1387         R300_STATECHANGE(rmesa, fp);
1388         for(i=0;i<4;i++){
1389                 rmesa->hw.fp.cmd[R300_FP_NODE0+i]=
1390                 (rmesa->state.pixel_shader.program.node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
1391                 | (rmesa->state.pixel_shader.program.node[i].alu_end  << R300_PFS_NODE_ALU_END_SHIFT)
1392                 | (rmesa->state.pixel_shader.program.node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
1393                 | (rmesa->state.pixel_shader.program.node[i].tex_end  << R300_PFS_NODE_TEX_END_SHIFT)
1394                 | ( (i==3) ? R300_PFS_NODE_LAST_NODE : 0);
1395                 }
1396
1397                 /*  PFS_CNTL_0 */
1398         rmesa->hw.fp.cmd[R300_FP_CNTL0]=
1399                 (rmesa->state.pixel_shader.program.active_nodes-1)
1400                 | (rmesa->state.pixel_shader.program.first_node_has_tex<<3);
1401                 /* PFS_CNTL_1 */
1402         rmesa->hw.fp.cmd[R300_FP_CNTL1]=rmesa->state.pixel_shader.program.temp_register_count;
1403                 /* PFS_CNTL_2 */
1404         rmesa->hw.fp.cmd[R300_FP_CNTL2]=
1405                 (rmesa->state.pixel_shader.program.alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
1406                 | (rmesa->state.pixel_shader.program.alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
1407                 | (rmesa->state.pixel_shader.program.tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
1408                 | (rmesa->state.pixel_shader.program.tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
1409
1410         R300_STATECHANGE(rmesa, fpp);
1411         for(i=0;i<rmesa->state.pixel_shader.param_length;i++){
1412                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+0]=r300PackFloat32(rmesa->state.pixel_shader.param[i].x);
1413                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+1]=r300PackFloat32(rmesa->state.pixel_shader.param[i].y);
1414                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+2]=r300PackFloat32(rmesa->state.pixel_shader.param[i].z);
1415                 rmesa->hw.fpp.cmd[R300_FPP_PARAM_0+4*i+3]=r300PackFloat32(rmesa->state.pixel_shader.param[i].w);
1416                 }
1417         rmesa->hw.fpp.cmd[R300_FPP_CMD_0]=cmducs(R300_PFS_PARAM_0_X, rmesa->state.pixel_shader.param_length);
1418
1419 }
1420
1421 /**
1422  * Called by Mesa after an internal state update.
1423  */
1424 static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
1425 {
1426         r300ContextPtr r300 = R300_CONTEXT(ctx);
1427
1428         _swrast_InvalidateState(ctx, new_state);
1429         _swsetup_InvalidateState(ctx, new_state);
1430         _ac_InvalidateState(ctx, new_state);
1431         _tnl_InvalidateState(ctx, new_state);
1432         _ae_invalidate_state(ctx, new_state);
1433
1434         /* Go inefficiency! */
1435         r300ResetHwState(r300);
1436 }
1437
1438
1439 /**
1440  * Completely recalculates hardware state based on the Mesa state.
1441  */
1442 void r300ResetHwState(r300ContextPtr r300)
1443 {
1444         GLcontext* ctx = r300->radeon.glCtx;
1445         int i;
1446
1447         if (RADEON_DEBUG & DEBUG_STATE)
1448                 fprintf(stderr, "%s\n", __FUNCTION__);
1449
1450                 /* This is a place to initialize registers which
1451                    have bitfields accessed by different functions
1452                    and not all bits are used */
1453         #if 0
1454         r300->hw.zs.cmd[R300_ZS_CNTL_0] = 0;
1455         r300->hw.zs.cmd[R300_ZS_CNTL_1] = 0;
1456         r300->hw.zs.cmd[R300_ZS_CNTL_2] = 0xffff00;
1457         #endif
1458
1459                 /* go and compute register values from GL state */
1460
1461         r300UpdateWindow(ctx);
1462
1463         r300ColorMask(ctx,
1464                 ctx->Color.ColorMask[RCOMP],
1465                 ctx->Color.ColorMask[GCOMP],
1466                 ctx->Color.ColorMask[BCOMP],
1467                 ctx->Color.ColorMask[ACOMP]);
1468
1469         r300Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
1470         r300DepthMask(ctx, ctx->Depth.Mask);
1471         r300DepthFunc(ctx, ctx->Depth.Func);
1472
1473         r300UpdateCulling(ctx);
1474
1475         r300_setup_routing(ctx, GL_TRUE);
1476
1477         r300UpdateTextureState(ctx);
1478         r300_setup_textures(ctx);
1479         r300_setup_rs_unit(ctx);
1480
1481         r300SetupVertexShader(r300);
1482         r300SetupPixelShader(r300);
1483
1484         r300_set_blend_state(ctx);
1485         r300AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
1486
1487                 /* Initialize magic registers
1488                  TODO : learn what they really do, or get rid of
1489                  those we don't have to touch */
1490         r300->hw.unk2080.cmd[1] = 0x0030045A;
1491
1492         r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
1493                                 | R300_VPORT_X_OFFSET_ENA
1494                                 | R300_VPORT_Y_SCALE_ENA
1495                                 | R300_VPORT_Y_OFFSET_ENA
1496                                 | R300_VPORT_Z_SCALE_ENA
1497                                 | R300_VPORT_Z_OFFSET_ENA
1498                                 | R300_VTX_W0_FMT;
1499         r300->hw.vte.cmd[2] = 0x00000008;
1500
1501         r300->hw.unk2134.cmd[1] = 0x00FFFFFF;
1502         r300->hw.unk2134.cmd[2] = 0x00000000;
1503
1504         r300->hw.unk2140.cmd[1] = 0x00000000;
1505
1506         #if 0 /* Done in setup routing */
1507         ((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->unchecked_state.count = 1;
1508         r300->hw.vir[0].cmd[1] = 0x21030003;
1509
1510         ((drm_r300_cmd_header_t*)r300->hw.vir[1].cmd)->unchecked_state.count = 1;
1511         r300->hw.vir[1].cmd[1] = 0xF688F688;
1512
1513         r300->hw.vic.cmd[R300_VIR_CNTL_0] = 0x00000001;
1514         r300->hw.vic.cmd[R300_VIR_CNTL_1] = 0x00000405;
1515         #endif
1516
1517         r300->hw.unk21DC.cmd[1] = 0xAAAAAAAA;
1518
1519         r300->hw.unk221C.cmd[1] = R300_221C_NORMAL;
1520
1521         r300->hw.unk2220.cmd[1] = r300PackFloat32(1.0);
1522         r300->hw.unk2220.cmd[2] = r300PackFloat32(1.0);
1523         r300->hw.unk2220.cmd[3] = r300PackFloat32(1.0);
1524         r300->hw.unk2220.cmd[4] = r300PackFloat32(1.0);
1525
1526         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1527                 r300->hw.unk2288.cmd[1] = R300_2288_R300;
1528         else
1529                 r300->hw.unk2288.cmd[1] = R300_2288_RV350;
1530
1531         #if 0
1532         r300->hw.vof.cmd[R300_VOF_CNTL_0] = R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT
1533                                 | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
1534         r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0; /* no textures */
1535
1536
1537         r300->hw.pvs.cmd[R300_PVS_CNTL_1] = 0;
1538         r300->hw.pvs.cmd[R300_PVS_CNTL_2] = 0;
1539         r300->hw.pvs.cmd[R300_PVS_CNTL_3] = 0;
1540         #endif
1541
1542         r300->hw.gb_enable.cmd[1] = R300_GB_POINT_STUFF_ENABLE
1543                 | R300_GB_LINE_STUFF_ENABLE
1544                 | R300_GB_TRIANGLE_STUFF_ENABLE;
1545
1546         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_0] = 0x66666666;
1547         r300->hw.gb_misc.cmd[R300_GB_MISC_MSPOS_1] = 0x06666666;
1548         if (GET_CHIP(r300->radeon.radeonScreen) == RADEON_CHIP_R300)
1549                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1550                                                         | R300_GB_TILE_PIPE_COUNT_R300
1551                                                         | R300_GB_TILE_SIZE_16;
1552         else
1553                 r300->hw.gb_misc.cmd[R300_GB_MISC_TILE_CONFIG] = R300_GB_TILE_ENABLE
1554                                                         | R300_GB_TILE_PIPE_COUNT_RV300
1555                                                         | R300_GB_TILE_SIZE_16;
1556         r300->hw.gb_misc.cmd[R300_GB_MISC_SELECT] = 0x00000000;
1557         r300->hw.gb_misc.cmd[R300_GB_MISC_AA_CONFIG] = 0x00000000; /* No antialiasing */
1558
1559         //r300->hw.txe.cmd[R300_TXE_ENABLE] = 0;
1560
1561         r300->hw.unk4200.cmd[1] = r300PackFloat32(0.0);
1562         r300->hw.unk4200.cmd[2] = r300PackFloat32(0.0);
1563         r300->hw.unk4200.cmd[3] = r300PackFloat32(1.0);
1564         r300->hw.unk4200.cmd[4] = r300PackFloat32(1.0);
1565
1566         r300->hw.unk4214.cmd[1] = 0x00050005;
1567
1568         r300->hw.ps.cmd[R300_PS_POINTSIZE] = (6 << R300_POINTSIZE_X_SHIFT) |
1569                                              (6 << R300_POINTSIZE_Y_SHIFT);
1570
1571         r300->hw.unk4230.cmd[1] = 0x01800000;
1572         r300->hw.unk4230.cmd[2] = 0x00020006;
1573         r300->hw.unk4230.cmd[3] = r300PackFloat32(1.0 / 192.0);
1574
1575         r300->hw.unk4260.cmd[1] = 0;
1576         r300->hw.unk4260.cmd[2] = r300PackFloat32(0.0);
1577         r300->hw.unk4260.cmd[3] = r300PackFloat32(1.0);
1578
1579         r300->hw.unk4274.cmd[1] = 0x00000002;
1580         r300->hw.unk4274.cmd[2] = 0x0003AAAA;
1581         r300->hw.unk4274.cmd[3] = 0x00000000;
1582         r300->hw.unk4274.cmd[4] = 0x00000000;
1583
1584         r300->hw.unk4288.cmd[1] = 0x00000000;
1585         r300->hw.unk4288.cmd[2] = 0x00000001;
1586         r300->hw.unk4288.cmd[3] = 0x00000000;
1587         r300->hw.unk4288.cmd[4] = 0x00000000;
1588         r300->hw.unk4288.cmd[5] = 0x00000000;
1589
1590         r300->hw.unk42A0.cmd[1] = 0x00000000;
1591
1592         r300->hw.unk42B4.cmd[1] = 0x00000000;
1593
1594         r300->hw.unk42C0.cmd[1] = 0x4B7FFFFF;
1595         r300->hw.unk42C0.cmd[2] = 0x00000000;
1596
1597
1598         r300->hw.unk43A4.cmd[1] = 0x0000001C;
1599         r300->hw.unk43A4.cmd[2] = 0x2DA49525;
1600
1601         r300->hw.unk43E8.cmd[1] = 0x00FFFFFF;
1602
1603         #if 0
1604         r300->hw.fp.cmd[R300_FP_CNTL0] = 0;
1605         r300->hw.fp.cmd[R300_FP_CNTL1] = 0;
1606         r300->hw.fp.cmd[R300_FP_CNTL2] = 0;
1607         r300->hw.fp.cmd[R300_FP_NODE0] = 0;
1608         r300->hw.fp.cmd[R300_FP_NODE1] = 0;
1609         r300->hw.fp.cmd[R300_FP_NODE2] = 0;
1610         r300->hw.fp.cmd[R300_FP_NODE3] = 0;
1611         #endif
1612
1613         r300->hw.unk46A4.cmd[1] = 0x00001B01;
1614         r300->hw.unk46A4.cmd[2] = 0x00001B0F;
1615         r300->hw.unk46A4.cmd[3] = 0x00001B0F;
1616         r300->hw.unk46A4.cmd[4] = 0x00001B0F;
1617         r300->hw.unk46A4.cmd[5] = 0x00000001;
1618
1619         #if 0
1620         for(i = 1; i <= 64; ++i) {
1621                 /* create NOP instructions */
1622                 r300->hw.fpi[0].cmd[i] = FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO));
1623                 r300->hw.fpi[1].cmd[i] = FP_SELC(0,XYZ,NO,FP_TMP(0),0,0);
1624                 r300->hw.fpi[2].cmd[i] = FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO));
1625                 r300->hw.fpi[3].cmd[i] = FP_SELA(0,W,NO,FP_TMP(0),0,0);
1626         }
1627         #endif
1628
1629         r300->hw.unk4BC0.cmd[1] = 0;
1630
1631         r300->hw.unk4BC8.cmd[1] = 0;
1632         r300->hw.unk4BC8.cmd[2] = 0;
1633         r300->hw.unk4BC8.cmd[3] = 0;
1634
1635         #if 0
1636         r300->hw.at.cmd[R300_AT_ALPHA_TEST] = 0;
1637         #endif
1638
1639         r300->hw.at.cmd[R300_AT_UNKNOWN] = 0;
1640         r300->hw.unk4BD8.cmd[1] = 0;
1641
1642         r300->hw.unk4E00.cmd[1] = 0;
1643
1644         #if 0
1645         r300->hw.bld.cmd[R300_BLD_CBLEND] = 0;
1646         r300->hw.bld.cmd[R300_BLD_ABLEND] = 0;
1647         #endif
1648
1649         r300->hw.unk4E10.cmd[1] = 0;
1650         r300->hw.unk4E10.cmd[2] = 0;
1651         r300->hw.unk4E10.cmd[3] = 0;
1652
1653         r300->hw.cb.cmd[R300_CB_OFFSET] =
1654                 r300->radeon.radeonScreen->backOffset +
1655                 r300->radeon.radeonScreen->fbLocation;
1656         r300->hw.cb.cmd[R300_CB_PITCH] = r300->radeon.radeonScreen->backPitch
1657                 | R300_COLOR_UNKNOWN_22_23;
1658
1659         r300->hw.unk4E50.cmd[1] = 0;
1660         r300->hw.unk4E50.cmd[2] = 0;
1661         r300->hw.unk4E50.cmd[3] = 0;
1662         r300->hw.unk4E50.cmd[4] = 0;
1663         r300->hw.unk4E50.cmd[5] = 0;
1664         r300->hw.unk4E50.cmd[6] = 0;
1665         r300->hw.unk4E50.cmd[7] = 0;
1666         r300->hw.unk4E50.cmd[8] = 0;
1667         r300->hw.unk4E50.cmd[9] = 0;
1668
1669         r300->hw.unk4E88.cmd[1] = 0;
1670
1671         r300->hw.unk4EA0.cmd[1] = 0x00000000;
1672         r300->hw.unk4EA0.cmd[2] = 0xffffffff;
1673
1674         r300->hw.unk4F10.cmd[1] = 0x00000002; // depthbuffer format?
1675         r300->hw.unk4F10.cmd[2] = 0x00000000;
1676         r300->hw.unk4F10.cmd[3] = 0x00000003;
1677         r300->hw.unk4F10.cmd[4] = 0x00000000;
1678
1679         /* experiment a bit */
1680         r300->hw.unk4F10.cmd[2] = 0x00000001; // depthbuffer format?
1681
1682         r300->hw.zb.cmd[R300_ZB_OFFSET] =
1683                 r300->radeon.radeonScreen->depthOffset +
1684                 r300->radeon.radeonScreen->fbLocation;
1685         r300->hw.zb.cmd[R300_ZB_PITCH] = r300->radeon.radeonScreen->depthPitch;
1686
1687         r300->hw.unk4F28.cmd[1] = 0;
1688
1689         r300->hw.unk4F30.cmd[1] = 0;
1690         r300->hw.unk4F30.cmd[2] = 0;
1691
1692         r300->hw.unk4F44.cmd[1] = 0;
1693
1694         r300->hw.unk4F54.cmd[1] = 0;
1695
1696         #if 0
1697         ((drm_r300_cmd_header_t*)r300->hw.vpi.cmd)->vpu.count = 0;
1698         for(i = 1; i < R300_VPI_CMDSIZE; i += 4) {
1699                 /* MOV t0, t0 */
1700                 r300->hw.vpi.cmd[i+0] = VP_OUT(ADD,TMP,0,XYZW);
1701                 r300->hw.vpi.cmd[i+1] = VP_IN(TMP,0);
1702                 r300->hw.vpi.cmd[i+2] = VP_ZERO();
1703                 r300->hw.vpi.cmd[i+3] = VP_ZERO();
1704         }
1705
1706         ((drm_r300_cmd_header_t*)r300->hw.vpp.cmd)->vpu.count = 0;
1707         for(i = 1; i < R300_VPP_CMDSIZE; ++i)
1708                 r300->hw.vpp.cmd[i] = 0;
1709         #endif
1710
1711         r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
1712         r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
1713         r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
1714         r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
1715
1716 //END: TODO
1717
1718         r300->hw.all_dirty = GL_TRUE;
1719 }
1720
1721
1722
1723 /**
1724  * Calculate initial hardware state and register state functions.
1725  * Assumes that the command buffer and state atoms have been
1726  * initialized already.
1727  */
1728 void r300InitState(r300ContextPtr r300)
1729 {
1730         GLcontext *ctx = r300->radeon.glCtx;
1731         GLuint depth_fmt;
1732
1733         radeonInitState(&r300->radeon);
1734
1735         switch (ctx->Visual.depthBits) {
1736         case 16:
1737                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffff;
1738                 depth_fmt = R200_DEPTH_FORMAT_16BIT_INT_Z;
1739                 //r300->state.stencil.clear = 0x00000000;
1740                 break;
1741         case 24:
1742                 r300->state.depth.scale = 1.0 / (GLfloat) 0xffffff;
1743                 depth_fmt = R200_DEPTH_FORMAT_24BIT_INT_Z;
1744                 //r300->state.stencil.clear = 0xff000000;
1745                 break;
1746         default:
1747                 fprintf(stderr, "Error: Unsupported depth %d... exiting\n",
1748                         ctx->Visual.depthBits);
1749                 exit(-1);
1750         }
1751
1752         /* Only have hw stencil when depth buffer is 24 bits deep */
1753         r300->state.hw_stencil = (ctx->Visual.stencilBits > 0 &&
1754                                          ctx->Visual.depthBits == 24);
1755
1756         memset(&(r300->state.texture), 0, sizeof(r300->state.texture));
1757
1758         r300ResetHwState(r300);
1759 }
1760
1761
1762
1763 /**
1764  * Initialize driver's state callback functions
1765  */
1766 void r300InitStateFuncs(struct dd_function_table* functions)
1767 {
1768         radeonInitStateFuncs(functions);
1769
1770         functions->UpdateState = r300InvalidateState;
1771         functions->AlphaFunc = r300AlphaFunc;
1772         functions->BlendColor = r300BlendColor;
1773         functions->BlendEquationSeparate = r300BlendEquationSeparate;
1774         functions->BlendFuncSeparate = r300BlendFuncSeparate;
1775         functions->Enable = r300Enable;
1776         functions->ColorMask = r300ColorMask;
1777         functions->DepthFunc = r300DepthFunc;
1778         functions->DepthMask = r300DepthMask;
1779         functions->CullFace = r300CullFace;
1780         functions->FrontFace = r300FrontFace;
1781
1782         /* Stencil related */
1783         functions->ClearStencil = r300ClearStencil;
1784         functions->StencilFunc = r300StencilFunc;
1785         functions->StencilMask = r300StencilMask;
1786         functions->StencilOp = r300StencilOp;
1787
1788         /* Viewport related */
1789         functions->Viewport = r300Viewport;
1790         functions->DepthRange = r300DepthRange;
1791         functions->PointSize = r300PointSize;
1792 }
1793