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