Merge commit 'origin/master' into gallium-map-range

17 files changed, 691 insertions, 406 deletions

diff --git a/src/gallium/drivers/r300/Makefile b/src/gallium/drivers/r300/Makefile
index 9b7524b523..a0fd17bd59 100644
--- a/src/gallium/drivers/r300/Makefile
+++ b/src/gallium/drivers/r300/Makefile
@@ -12,6 +12,7 @@ C_SOURCES = \
 	r300_screen.c \
 	r300_state.c \
 	r300_state_derived.c \
+	r300_state_invariant.c \
 	r300_state_shader.c \
 	r300_surface.c \
 	r300_swtcl_emit.c \
diff --git a/src/gallium/drivers/r300/r300_chipset.c b/src/gallium/drivers/r300/r300_chipset.c
index 196537a432..e01a0546b2 100644
--- a/src/gallium/drivers/r300/r300_chipset.c
+++ b/src/gallium/drivers/r300/r300_chipset.c
@@ -30,7 +30,7 @@
 void r300_parse_chipset(struct r300_capabilities* caps)
 {
     /* Reasonable defaults */
-    caps->has_tcl = TRUE;
+    caps->has_tcl = getenv("RADEON_NO_TCL") ? TRUE : FALSE;
     caps->is_r500 = FALSE;
     caps->num_vert_fpus = 4;
 
@@ -204,6 +204,13 @@ void r300_parse_chipset(struct r300_capabilities* caps)
             caps->has_tcl = FALSE;
             break;
 
+        case 0x793F:
+        case 0x7941:
+        case 0x7942:
+            caps->family = CHIP_FAMILY_RS600;
+            caps->has_tcl = FALSE;
+            break;
+
         case 0x796C:
         case 0x796D:
         case 0x796E:
diff --git a/src/gallium/drivers/r300/r300_chipset.h b/src/gallium/drivers/r300/r300_chipset.h
index a9cd372ec5..21eebeae60 100644
--- a/src/gallium/drivers/r300/r300_chipset.h
+++ b/src/gallium/drivers/r300/r300_chipset.h
@@ -64,6 +64,7 @@ enum {
     CHIP_FAMILY_RC410,
     CHIP_FAMILY_RS480,
     CHIP_FAMILY_RS482,
+    CHIP_FAMILY_RS600,
     CHIP_FAMILY_RS690,
     CHIP_FAMILY_RS740,
     CHIP_FAMILY_RV515,
diff --git a/src/gallium/drivers/r300/r300_context.c b/src/gallium/drivers/r300/r300_context.c
index 15a8751549..a981150143 100644
--- a/src/gallium/drivers/r300/r300_context.c
+++ b/src/gallium/drivers/r300/r300_context.c
@@ -73,7 +73,7 @@ static boolean r300_draw_range_elements(struct pipe_context* pipe,
                                              start + count - 1, NULL);
     }
 
-    return true;
+    return TRUE;
 }
 
 static boolean r300_draw_elements(struct pipe_context* pipe,
@@ -97,6 +97,7 @@ static void r300_destroy_context(struct pipe_context* context) {
     draw_destroy(r300->draw);
 
     FREE(r300->blend_color_state);
+    FREE(r300->rs_block);
     FREE(r300->scissor_state);
     FREE(r300);
 }
@@ -126,6 +127,7 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
     draw_set_rasterize_stage(r300->draw, r300_draw_swtcl_stage(r300));
 
     r300->blend_color_state = CALLOC_STRUCT(r300_blend_color_state);
+    r300->rs_block = CALLOC_STRUCT(r300_rs_block);
     r300->scissor_state = CALLOC_STRUCT(r300_scissor_state);
 
     r300_init_flush_functions(r300);
diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h
index aaab1dd2bc..5247901be5 100644
--- a/src/gallium/drivers/r300/r300_context.h
+++ b/src/gallium/drivers/r300/r300_context.h
@@ -75,6 +75,13 @@ struct r300_rs_state {
     uint32_t line_stipple_value;    /* R300_GA_LINE_STIPPLE_VALUE: 0x4260 */
 };
 
+struct r300_rs_block {
+    uint32_t ip[8]; /* R300_RS_IP_[0-7], R500_RS_IP_[0-7] */
+    uint32_t count; /* R300_RS_COUNT */
+    uint32_t inst_count; /* R300_RS_INST_COUNT */
+    uint32_t inst[8]; /* R300_RS_INST_[0-7] */
+};
+
 struct r300_sampler_state {
     uint32_t filter0;      /* R300_TX_FILTER0: 0x4400 */
     uint32_t filter1;      /* R300_TX_FILTER1: 0x4440 */
@@ -96,12 +103,13 @@ struct r300_texture_state {
 #define R300_NEW_FRAMEBUFFERS    0x0000010
 #define R300_NEW_FRAGMENT_SHADER 0x0000020
 #define R300_NEW_RASTERIZER      0x0000040
-#define R300_NEW_SAMPLER         0x0000080
-#define R300_NEW_SCISSOR         0x0008000
-#define R300_NEW_TEXTURE         0x0010000
-#define R300_NEW_VERTEX_FORMAT   0x1000000
-#define R300_NEW_VERTEX_SHADER   0x2000000
-#define R300_NEW_KITCHEN_SINK    0x3ffffff
+#define R300_NEW_RS_BLOCK        0x0000080
+#define R300_NEW_SAMPLER         0x0000100
+#define R300_NEW_SCISSOR         0x0010000
+#define R300_NEW_TEXTURE         0x0020000
+#define R300_NEW_VERTEX_FORMAT   0x2000000
+#define R300_NEW_VERTEX_SHADER   0x4000000
+#define R300_NEW_KITCHEN_SINK    0x7ffffff
 
 /* The next several objects are not pure Radeon state; they inherit from
  * various Gallium classes. */
@@ -224,6 +232,8 @@ struct r300_context {
     struct pipe_framebuffer_state framebuffer_state;
     /* Rasterizer state. */
     struct r300_rs_state* rs_state;
+    /* RS block state. */
+    struct r300_rs_block* rs_block;
     /* Sampler states. */
     struct r300_sampler_state* sampler_states[8];
     int sampler_count;
diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
index 960f45f651..91fac62cbe 100644
--- a/src/gallium/drivers/r300/r300_emit.c
+++ b/src/gallium/drivers/r300/r300_emit.c
@@ -40,9 +40,9 @@ void r300_emit_blend_state(struct r300_context* r300,
 void r300_emit_blend_color_state(struct r300_context* r300,
                                  struct r300_blend_color_state* bc)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
+
     if (r300screen->caps->is_r500) {
         BEGIN_CS(3);
         OUT_CS_REG_SEQ(R500_RB3D_CONSTANT_COLOR_AR, 2);
@@ -59,9 +59,9 @@ void r300_emit_blend_color_state(struct r300_context* r300,
 void r300_emit_dsa_state(struct r300_context* r300,
                            struct r300_dsa_state* dsa)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
+
     BEGIN_CS(r300screen->caps->is_r500 ? 8 : 8);
     OUT_CS_REG(R300_FG_ALPHA_FUNC, dsa->alpha_function);
     /* XXX figure out the r300 counterpart for this */
@@ -84,6 +84,7 @@ void r300_emit_fragment_shader(struct r300_context* r300,
 {
     CS_LOCALS(r300);
     int i;
+
     BEGIN_CS(22);
 
     OUT_CS_REG(R300_US_CONFIG, MAX2(fs->indirections - 1, 0));
@@ -114,7 +115,8 @@ void r500_emit_fragment_shader(struct r300_context* r300,
                                struct r500_fragment_shader* fs)
 {
     CS_LOCALS(r300);
-    int i = 0;
+    int i;
+
     BEGIN_CS(9 + (fs->instruction_count * 6));
     OUT_CS_REG(R500_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
     OUT_CS_REG(R500_US_PIXSIZE, fs->shader.stack_size);
@@ -191,9 +193,9 @@ void r300_emit_fb_state(struct r300_context* r300,
 
 void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
+
     BEGIN_CS(13);
     OUT_CS_REG(R300_VAP_CNTL_STATUS, rs->vap_control_status);
     OUT_CS_REG_SEQ(R300_SU_POLY_OFFSET_FRONT_SCALE, 6);
@@ -208,10 +210,44 @@ void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs)
     END_CS;
 }
 
+void r300_emit_rs_block_state(struct r300_context* r300,
+                              struct r300_rs_block* rs)
+{
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
+    CS_LOCALS(r300);
+    int i;
+
+    BEGIN_CS(21);
+    if (r300screen->caps->is_r500) {
+        OUT_CS_REG_SEQ(R500_RS_IP_0, 8);
+    } else {
+        OUT_CS_REG_SEQ(R300_RS_IP_0, 8);
+    }
+    for (i = 0; i < 8; i++) {
+        OUT_CS(rs->ip[i]);
+    }
+
+    OUT_CS_REG_SEQ(R300_RS_COUNT, 2);
+    OUT_CS(rs->count);
+    OUT_CS(rs->inst_count);
+
+    if (r300screen->caps->is_r500) {
+        OUT_CS_REG_SEQ(R500_RS_INST_0, 8);
+    } else {
+        OUT_CS_REG_SEQ(R300_RS_INST_0, 8);
+    }
+    for (i = 0; i < 8; i++) {
+        OUT_CS(rs->inst[i]);
+    }
+
+    END_CS;
+}
+
 void r300_emit_scissor_state(struct r300_context* r300,
                              struct r300_scissor_state* scissor)
 {
     CS_LOCALS(r300);
+
     BEGIN_CS(3);
     OUT_CS_REG_SEQ(R300_SC_SCISSORS_TL, 2);
     OUT_CS(scissor->scissor_top_left);
@@ -248,8 +284,7 @@ void r300_emit_vertex_format_state(struct r300_context* r300)
 /* Emit all dirty state. */
 void r300_emit_dirty_state(struct r300_context* r300)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
 
     if (!(r300->dirty_state) && !(r300->dirty_hw)) {
diff --git a/src/gallium/drivers/r300/r300_reg.h b/src/gallium/drivers/r300/r300_reg.h
index 8888b39a2f..e0da9d361e 100644
--- a/src/gallium/drivers/r300/r300_reg.h
+++ b/src/gallium/drivers/r300/r300_reg.h
@@ -732,6 +732,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define R500_RS_IP_TEX_PTR_Q_SHIFT 			18
 #define R500_RS_IP_COL_PTR_SHIFT 			24
 #define R500_RS_IP_COL_FMT_SHIFT 			27
+#       define R500_RS_SEL_S(x)                         ((x) << 0)
+#       define R500_RS_SEL_T(x)                         ((x) << 6)
+#       define R500_RS_SEL_R(x)                         ((x) << 12)
+#       define R500_RS_SEL_Q(x)                         ((x) << 18)
 #	define R500_RS_COL_PTR(x)		        ((x) << 24)
 #       define R500_RS_COL_FMT(x)                       ((x) << 27)
 /* gap */
@@ -1216,14 +1220,18 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define R500_RS_INST_14					0x4358
 #define R500_RS_INST_15					0x435c
 #define R500_RS_INST_TEX_ID_SHIFT			0
+#        define R500_RS_INST_TEX_ID(x)                  ((x) << 0)
 #define R500_RS_INST_TEX_CN_WRITE			(1 << 4)
 #define R500_RS_INST_TEX_ADDR_SHIFT			5
+#        define R500_RS_INST_TEX_ADDR(x)                ((x) << 0)
 #define R500_RS_INST_COL_ID_SHIFT			12
+#        define R500_RS_INST_COL_ID(x)                  ((x) << 12)
 #define R500_RS_INST_COL_CN_NO_WRITE			(0 << 16)
 #define R500_RS_INST_COL_CN_WRITE			(1 << 16)
 #define R500_RS_INST_COL_CN_WRITE_FBUFFER		(2 << 16)
 #define R500_RS_INST_COL_CN_WRITE_BACKFACE		(3 << 16)
 #define R500_RS_INST_COL_ADDR_SHIFT			18
+#        define R500_RS_INST_COL_ADDR(x)                ((x) << 18)
 #define R500_RS_INST_TEX_ADJ				(1 << 25)
 #define R500_RS_INST_W_CN				(1 << 26)
 
@@ -1240,9 +1248,11 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define R300_RS_INST_7                     0x434C
 #	define R300_RS_INST_TEX_ID(x)  		((x) << 0)
 #	define R300_RS_INST_TEX_CN_WRITE 	(1 << 3)
+#	define R300_RS_INST_TEX_ADDR(x)		((x) << 6)
 #	define R300_RS_INST_TEX_ADDR_SHIFT 	6
 #	define R300_RS_INST_COL_ID(x)		((x) << 11)
 #	define R300_RS_INST_COL_CN_WRITE	(1 << 14)
+#	define R300_RS_INST_COL_ADDR(x)		((x) << 17)
 #	define R300_RS_INST_COL_ADDR_SHIFT	17
 #	define R300_RS_INST_TEX_ADJ		(1 << 22)
 #	define R300_RS_COL_BIAS_UNUSED_SHIFT    23
diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c
index 5ff9015a7b..2fcd504812 100644
--- a/src/gallium/drivers/r300/r300_screen.c
+++ b/src/gallium/drivers/r300/r300_screen.c
@@ -50,6 +50,7 @@ static const char* chip_families[] = {
     "RC410",
     "RS480",
     "RS482",
+    "RS600",
     "RS690",
     "RS740",
     "RV515",
@@ -178,8 +179,11 @@ static boolean check_tex_2d_format(enum pipe_format format, boolean is_r500)
 {
     switch (format) {
         /* Colorbuffer */
+        case PIPE_FORMAT_A4R4G4B4_UNORM:
+        case PIPE_FORMAT_R5G6B5_UNORM:
+        case PIPE_FORMAT_A1R5G5B5_UNORM:
         case PIPE_FORMAT_A8R8G8B8_UNORM:
-        /* Texture */
+        /* Colorbuffer or texture */
         case PIPE_FORMAT_I8_UNORM:
         /* Z buffer */
         case PIPE_FORMAT_Z16_UNORM:
@@ -187,29 +191,25 @@ static boolean check_tex_2d_format(enum pipe_format format, boolean is_r500)
         case PIPE_FORMAT_Z24S8_UNORM:
             return TRUE;
 
-        /* XXX Supported yet unimplemented formats: */
-        case PIPE_FORMAT_A1R5G5B5_UNORM:
-        case PIPE_FORMAT_R5G6B5_UNORM:
         /* XXX These don't even exist
         case PIPE_FORMAT_A32R32G32B32:
         case PIPE_FORMAT_A16R16G16B16: */
         /* XXX Insert YUV422 packed VYUY and YVYU here */
-        /* XXX What the deuce is UV88? (r3xx accel page 14) */
-        case PIPE_FORMAT_A4R4G4B4_UNORM:
+        /* XXX What the deuce is UV88? (r3xx accel page 14)
             debug_printf("r300: Warning: Got unimplemented format: %s in %s\n",
                 pf_name(format), __FUNCTION__);
-            return FALSE;
+            return FALSE; */
 
         /* XXX Supported yet unimplemented r5xx formats: */
         /* XXX Again, what is UV1010 this time? (r5xx accel page 148) */
         /* XXX Even more that don't exist
         case PIPE_FORMAT_A10R10G10B10_UNORM:
         case PIPE_FORMAT_A2R10G10B10_UNORM:
-        case PIPE_FORMAT_I10_UNORM: */
+        case PIPE_FORMAT_I10_UNORM:
             debug_printf(
                 "r300: Warning: Got unimplemented r500 format: %s in %s\n",
                 pf_name(format), __FUNCTION__);
-            return FALSE;
+            return FALSE; */
 
         default:
             debug_printf("r300: Warning: Got unsupported format: %s in %s\n",
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index da99a3be6b..6e64ad2dc3 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -28,89 +28,11 @@
 
 #include "r300_context.h"
 #include "r300_reg.h"
+#include "r300_state_inlines.h"
 #include "r300_state_shader.h"
 
 /* r300_state: Functions used to intialize state context by translating
- * Gallium state objects into semi-native r300 state objects.
- *
- * XXX break this file up into pieces if it gets too big! */
-
-/* Pack a float into a dword. */
-static uint32_t pack_float_32(float f)
-{
-    union {
-        float f;
-        uint32_t u;
-    } u;
-
-    u.f = f;
-    return u.u;
-}
-
-static uint32_t translate_blend_function(int blend_func) {
-    switch (blend_func) {
-        case PIPE_BLEND_ADD:
-            return R300_COMB_FCN_ADD_CLAMP;
-        case PIPE_BLEND_SUBTRACT:
-            return R300_COMB_FCN_SUB_CLAMP;
-        case PIPE_BLEND_REVERSE_SUBTRACT:
-            return R300_COMB_FCN_RSUB_CLAMP;
-        case PIPE_BLEND_MIN:
-            return R300_COMB_FCN_MIN;
-        case PIPE_BLEND_MAX:
-            return R300_COMB_FCN_MAX;
-        default:
-            debug_printf("r300: Unknown blend function %d\n", blend_func);
-            break;
-    }
-    return 0;
-}
-
-/* XXX we can also offer the D3D versions of some of these... */
-static uint32_t translate_blend_factor(int blend_fact) {
-    switch (blend_fact) {
-        case PIPE_BLENDFACTOR_ONE:
-            return R300_BLEND_GL_ONE;
-        case PIPE_BLENDFACTOR_SRC_COLOR:
-            return R300_BLEND_GL_SRC_COLOR;
-        case PIPE_BLENDFACTOR_SRC_ALPHA:
-            return R300_BLEND_GL_SRC_ALPHA;
-        case PIPE_BLENDFACTOR_DST_ALPHA:
-            return R300_BLEND_GL_DST_ALPHA;
-        case PIPE_BLENDFACTOR_DST_COLOR:
-            return R300_BLEND_GL_DST_COLOR;
-        case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
-            return R300_BLEND_GL_SRC_ALPHA_SATURATE;
-        case PIPE_BLENDFACTOR_CONST_COLOR:
-            return R300_BLEND_GL_CONST_COLOR;
-        case PIPE_BLENDFACTOR_CONST_ALPHA:
-            return R300_BLEND_GL_CONST_ALPHA;
-        /* XXX WTF are these?
-        case PIPE_BLENDFACTOR_SRC1_COLOR:
-        case PIPE_BLENDFACTOR_SRC1_ALPHA: */
-        case PIPE_BLENDFACTOR_ZERO:
-            return R300_BLEND_GL_ZERO;
-        case PIPE_BLENDFACTOR_INV_SRC_COLOR:
-            return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
-        case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
-            return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
-        case PIPE_BLENDFACTOR_INV_DST_ALPHA:
-            return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
-        case PIPE_BLENDFACTOR_INV_DST_COLOR:
-            return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
-        case PIPE_BLENDFACTOR_INV_CONST_COLOR:
-            return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
-        case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
-            return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
-        /* XXX see above
-        case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
-        case PIPE_BLENDFACTOR_INV_SRC1_ALPHA: */
-        default:
-            debug_printf("r300: Unknown blend factor %d\n", blend_fact);
-            break;
-    }
-    return 0;
-}
+ * Gallium state objects into semi-native r300 state objects. */
 
 /* Create a new blend state based on the CSO blend state.
  *
@@ -126,16 +48,16 @@ static void* r300_create_blend_state(struct pipe_context* pipe,
         blend->blend_control = R300_ALPHA_BLEND_ENABLE |
                 R300_SEPARATE_ALPHA_ENABLE |
                 R300_READ_ENABLE |
-                translate_blend_function(state->rgb_func) |
-                (translate_blend_factor(state->rgb_src_factor) <<
+                r300_translate_blend_function(state->rgb_func) |
+                (r300_translate_blend_factor(state->rgb_src_factor) <<
                     R300_SRC_BLEND_SHIFT) |
-                (translate_blend_factor(state->rgb_dst_factor) <<
+                (r300_translate_blend_factor(state->rgb_dst_factor) <<
                     R300_DST_BLEND_SHIFT);
         blend->alpha_blend_control =
-                translate_blend_function(state->alpha_func) |
-                (translate_blend_factor(state->alpha_src_factor) <<
+                r300_translate_blend_function(state->alpha_func) |
+                (r300_translate_blend_factor(state->alpha_src_factor) <<
                     R300_SRC_BLEND_SHIFT) |
-                (translate_blend_factor(state->alpha_dst_factor) <<
+                (r300_translate_blend_factor(state->alpha_dst_factor) <<
                     R300_DST_BLEND_SHIFT);
     }
 
@@ -178,21 +100,17 @@ static void r300_set_blend_color(struct pipe_context* pipe,
                                  const struct pipe_blend_color* color)
 {
     struct r300_context* r300 = r300_context(pipe);
-    uint32_t r, g, b, a;
     ubyte ur, ug, ub, ua;
 
-    r = util_iround(color->color[0] * 1023.0f);
-    g = util_iround(color->color[1] * 1023.0f);
-    b = util_iround(color->color[2] * 1023.0f);
-    a = util_iround(color->color[3] * 1023.0f);
-
     ur = float_to_ubyte(color->color[0]);
     ug = float_to_ubyte(color->color[1]);
     ub = float_to_ubyte(color->color[2]);
     ua = float_to_ubyte(color->color[3]);
 
-    r300->blend_color_state->blend_color = (a << 24) | (r << 16) | (g << 8) | b;
+    util_pack_color(color->color, PIPE_FORMAT_A8R8G8B8_UNORM,
+            &r300->blend_color_state->blend_color);
 
+    /* XXX this is wrong */
     r300->blend_color_state->blend_color_red_alpha = ur | (ua << 16);
     r300->blend_color_state->blend_color_green_blue = ub | (ug << 16);
 
@@ -233,82 +151,6 @@ static void
     r300->dirty_state |= R300_NEW_CONSTANTS;
 }
 
-static uint32_t translate_depth_stencil_function(int zs_func) {
-    switch (zs_func) {
-        case PIPE_FUNC_NEVER:
-            return R300_ZS_NEVER;
-        case PIPE_FUNC_LESS:
-            return R300_ZS_LESS;
-        case PIPE_FUNC_EQUAL:
-            return R300_ZS_EQUAL;
-        case PIPE_FUNC_LEQUAL:
-            return R300_ZS_LEQUAL;
-        case PIPE_FUNC_GREATER:
-            return R300_ZS_GREATER;
-        case PIPE_FUNC_NOTEQUAL:
-            return R300_ZS_NOTEQUAL;
-        case PIPE_FUNC_GEQUAL:
-            return R300_ZS_GEQUAL;
-        case PIPE_FUNC_ALWAYS:
-            return R300_ZS_ALWAYS;
-        default:
-            debug_printf("r300: Unknown depth/stencil function %d\n",
-                zs_func);
-            break;
-    }
-    return 0;
-}
-
-static uint32_t translate_stencil_op(int s_op) {
-    switch (s_op) {
-        case PIPE_STENCIL_OP_KEEP:
-            return R300_ZS_KEEP;
-        case PIPE_STENCIL_OP_ZERO:
-            return R300_ZS_ZERO;
-        case PIPE_STENCIL_OP_REPLACE:
-            return R300_ZS_REPLACE;
-        case PIPE_STENCIL_OP_INCR:
-            return R300_ZS_INCR;
-        case PIPE_STENCIL_OP_DECR:
-            return R300_ZS_DECR;
-        case PIPE_STENCIL_OP_INCR_WRAP:
-            return R300_ZS_INCR_WRAP;
-        case PIPE_STENCIL_OP_DECR_WRAP:
-            return R300_ZS_DECR_WRAP;
-        case PIPE_STENCIL_OP_INVERT:
-            return R300_ZS_INVERT;
-        default:
-            debug_printf("r300: Unknown stencil op %d", s_op);
-            break;
-    }
-    return 0;
-}
-
-static uint32_t translate_alpha_function(int alpha_func) {
-    switch (alpha_func) {
-        case PIPE_FUNC_NEVER:
-            return R300_FG_ALPHA_FUNC_NEVER;
-        case PIPE_FUNC_LESS:
-            return R300_FG_ALPHA_FUNC_LESS;
-        case PIPE_FUNC_EQUAL:
-            return R300_FG_ALPHA_FUNC_EQUAL;
-        case PIPE_FUNC_LEQUAL:
-            return R300_FG_ALPHA_FUNC_LE;
-        case PIPE_FUNC_GREATER:
-            return R300_FG_ALPHA_FUNC_GREATER;
-        case PIPE_FUNC_NOTEQUAL:
-            return R300_FG_ALPHA_FUNC_NOTEQUAL;
-        case PIPE_FUNC_GEQUAL:
-            return R300_FG_ALPHA_FUNC_GE;
-        case PIPE_FUNC_ALWAYS:
-            return R300_FG_ALPHA_FUNC_ALWAYS;
-        default:
-            debug_printf("r300: Unknown alpha function %d", alpha_func);
-            break;
-    }
-    return 0;
-}
-
 /* Create a new depth, stencil, and alpha state based on the CSO dsa state.
  *
  * This contains the depth buffer, stencil buffer, alpha test, and such.
@@ -329,7 +171,7 @@ static void*
         }
 
         dsa->z_stencil_control |=
-            (translate_depth_stencil_function(state->depth.func) <<
+            (r300_translate_depth_stencil_function(state->depth.func) <<
                 R300_Z_FUNC_SHIFT);
     }
 
@@ -337,14 +179,14 @@ static void*
     if (state->stencil[0].enabled) {
         dsa->z_buffer_control |= R300_STENCIL_ENABLE;
         dsa->z_stencil_control |=
-                (translate_depth_stencil_function(state->stencil[0].func) <<
-                    R300_S_FRONT_FUNC_SHIFT) |
-                (translate_stencil_op(state->stencil[0].fail_op) <<
-                    R300_S_FRONT_SFAIL_OP_SHIFT) |
-                (translate_stencil_op(state->stencil[0].zpass_op) <<
-                    R300_S_FRONT_ZPASS_OP_SHIFT) |
-                (translate_stencil_op(state->stencil[0].zfail_op) <<
-                    R300_S_FRONT_ZFAIL_OP_SHIFT);
+            (r300_translate_depth_stencil_function(state->stencil[0].func) <<
+                R300_S_FRONT_FUNC_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[0].fail_op) <<
+                R300_S_FRONT_SFAIL_OP_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[0].zpass_op) <<
+                R300_S_FRONT_ZPASS_OP_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[0].zfail_op) <<
+                R300_S_FRONT_ZFAIL_OP_SHIFT);
 
         dsa->stencil_ref_mask = (state->stencil[0].ref_value) |
                 (state->stencil[0].valuemask << R300_STENCILMASK_SHIFT) |
@@ -353,14 +195,14 @@ static void*
         if (state->stencil[1].enabled) {
             dsa->z_buffer_control |= R300_STENCIL_FRONT_BACK;
             dsa->z_stencil_control |=
-                (translate_depth_stencil_function(state->stencil[1].func) <<
-                    R300_S_BACK_FUNC_SHIFT) |
-                (translate_stencil_op(state->stencil[1].fail_op) <<
-                    R300_S_BACK_SFAIL_OP_SHIFT) |
-                (translate_stencil_op(state->stencil[1].zpass_op) <<
-                    R300_S_BACK_ZPASS_OP_SHIFT) |
-                (translate_stencil_op(state->stencil[1].zfail_op) <<
-                    R300_S_BACK_ZFAIL_OP_SHIFT);
+            (r300_translate_depth_stencil_function(state->stencil[1].func) <<
+                R300_S_BACK_FUNC_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[1].fail_op) <<
+                R300_S_BACK_SFAIL_OP_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[1].zpass_op) <<
+                R300_S_BACK_ZPASS_OP_SHIFT) |
+            (r300_translate_stencil_op(state->stencil[1].zfail_op) <<
+                R300_S_BACK_ZFAIL_OP_SHIFT);
 
             dsa->stencil_ref_bf = (state->stencil[1].ref_value) |
                 (state->stencil[1].valuemask << R300_STENCILMASK_SHIFT) |
@@ -370,7 +212,8 @@ static void*
 
     /* Alpha test setup. */
     if (state->alpha.enabled) {
-        dsa->alpha_function = translate_alpha_function(state->alpha.func) |
+        dsa->alpha_function =
+            r300_translate_alpha_function(state->alpha.func) |
             R300_FG_ALPHA_FUNC_ENABLE;
         dsa->alpha_reference = CLAMP(state->alpha.ref_value * 1023.0f,
                                      0, 1023);
@@ -457,7 +300,7 @@ static void r300_bind_fs_state(struct pipe_context* pipe, void* shader)
         }
     }
 
-    fs->translated = true;
+    fs->translated = TRUE;
     r300->fs = fs;
 
     r300->dirty_state |= R300_NEW_FRAGMENT_SHADER;
@@ -475,10 +318,6 @@ static void r300_set_polygon_stipple(struct pipe_context* pipe,
     /* XXX */
 }
 
-static INLINE int pack_float_16_6x(float f) {
-    return ((int)(f * 6.0) & 0xffff);
-}
-
 /* Create a new rasterizer state based on the CSO rasterizer state.
  *
  * This is a very large chunk of state, and covers most of the graphics
@@ -530,15 +369,15 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
 
     if (rs->polygon_offset_enable) {
         rs->depth_offset_front = rs->depth_offset_back =
-                pack_float_32(state->offset_units);
+            fui(state->offset_units);
         rs->depth_scale_front = rs->depth_scale_back =
-                pack_float_32(state->offset_scale);
+            fui(state->offset_scale);
     }
 
     if (state->line_stipple_enable) {
         rs->line_stipple_config =
             R300_GA_LINE_STIPPLE_CONFIG_LINE_RESET_LINE |
-            (pack_float_32((float)state->line_stipple_factor) &
+            (fui((float)state->line_stipple_factor) &
                 R300_GA_LINE_STIPPLE_CONFIG_STIPPLE_SCALE_MASK);
         /* XXX this might need to be scaled up */
         rs->line_stipple_value = state->line_stipple_pattern;
@@ -567,83 +406,6 @@ static void r300_delete_rs_state(struct pipe_context* pipe, void* state)
     FREE(state);
 }
 
-static uint32_t translate_wrap(int wrap) {
-    switch (wrap) {
-        case PIPE_TEX_WRAP_REPEAT:
-            return R300_TX_REPEAT;
-        case PIPE_TEX_WRAP_CLAMP:
-            return R300_TX_CLAMP;
-        case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
-            return R300_TX_CLAMP_TO_EDGE;
-        case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
-            return R300_TX_CLAMP_TO_BORDER;
-        case PIPE_TEX_WRAP_MIRROR_REPEAT:
-            return R300_TX_REPEAT | R300_TX_MIRRORED;
-        case PIPE_TEX_WRAP_MIRROR_CLAMP:
-            return R300_TX_CLAMP | R300_TX_MIRRORED;
-        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
-            return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
-        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
-            return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
-        default:
-            debug_printf("r300: Unknown texture wrap %d", wrap);
-            return 0;
-    }
-}
-
-static uint32_t translate_tex_filters(int min, int mag, int mip) {
-    uint32_t retval = 0;
-    switch (min) {
-        case PIPE_TEX_FILTER_NEAREST:
-            retval |= R300_TX_MIN_FILTER_NEAREST;
-        case PIPE_TEX_FILTER_LINEAR:
-            retval |= R300_TX_MIN_FILTER_LINEAR;
-        case PIPE_TEX_FILTER_ANISO:
-            retval |= R300_TX_MIN_FILTER_ANISO;
-        default:
-            debug_printf("r300: Unknown texture filter %d", min);
-            break;
-    }
-    switch (mag) {
-        case PIPE_TEX_FILTER_NEAREST:
-            retval |= R300_TX_MAG_FILTER_NEAREST;
-        case PIPE_TEX_FILTER_LINEAR:
-            retval |= R300_TX_MAG_FILTER_LINEAR;
-        case PIPE_TEX_FILTER_ANISO:
-            retval |= R300_TX_MAG_FILTER_ANISO;
-        default:
-            debug_printf("r300: Unknown texture filter %d", mag);
-            break;
-    }
-    switch (mip) {
-        case PIPE_TEX_MIPFILTER_NONE:
-            retval |= R300_TX_MIN_FILTER_MIP_NONE;
-        case PIPE_TEX_MIPFILTER_NEAREST:
-            retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
-        case PIPE_TEX_MIPFILTER_LINEAR:
-            retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
-        default:
-            debug_printf("r300: Unknown texture filter %d", mip);
-            break;
-    }
-
-    return retval;
-}
-
-static uint32_t anisotropy(float max_aniso) {
-    if (max_aniso >= 16.0f) {
-        return R300_TX_MAX_ANISO_16_TO_1;
-    } else if (max_aniso >= 8.0f) {
-        return R300_TX_MAX_ANISO_8_TO_1;
-    } else if (max_aniso >= 4.0f) {
-        return R300_TX_MAX_ANISO_4_TO_1;
-    } else if (max_aniso >= 2.0f) {
-        return R300_TX_MAX_ANISO_2_TO_1;
-    } else {
-        return R300_TX_MAX_ANISO_1_TO_1;
-    }
-}
-
 static void*
         r300_create_sampler_state(struct pipe_context* pipe,
                                   const struct pipe_sampler_state* state)
@@ -653,19 +415,19 @@ static void*
     int lod_bias;
 
     sampler->filter0 |=
-        (translate_wrap(state->wrap_s) << R300_TX_WRAP_S_SHIFT) |
-        (translate_wrap(state->wrap_t) << R300_TX_WRAP_T_SHIFT) |
-        (translate_wrap(state->wrap_r) << R300_TX_WRAP_R_SHIFT);
+        (r300_translate_wrap(state->wrap_s) << R300_TX_WRAP_S_SHIFT) |
+        (r300_translate_wrap(state->wrap_t) << R300_TX_WRAP_T_SHIFT) |
+        (r300_translate_wrap(state->wrap_r) << R300_TX_WRAP_R_SHIFT);
 
-    sampler->filter0 |= translate_tex_filters(state->min_img_filter,
-                                              state->mag_img_filter,
-                                              state->min_mip_filter);
+    sampler->filter0 |= r300_translate_tex_filters(state->min_img_filter,
+                                                   state->mag_img_filter,
+                                                   state->min_mip_filter);
 
     lod_bias = CLAMP((int)(state->lod_bias * 32), -(1 << 9), (1 << 9) - 1);
 
     sampler->filter1 |= lod_bias << R300_LOD_BIAS_SHIFT;
 
-    sampler->filter1 |= anisotropy(state->max_anisotropy);
+    sampler->filter1 |= r300_anisotropy(state->max_anisotropy);
 
     util_pack_color(state->border_color, PIPE_FORMAT_A8R8G8B8_UNORM,
                     &sampler->border_color);
diff --git a/src/gallium/drivers/r300/r300_state_derived.c b/src/gallium/drivers/r300/r300_state_derived.c
index a51904096f..548a840f25 100644
--- a/src/gallium/drivers/r300/r300_state_derived.c
+++ b/src/gallium/drivers/r300/r300_state_derived.c
@@ -57,34 +57,40 @@ static uint32_t translate_vertex_data_type(int type) {
 /* XXX this function should be able to handle vert shaders as well as draw */
 static void r300_update_vertex_layout(struct r300_context* r300)
 {
+    struct r300_vertex_format vformat;
     struct vertex_info vinfo;
-    boolean pos = false, psize = false, fog = false;
+    boolean pos = FALSE, psize = FALSE, fog = FALSE;
     int i, texs = 0, cols = 0;
+    int tab[16];
 
     struct tgsi_shader_info* info = &r300->fs->info;
+
     memset(&vinfo, 0, sizeof(vinfo));
+    for (i = 0; i < 16; i++) {
+        tab[i] = -1;
+    }
 
     assert(info->num_inputs <= 16);
 
-    /* This is rather lame. Since draw_find_vs_output doesn't return an error
-     * when it can't find an output, we have to pre-iterate and count each
-     * output ourselves. */
     for (i = 0; i < info->num_inputs; i++) {
         switch (info->input_semantic_name[i]) {
             case TGSI_SEMANTIC_POSITION:
-                pos = true;
+                pos = TRUE;
+                tab[i] = 0;
                 break;
             case TGSI_SEMANTIC_COLOR:
-                cols++;
+                tab[i] = 2 + cols++;
                 break;
             case TGSI_SEMANTIC_FOG:
-                fog = true;
+                fog = TRUE;
+                tab[i] = 6 + texs++;
                 break;
             case TGSI_SEMANTIC_PSIZE:
-                psize = true;
+                psize = TRUE;
+                tab[i] = 1;
                 break;
             case TGSI_SEMANTIC_GENERIC:
-                texs++;
+                tab[i] = 6 + texs++;
                 break;
             default:
                 debug_printf("r300: Unknown vertex input %d\n",
@@ -105,6 +111,12 @@ static void r300_update_vertex_layout(struct r300_context* r300)
 
     if (!pos) {
         debug_printf("r300: Forcing vertex position attribute emit...\n");
+        /* Make room for the position attribute
+         * at the beginning of the tab. */
+        for (i = 1; i < 16; i++) {
+            tab[i] = tab[i-1];
+        }
+        tab[0] = 0;
     }
 
     draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_POS,
@@ -125,16 +137,17 @@ static void r300_update_vertex_layout(struct r300_context* r300)
         vinfo.hwfmt[2] |= (R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT << i);
     }
 
-    if (fog) {
+    for (i = 0; i < texs; i++) {
         draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_PERSPECTIVE,
-            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_FOG, 0));
-        vinfo.hwfmt[2] |=
-            (R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT << cols);
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_GENERIC, i));
+        vinfo.hwfmt[1] |= (R300_INPUT_CNTL_TC0 << i);
+        vinfo.hwfmt[3] |= (4 << (3 * i));
     }
 
-    for (i = 0; i < texs; i++) {
-        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_LINEAR,
-            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_GENERIC, i));
+    if (fog) {
+        i++;
+        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_PERSPECTIVE,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_FOG, 0));
         vinfo.hwfmt[1] |= (R300_INPUT_CNTL_TC0 << i);
         vinfo.hwfmt[3] |= (4 << (3 * i));
     }
@@ -152,18 +165,29 @@ static void r300_update_vertex_layout(struct r300_context* r300)
          (0xf << R300_WRITE_ENA_SHIFT))
 
         for (i = 0; i < vinfo.num_attribs; i++) {
+            /* Make sure we have a proper destination for our attribute */
+            if (tab[i] == -1) {
+                debug_printf("attrib count: %d, fp input count: %d\n",
+                        vinfo.num_attribs, info->num_inputs);
+                for (i = 0; i < vinfo.num_attribs; i++) {
+                    debug_printf("attrib: offset %d, interp %d, size %d,"
+                           " tab %d\n", vinfo.attrib[i].src_index,
+                           vinfo.attrib[i].interp_mode, vinfo.attrib[i].emit,
+                           tab[i]);
+                }
+                assert(0);
+            }
+
             temp = translate_vertex_data_type(vinfo.attrib[i].emit) |
-                R300_SIGNED;
+                (tab[i] << R300_DST_VEC_LOC_SHIFT) | R300_SIGNED;
             if (i & 1) {
                 r300->vertex_info.vap_prog_stream_cntl[i >> 1] &= 0xffff0000;
                 r300->vertex_info.vap_prog_stream_cntl[i >> 1] |=
-                        (translate_vertex_data_type(vinfo.attrib[i].emit) |
-                        R300_SIGNED) << 16;
+                        temp << 16;
             } else {
                 r300->vertex_info.vap_prog_stream_cntl[i >> 1] &= 0xffff;
                 r300->vertex_info.vap_prog_stream_cntl[i >> 1] |=
-                    translate_vertex_data_type(vinfo.attrib[i].emit) |
-                    R300_SIGNED;
+                    temp;
             }
 
             r300->vertex_info.vap_prog_stream_cntl_ext[i >> 1] |=
@@ -180,8 +204,85 @@ static void r300_update_vertex_layout(struct r300_context* r300)
 /* Set up the RS block. This is the part of the chipset that actually does
  * the rasterization of vertices into fragments. This is also the part of the
  * chipset that locks up if any part of it is even slightly wrong. */
-void r300_update_rs_block(struct r300_context* r300)
+static void r300_update_rs_block(struct r300_context* r300)
 {
+    struct r300_rs_block* rs = r300->rs_block;
+    struct vertex_info* vinfo = &r300->vertex_info.vinfo;
+    int col_count = 0, fp_offset = 0, i, tex_count = 0;
+
+    memset(rs, 0, sizeof(struct r300_rs_block));
+
+    if (r300_screen(r300->context.screen)->caps->is_r500) {
+        for (i = 0; i < vinfo->num_attribs; i++) {
+            switch (vinfo->attrib[i].interp_mode) {
+                case INTERP_LINEAR:
+                    rs->ip[col_count] |=
+                        R500_RS_COL_PTR(vinfo->attrib[i].src_index) |
+                        R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
+                    col_count++;
+                    break;
+                case INTERP_PERSPECTIVE:
+                    rs->ip[tex_count] |=
+                        R500_RS_SEL_S(vinfo->attrib[i].src_index) |
+                        R500_RS_SEL_T(vinfo->attrib[i].src_index + 1) |
+                        R500_RS_SEL_R(vinfo->attrib[i].src_index + 2) |
+                        R500_RS_SEL_Q(vinfo->attrib[i].src_index + 3);
+                    tex_count++;
+                    break;
+            }
+        }
+
+        for (i = 0; i < tex_count; i++) {
+            rs->inst[i] |= R500_RS_INST_TEX_ID(i) | R500_RS_INST_TEX_CN_WRITE |
+                R500_RS_INST_TEX_ADDR(fp_offset);
+            fp_offset++;
+        }
+
+        for (i = 0; i < col_count; i++) {
+            rs->inst[i] |= R500_RS_INST_COL_ID(i) | R500_RS_INST_COL_CN_WRITE |
+                R500_RS_INST_COL_ADDR(fp_offset);
+            fp_offset++;
+        }
+
+        rs->inst_count = MAX2(col_count, tex_count);
+    } else {
+        for (i = 0; i < vinfo->num_attribs; i++) {
+            switch (vinfo->attrib[i].interp_mode) {
+                case INTERP_LINEAR:
+                    rs->ip[col_count] |=
+                        R300_RS_COL_PTR(vinfo->attrib[i].src_index) |
+                        R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
+                    col_count++;
+                    break;
+                case INTERP_PERSPECTIVE:
+                    rs->ip[tex_count] |=
+                        R300_RS_TEX_PTR(vinfo->attrib[i].src_index) |
+                        R300_RS_SEL_S(R300_RS_SEL_C0) |
+                        R300_RS_SEL_T(R300_RS_SEL_C1) |
+                        R300_RS_SEL_R(R300_RS_SEL_C2) |
+                        R300_RS_SEL_Q(R300_RS_SEL_C3);
+                    tex_count += 4;
+                    break;
+            }
+        }
+
+        for (i = 0; i < tex_count; i++) {
+            rs->inst[i] |= R300_RS_INST_TEX_ID(i) | R300_RS_INST_TEX_CN_WRITE |
+                R300_RS_INST_TEX_ADDR(fp_offset);
+            fp_offset++;
+        }
+
+        for (i = 0; i < col_count; i++) {
+            rs->inst[i] |= R300_RS_INST_COL_ID(i) | R300_RS_INST_COL_CN_WRITE |
+                R300_RS_INST_COL_ADDR(fp_offset);
+            fp_offset++;
+        }
+    }
+
+    rs->count = (tex_count * 4) | (col_count << R300_IC_COUNT_SHIFT) |
+        R300_HIRES_EN;
+
+    rs->inst_count = MAX2(col_count, tex_count);
 }
 
 void r300_update_derived_state(struct r300_context* r300)
diff --git a/src/gallium/drivers/r300/r300_state_inlines.h b/src/gallium/drivers/r300/r300_state_inlines.h
index 005fb74ed6..630ac3b2fc 100644
--- a/src/gallium/drivers/r300/r300_state_inlines.h
+++ b/src/gallium/drivers/r300/r300_state_inlines.h
@@ -1,5 +1,6 @@
 /*
  * Copyright 2009 Joakim Sindholt <opensource@zhasha.com>
+ *                Corbin Simpson <MostAwesomeDude@gmail.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -27,56 +28,319 @@
 
 #include "r300_reg.h"
 
+/* Some maths. These should probably find their way to u_math, if needed. */
+
+static INLINE int pack_float_16_6x(float f) {
+    return ((int)(f * 6.0) & 0xffff);
+}
+
+/* Blend state. */
+
+static INLINE uint32_t r300_translate_blend_function(int blend_func)
+{
+    switch (blend_func) {
+        case PIPE_BLEND_ADD:
+            return R300_COMB_FCN_ADD_CLAMP;
+        case PIPE_BLEND_SUBTRACT:
+            return R300_COMB_FCN_SUB_CLAMP;
+        case PIPE_BLEND_REVERSE_SUBTRACT:
+            return R300_COMB_FCN_RSUB_CLAMP;
+        case PIPE_BLEND_MIN:
+            return R300_COMB_FCN_MIN;
+        case PIPE_BLEND_MAX:
+            return R300_COMB_FCN_MAX;
+        default:
+            debug_printf("r300: Unknown blend function %d\n", blend_func);
+            break;
+    }
+    return 0;
+}
+
+/* XXX we can also offer the D3D versions of some of these... */
+static INLINE uint32_t r300_translate_blend_factor(int blend_fact)
+{
+    switch (blend_fact) {
+        case PIPE_BLENDFACTOR_ONE:
+            return R300_BLEND_GL_ONE;
+        case PIPE_BLENDFACTOR_SRC_COLOR:
+            return R300_BLEND_GL_SRC_COLOR;
+        case PIPE_BLENDFACTOR_SRC_ALPHA:
+            return R300_BLEND_GL_SRC_ALPHA;
+        case PIPE_BLENDFACTOR_DST_ALPHA:
+            return R300_BLEND_GL_DST_ALPHA;
+        case PIPE_BLENDFACTOR_DST_COLOR:
+            return R300_BLEND_GL_DST_COLOR;
+        case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
+            return R300_BLEND_GL_SRC_ALPHA_SATURATE;
+        case PIPE_BLENDFACTOR_CONST_COLOR:
+            return R300_BLEND_GL_CONST_COLOR;
+        case PIPE_BLENDFACTOR_CONST_ALPHA:
+            return R300_BLEND_GL_CONST_ALPHA;
+        /* XXX WTF are these?
+        case PIPE_BLENDFACTOR_SRC1_COLOR:
+        case PIPE_BLENDFACTOR_SRC1_ALPHA: */
+        case PIPE_BLENDFACTOR_ZERO:
+            return R300_BLEND_GL_ZERO;
+        case PIPE_BLENDFACTOR_INV_SRC_COLOR:
+            return R300_BLEND_GL_ONE_MINUS_SRC_COLOR;
+        case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
+            return R300_BLEND_GL_ONE_MINUS_SRC_ALPHA;
+        case PIPE_BLENDFACTOR_INV_DST_ALPHA:
+            return R300_BLEND_GL_ONE_MINUS_DST_ALPHA;
+        case PIPE_BLENDFACTOR_INV_DST_COLOR:
+            return R300_BLEND_GL_ONE_MINUS_DST_COLOR;
+        case PIPE_BLENDFACTOR_INV_CONST_COLOR:
+            return R300_BLEND_GL_ONE_MINUS_CONST_COLOR;
+        case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
+            return R300_BLEND_GL_ONE_MINUS_CONST_ALPHA;
+        /* XXX see above
+        case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
+        case PIPE_BLENDFACTOR_INV_SRC1_ALPHA: */
+        default:
+            debug_printf("r300: Unknown blend factor %d\n", blend_fact);
+            break;
+    }
+    return 0;
+}
+
+/* DSA state. */
+
+static INLINE uint32_t r300_translate_depth_stencil_function(int zs_func)
+{
+    switch (zs_func) {
+        case PIPE_FUNC_NEVER:
+            return R300_ZS_NEVER;
+        case PIPE_FUNC_LESS:
+            return R300_ZS_LESS;
+        case PIPE_FUNC_EQUAL:
+            return R300_ZS_EQUAL;
+        case PIPE_FUNC_LEQUAL:
+            return R300_ZS_LEQUAL;
+        case PIPE_FUNC_GREATER:
+            return R300_ZS_GREATER;
+        case PIPE_FUNC_NOTEQUAL:
+            return R300_ZS_NOTEQUAL;
+        case PIPE_FUNC_GEQUAL:
+            return R300_ZS_GEQUAL;
+        case PIPE_FUNC_ALWAYS:
+            return R300_ZS_ALWAYS;
+        default:
+            debug_printf("r300: Unknown depth/stencil function %d\n",
+                zs_func);
+            break;
+    }
+    return 0;
+}
+
+static INLINE uint32_t r300_translate_stencil_op(int s_op)
+{
+    switch (s_op) {
+        case PIPE_STENCIL_OP_KEEP:
+            return R300_ZS_KEEP;
+        case PIPE_STENCIL_OP_ZERO:
+            return R300_ZS_ZERO;
+        case PIPE_STENCIL_OP_REPLACE:
+            return R300_ZS_REPLACE;
+        case PIPE_STENCIL_OP_INCR:
+            return R300_ZS_INCR;
+        case PIPE_STENCIL_OP_DECR:
+            return R300_ZS_DECR;
+        case PIPE_STENCIL_OP_INCR_WRAP:
+            return R300_ZS_INCR_WRAP;
+        case PIPE_STENCIL_OP_DECR_WRAP:
+            return R300_ZS_DECR_WRAP;
+        case PIPE_STENCIL_OP_INVERT:
+            return R300_ZS_INVERT;
+        default:
+            debug_printf("r300: Unknown stencil op %d", s_op);
+            break;
+    }
+    return 0;
+}
+
+static INLINE uint32_t r300_translate_alpha_function(int alpha_func)
+{
+    switch (alpha_func) {
+        case PIPE_FUNC_NEVER:
+            return R300_FG_ALPHA_FUNC_NEVER;
+        case PIPE_FUNC_LESS:
+            return R300_FG_ALPHA_FUNC_LESS;
+        case PIPE_FUNC_EQUAL:
+            return R300_FG_ALPHA_FUNC_EQUAL;
+        case PIPE_FUNC_LEQUAL:
+            return R300_FG_ALPHA_FUNC_LE;
+        case PIPE_FUNC_GREATER:
+            return R300_FG_ALPHA_FUNC_GREATER;
+        case PIPE_FUNC_NOTEQUAL:
+            return R300_FG_ALPHA_FUNC_NOTEQUAL;
+        case PIPE_FUNC_GEQUAL:
+            return R300_FG_ALPHA_FUNC_GE;
+        case PIPE_FUNC_ALWAYS:
+            return R300_FG_ALPHA_FUNC_ALWAYS;
+        default:
+            debug_printf("r300: Unknown alpha function %d", alpha_func);
+            break;
+    }
+    return 0;
+}
+
+/* Texture sampler state. */
+
+static INLINE uint32_t r300_translate_wrap(int wrap)
+{
+    switch (wrap) {
+        case PIPE_TEX_WRAP_REPEAT:
+            return R300_TX_REPEAT;
+        case PIPE_TEX_WRAP_CLAMP:
+            return R300_TX_CLAMP;
+        case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+            return R300_TX_CLAMP_TO_EDGE;
+        case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+            return R300_TX_CLAMP_TO_BORDER;
+        case PIPE_TEX_WRAP_MIRROR_REPEAT:
+            return R300_TX_REPEAT | R300_TX_MIRRORED;
+        case PIPE_TEX_WRAP_MIRROR_CLAMP:
+            return R300_TX_CLAMP | R300_TX_MIRRORED;
+        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+            return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
+        case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+            return R300_TX_CLAMP_TO_EDGE | R300_TX_MIRRORED;
+        default:
+            debug_printf("r300: Unknown texture wrap %d", wrap);
+            return 0;
+    }
+}
+
+static INLINE uint32_t r300_translate_tex_filters(int min, int mag, int mip)
+{
+    uint32_t retval = 0;
+    switch (min) {
+        case PIPE_TEX_FILTER_NEAREST:
+            retval |= R300_TX_MIN_FILTER_NEAREST;
+        case PIPE_TEX_FILTER_LINEAR:
+            retval |= R300_TX_MIN_FILTER_LINEAR;
+        case PIPE_TEX_FILTER_ANISO:
+            retval |= R300_TX_MIN_FILTER_ANISO;
+        default:
+            debug_printf("r300: Unknown texture filter %d", min);
+            break;
+    }
+    switch (mag) {
+        case PIPE_TEX_FILTER_NEAREST:
+            retval |= R300_TX_MAG_FILTER_NEAREST;
+        case PIPE_TEX_FILTER_LINEAR:
+            retval |= R300_TX_MAG_FILTER_LINEAR;
+        case PIPE_TEX_FILTER_ANISO:
+            retval |= R300_TX_MAG_FILTER_ANISO;
+        default:
+            debug_printf("r300: Unknown texture filter %d", mag);
+            break;
+    }
+    switch (mip) {
+        case PIPE_TEX_MIPFILTER_NONE:
+            retval |= R300_TX_MIN_FILTER_MIP_NONE;
+        case PIPE_TEX_MIPFILTER_NEAREST:
+            retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
+        case PIPE_TEX_MIPFILTER_LINEAR:
+            retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
+        default:
+            debug_printf("r300: Unknown texture filter %d", mip);
+            break;
+    }
+
+    return retval;
+}
+
+static INLINE uint32_t r300_anisotropy(float max_aniso)
+{
+    if (max_aniso >= 16.0f) {
+        return R300_TX_MAX_ANISO_16_TO_1;
+    } else if (max_aniso >= 8.0f) {
+        return R300_TX_MAX_ANISO_8_TO_1;
+    } else if (max_aniso >= 4.0f) {
+        return R300_TX_MAX_ANISO_4_TO_1;
+    } else if (max_aniso >= 2.0f) {
+        return R300_TX_MAX_ANISO_2_TO_1;
+    } else {
+        return R300_TX_MAX_ANISO_1_TO_1;
+    }
+}
+
+/* Buffer formats. */
+
 static INLINE uint32_t r300_translate_colorformat(enum pipe_format format)
 {
     switch (format) {
-    case PIPE_FORMAT_A8R8G8B8_UNORM:
-        return R300_COLOR_FORMAT_ARGB8888;
-    case PIPE_FORMAT_I8_UNORM:
-        return R300_COLOR_FORMAT_I8;
-    case PIPE_FORMAT_A1R5G5B5_UNORM:
-        return R300_COLOR_FORMAT_ARGB1555;
-    case PIPE_FORMAT_R5G6B5_UNORM:
-        return R300_COLOR_FORMAT_RGB565;
-    /* XXX Not in pipe_format
-    case PIPE_FORMAT_A32R32G32B32:
-        return R300_COLOR_FORMAT_ARGB32323232;
-    case PIPE_FORMAT_A16R16G16B16:
-        return R300_COLOR_FORMAT_ARGB16161616; */
-    case PIPE_FORMAT_A4R4G4B4_UNORM:
-        return R300_COLOR_FORMAT_ARGB4444;
-    /* XXX Not in pipe_format
-    case PIPE_FORMAT_A10R10G10B10_UNORM:
-        return R500_COLOR_FORMAT_ARGB10101010;
-    case PIPE_FORMAT_A2R10G10B10_UNORM:
-        return R500_COLOR_FORMAT_ARGB2101010;
-    case PIPE_FORMAT_I10_UNORM:
-        return R500_COLOR_FORMAT_I10; */
-    default:
-        debug_printf("r300: Implementation error: " \
-            "Got unsupported color format %s in %s\n",
-            pf_name(format), __FUNCTION__);
-        break;
+        /* 8-bit buffers */
+        case PIPE_FORMAT_I8_UNORM:
+            return R300_COLOR_FORMAT_I8;
+        /* 16-bit buffers */
+        case PIPE_FORMAT_R5G6B5_UNORM:
+            return R300_COLOR_FORMAT_RGB565;
+        case PIPE_FORMAT_A1R5G5B5_UNORM:
+            return R300_COLOR_FORMAT_ARGB1555;
+        case PIPE_FORMAT_A4R4G4B4_UNORM:
+            return R300_COLOR_FORMAT_ARGB4444;
+        /* 32-bit buffers */
+        case PIPE_FORMAT_A8R8G8B8_UNORM:
+            return R300_COLOR_FORMAT_ARGB8888;
+        /* XXX Not in pipe_format
+        case PIPE_FORMAT_A32R32G32B32:
+            return R300_COLOR_FORMAT_ARGB32323232;
+        case PIPE_FORMAT_A16R16G16B16:
+            return R300_COLOR_FORMAT_ARGB16161616; */
+        /* XXX Not in pipe_format
+        case PIPE_FORMAT_A10R10G10B10_UNORM:
+            return R500_COLOR_FORMAT_ARGB10101010;
+        case PIPE_FORMAT_A2R10G10B10_UNORM:
+            return R500_COLOR_FORMAT_ARGB2101010;
+        case PIPE_FORMAT_I10_UNORM:
+            return R500_COLOR_FORMAT_I10; */
+        default:
+            debug_printf("r300: Implementation error: " \
+                "Got unsupported color format %s in %s\n",
+                pf_name(format), __FUNCTION__);
+            break;
     }
-    
     return 0;
 }
 
 static INLINE uint32_t r300_translate_zsformat(enum pipe_format format)
 {
     switch (format) {
-    case PIPE_FORMAT_Z16_UNORM:
-        return R300_DEPTHFORMAT_16BIT_INT_Z;
-    /* XXX R300_DEPTHFORMAT_16BIT_13E3 anyone? */
-    case PIPE_FORMAT_Z24S8_UNORM:
-        return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
-    default:
-        debug_printf("r300: Implementation error: " \
-            "Got unsupported ZS format %s in %s\n",
-            pf_name(format), __FUNCTION__);
-        break;
+        /* 16-bit depth, no stencil */
+        case PIPE_FORMAT_Z16_UNORM:
+            return R300_DEPTHFORMAT_16BIT_INT_Z;
+        /* 24-bit depth, 8-bit stencil */
+        case PIPE_FORMAT_Z24S8_UNORM:
+            return R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL;
+        default:
+            debug_printf("r300: Implementation error: " \
+                "Got unsupported ZS format %s in %s\n",
+                pf_name(format), __FUNCTION__);
+            break;
+    }
+    return 0;
+}
+
+/* Non-CSO state. (For now.) */
+
+static INLINE uint32_t r300_translate_gb_pipes(int pipe_count)
+{
+    switch (pipe_count) {
+        case 1:
+            return R300_GB_TILE_PIPE_COUNT_RV300;
+            break;
+        case 2:
+            return R300_GB_TILE_PIPE_COUNT_R300;
+            break;
+        case 3:
+            return R300_GB_TILE_PIPE_COUNT_R420_3P;
+            break;
+        case 4:
+            return R300_GB_TILE_PIPE_COUNT_R420;
+            break;
     }
-    
     return 0;
 }
 
diff --git a/src/gallium/drivers/r300/r300_state_invariant.c b/src/gallium/drivers/r300/r300_state_invariant.c
new file mode 100644
index 0000000000..7fd7aefeb7
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_invariant.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009 Joakim Sindholt <opensource@zhasha.com>
+ *                Corbin Simpson <MostAwesomeDude@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE. */
+
+#include "r300_state_invariant.h"
+
+/* Calculate and emit invariant state. This is data that the 3D engine
+ * will probably want at the beginning of every CS, but it's not currently
+ * handled by any CSO setup, and in addition it doesn't really change much.
+ *
+ * Note that eventually this should be empty, but it's useful for development
+ * and general unduplication of code. */
+void r300_emit_invariant_state(struct r300_context* r300)
+{
+    struct r300_capabilities* caps = r300_screen(r300->context.screen)->caps;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(14);
+    /* Amount of time to wait for vertex fetches in PVS */
+    OUT_CS_REG(VAP_PVS_VTX_TIMEOUT_REG, 0xffff);
+    /* Various GB enables */
+    OUT_CS_REG(R300_GB_ENABLE, R300_GB_POINT_STUFF_ENABLE |
+        R300_GB_LINE_STUFF_ENABLE | R300_GB_TRIANGLE_STUFF_ENABLE);
+    /* Subpixel multisampling for AA */
+    OUT_CS_REG(R300_GB_MSPOS0, 0x66666666);
+    OUT_CS_REG(R300_GB_MSPOS1, 0x66666666);
+    /* GB tile config and pipe setup */
+    OUT_CS_REG(R300_GB_TILE_CONFIG, R300_GB_TILE_DISABLE |
+        r300_translate_gb_pipes(caps->num_frag_pipes));
+    /* Source of fog depth */
+    OUT_CS_REG(R300_GB_SELECT, R300_GB_FOG_SELECT_1_1_W);
+    /* AA enable */
+    OUT_CS_REG(R300_GB_AA_CONFIG, 0x0);
+    END_CS;
+}
diff --git a/src/gallium/drivers/r300/r300_state_invariant.h b/src/gallium/drivers/r300/r300_state_invariant.h
new file mode 100644
index 0000000000..8204bf9588
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_invariant.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE. */
+
+#ifndef R300_STATE_INVARIANT_H
+#define R300_STATE_INVARIANT_H
+
+#include "r300_context.h"
+#include "r300_cs.h"
+#include "r300_reg.h"
+#include "r300_state_inlines.h"
+
+void r300_emit_invariant_state(struct r300_context* r300);
+
+#endif /* R300_STATE_INVARIANT_H */
diff --git a/src/gallium/drivers/r300/r300_surface.c b/src/gallium/drivers/r300/r300_surface.c
index 49e4a96f83..288d8dea15 100644
--- a/src/gallium/drivers/r300/r300_surface.c
+++ b/src/gallium/drivers/r300/r300_surface.c
@@ -33,9 +33,10 @@ static void r300_surface_fill(struct pipe_context* pipe,
 {
     struct r300_context* r300 = r300_context(pipe);
     CS_LOCALS(r300);
-    struct r300_capabilities* caps = ((struct r300_screen*)pipe->screen)->caps;
+    struct r300_capabilities* caps = r300_screen(pipe->screen)->caps;
     struct r300_texture* tex = (struct r300_texture*)dest->texture;
     int i;
+
     float r, g, b, a;
     unsigned pixpitch = tex->stride / tex->tex.block.size;
     r = (float)((color >> 16) & 0xff) / 255.0f;
@@ -55,7 +56,14 @@ static void r300_surface_fill(struct pipe_context* pipe,
         return;
     }*/
 
-    BEGIN_CS(163 + (caps->is_r500 ? 22 : 14) + (caps->has_tcl ? 4 : 2));
+    r300_emit_invariant_state(r300);
+
+    r300_emit_blend_state(r300, &blend_clear_state);
+    r300_emit_blend_color_state(r300, &blend_color_clear_state);
+    r300_emit_dsa_state(r300, &dsa_clear_state);
+    r300_emit_rs_state(r300, &rs_clear_state);
+
+    BEGIN_CS(129 + (caps->is_r500 ? 22 : 14) + (caps->has_tcl ? 4 : 2));
     /* Flush PVS. */
     OUT_CS_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0x0);
 
@@ -69,7 +77,12 @@ static void r300_surface_fill(struct pipe_context* pipe,
     OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, 0xFFFFFF);
     OUT_CS_REG(R300_VAP_VF_MIN_VTX_INDX, 0x0);
     /* XXX endian */
-    OUT_CS_REG(R300_VAP_CNTL_STATUS, R300_VC_NO_SWAP);
+    if (caps->has_tcl) {
+        OUT_CS_REG(R300_VAP_CNTL_STATUS, R300_VC_NO_SWAP);
+    } else {
+        OUT_CS_REG(R300_VAP_CNTL_STATUS, R300_VC_NO_SWAP |
+                R300_VAP_TCL_BYPASS);
+    }
     OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_0, 0x0);
     /* XXX magic number not in r300_reg */
     OUT_CS_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0xAAAAAAAA);
@@ -79,18 +92,6 @@ static void r300_surface_fill(struct pipe_context* pipe,
     OUT_CS_32F(1.0);
     OUT_CS_32F(1.0);
     OUT_CS_32F(1.0);
-    /* XXX is this too long? */
-    OUT_CS_REG(VAP_PVS_VTX_TIMEOUT_REG, 0xFFFF);
-    OUT_CS_REG(R300_GB_ENABLE, R300_GB_POINT_STUFF_ENABLE |
-        R300_GB_LINE_STUFF_ENABLE | R300_GB_TRIANGLE_STUFF_ENABLE);
-    /* XXX more magic numbers */
-    OUT_CS_REG(R300_GB_MSPOS0, 0x66666666);
-    OUT_CS_REG(R300_GB_MSPOS1, 0x66666666);
-    /* XXX why doesn't classic Mesa write the number of pipes, too? */
-    OUT_CS_REG(R300_GB_TILE_CONFIG, R300_GB_TILE_ENABLE |
-        R300_GB_TILE_SIZE_16);
-    OUT_CS_REG(R300_GB_SELECT, R300_GB_FOG_SELECT_1_1_W);
-    OUT_CS_REG(R300_GB_AA_CONFIG, 0x0);
     /* XXX point tex stuffing */
     OUT_CS_REG_SEQ(R300_GA_POINT_S0, 1);
     OUT_CS_32F(0.0);
@@ -102,9 +103,6 @@ static void r300_surface_fill(struct pipe_context* pipe,
     OUT_CS_REG(R300_GA_POINT_MINMAX, 0x6 |
         (0x1800 << R300_GA_POINT_MINMAX_MAX_SHIFT));
     /* XXX this big chunk should be refactored into rs_state */
-    OUT_CS_REG(R300_GA_LINE_CNTL, 0x00030006);
-    OUT_CS_REG(R300_GA_LINE_STIPPLE_CONFIG, 0x3BAAAAAB);
-    OUT_CS_REG(R300_GA_LINE_STIPPLE_VALUE, 0x00000000);
     OUT_CS_REG(R300_GA_LINE_S0, 0x00000000);
     OUT_CS_REG(R300_GA_LINE_S1, 0x3F800000);
     OUT_CS_REG(R300_GA_ENHANCE, 0x00000002);
@@ -117,12 +115,6 @@ static void r300_surface_fill(struct pipe_context* pipe,
     OUT_CS_REG(R300_GA_FOG_SCALE, 0x3DBF1412);
     OUT_CS_REG(R300_GA_FOG_OFFSET, 0x00000000);
     OUT_CS_REG(R300_SU_TEX_WRAP, 0x00000000);
-    OUT_CS_REG(R300_SU_POLY_OFFSET_FRONT_SCALE, 0x00000000);
-    OUT_CS_REG(R300_SU_POLY_OFFSET_FRONT_OFFSET, 0x00000000);
-    OUT_CS_REG(R300_SU_POLY_OFFSET_BACK_SCALE, 0x00000000);
-    OUT_CS_REG(R300_SU_POLY_OFFSET_BACK_OFFSET, 0x00000000);
-    OUT_CS_REG(R300_SU_POLY_OFFSET_ENABLE, 0x00000000);
-    OUT_CS_REG(R300_SU_CULL_MODE, 0x00000000);
     OUT_CS_REG(R300_SU_DEPTH_SCALE, 0x4B7FFFFF);
     OUT_CS_REG(R300_SU_DEPTH_OFFSET, 0x00000000);
     OUT_CS_REG(R300_SC_HYPERZ, 0x0000001C);
@@ -190,11 +182,6 @@ static void r300_surface_fill(struct pipe_context* pipe,
             R300_PS_UCP_MODE_CLIP_AS_TRIFAN);
     }
 
-    /* The size of the point we're about to draw, in sixths of pixels */
-    OUT_CS_REG(R300_GA_POINT_SIZE,
-        ((h * 6) & R300_POINTSIZE_Y_MASK) |
-        ((w * 6) << R300_POINTSIZE_X_SHIFT));
-
     /* XXX */
     OUT_CS_REG(R300_SC_CLIP_RULE, 0xaaaa);
 
@@ -240,7 +227,7 @@ static void r300_surface_fill(struct pipe_context* pipe,
         r300_emit_fragment_shader(r300, &r300_passthrough_fragment_shader);
     }
 
-    BEGIN_CS(8 + (caps->has_tcl ? 20 : 2));
+    BEGIN_CS(7 + (caps->has_tcl ? 21 : 2));
     OUT_CS_REG_SEQ(R300_US_OUT_FMT_0, 4);
     OUT_CS(R300_C0_SEL_B | R300_C1_SEL_G | R300_C2_SEL_R | R300_C3_SEL_A);
     OUT_CS(R300_US_OUT_FMT_UNUSED);
@@ -277,9 +264,10 @@ static void r300_surface_fill(struct pipe_context* pipe,
     }
     END_CS;
 
-    r300_emit_blend_state(r300, &blend_clear_state);
-    r300_emit_blend_color_state(r300, &blend_color_clear_state);
-    r300_emit_dsa_state(r300, &dsa_clear_state);
+    /* The size of the point we're about to draw, in sixths of pixels */
+    OUT_CS_REG(R300_GA_POINT_SIZE,
+        ((h * 6) & R300_POINTSIZE_Y_MASK) |
+        ((w * 6) << R300_POINTSIZE_X_SHIFT));
 
     BEGIN_CS(24);
     /* Flush colorbuffer and blend caches. */
diff --git a/src/gallium/drivers/r300/r300_surface.h b/src/gallium/drivers/r300/r300_surface.h
index 442eac2cf2..807aad39e4 100644
--- a/src/gallium/drivers/r300/r300_surface.h
+++ b/src/gallium/drivers/r300/r300_surface.h
@@ -57,4 +57,16 @@ const struct r300_dsa_state dsa_clear_state = {
     .stencil_ref_bf = 0x0,
 };
 
+const struct r300_rs_state rs_clear_state = {
+    .line_control = 0x00030006,
+    .depth_scale_front = 0x0,
+    .depth_offset_front = 0x0,
+    .depth_scale_back = 0x0,
+    .depth_offset_back = 0x0,
+    .polygon_offset_enable = 0x0,
+    .cull_mode = 0x0,
+    .line_stipple_config = 0x3BAAAAAB,
+    .line_stipple_value = 0x0,
+};
+
 #endif /* R300_SURFACE_H */
diff --git a/src/gallium/drivers/r300/r300_swtcl_emit.c b/src/gallium/drivers/r300/r300_swtcl_emit.c
index 5b028aaf7b..f9baaade1e 100644
--- a/src/gallium/drivers/r300/r300_swtcl_emit.c
+++ b/src/gallium/drivers/r300/r300_swtcl_emit.c
@@ -27,6 +27,7 @@
 #include "r300_cs.h"
 #include "r300_context.h"
 #include "r300_reg.h"
+#include "r300_state_derived.h"
 
 /* r300_swtcl_emit: Vertex and index buffer primitive emission. No HW TCL. */
 
@@ -91,9 +92,9 @@ static boolean r300_swtcl_render_allocate_vertices(struct vbuf_render* render,
     r300render->vertex_size = vertex_size;
 
     if (r300render->vbo) {
-        return true;
+        return TRUE;
     } else {
-        return false;
+        return FALSE;
     }
 }
 
@@ -167,11 +168,11 @@ static boolean r300_swtcl_render_set_primitive(struct vbuf_render* render,
             r300render->hwprim = R300_VAP_VF_CNTL__PRIM_POLYGON;
             break;
         default:
-            return false;
+            return FALSE;
             break;
     }
 
-    return true;
+    return TRUE;
 }
 
 static void prepare_render(struct r300_swtcl_render* render)
@@ -191,12 +192,15 @@ static void prepare_render(struct r300_swtcl_render* render)
      * PACKET3 [3D_LOAD_VBPNTR]
      * COUNT   [1]
      * FORMAT  [size | stride << 8]
+     * OFFSET  [0]
      * VBPNTR  [relocated BO]
      */
     BEGIN_CS(5);
     OUT_CS(CP_PACKET3(R300_PACKET3_3D_LOAD_VBPNTR, 3));
     OUT_CS(1);
-    OUT_CS(r300->vertex_info.vinfo.size | (r300->vertex_info.vinfo.size << 8));
+    OUT_CS(r300->vertex_info.vinfo.size |
+            (r300->vertex_info.vinfo.size << 8));
+    OUT_CS(render->vbo_offset);
     OUT_CS_RELOC(render->vbo, 0, RADEON_GEM_DOMAIN_GTT, 0, 0);
     END_CS;
 }
@@ -218,7 +222,7 @@ static void r300_swtcl_render_draw_arrays(struct vbuf_render* render,
     BEGIN_CS(2);
     OUT_CS(CP_PACKET3(R300_PACKET3_3D_DRAW_VBUF_2, 0));
     OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST | (count << 16) |
-           r300render->hwprim | R300_VAP_VF_CNTL__INDEX_SIZE_32bit);
+           r300render->hwprim);
     END_CS;
 }
 
diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index edd4370663..8251a597ea 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -31,8 +31,9 @@ static void r300_setup_miptree(struct r300_texture* tex)
 {
     struct pipe_texture* base = &tex->tex;
     int stride, size, offset;
+    int i;
 
-    for (int i = 0; i <= base->last_level; i++) {
+    for (i = 0; i <= base->last_level; i++) {
         if (i > 0) {
             base->width[i] = minify(base->width[i-1]);
             base->height[i] = minify(base->height[i-1]);