18 files changed, 284 insertions, 293 deletions

diff --git a/src/mesa/state_tracker/st_atom_blend.c b/src/mesa/state_tracker/st_atom_blend.c
index 2a9d2091536..6c13fc81415 100644
--- a/src/mesa/state_tracker/st_atom_blend.c
+++ b/src/mesa/state_tracker/st_atom_blend.c
@@ -33,11 +33,11 @@
  
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_atom.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "cso_cache/cso_context.h"
 
 
 /**
@@ -155,44 +155,43 @@ translate_logicop(GLenum logicop)
 static void 
 update_blend( struct st_context *st )
 {
-   struct pipe_blend_state blend;
-   const struct cso_blend *cso;
+   struct pipe_blend_state *blend = &st->state.blend;
 
-   memset(&blend, 0, sizeof(blend));
+   memset(blend, 0, sizeof(*blend));
 
    if (st->ctx->Color.ColorLogicOpEnabled ||
        (st->ctx->Color.BlendEnabled &&
         st->ctx->Color.BlendEquationRGB == GL_LOGIC_OP)) {
       /* logicop enabled */
-      blend.logicop_enable = 1;
-      blend.logicop_func = translate_logicop(st->ctx->Color.LogicOp);
+      blend->logicop_enable = 1;
+      blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp);
    }
    else if (st->ctx->Color.BlendEnabled) {
       /* blending enabled */
-      blend.blend_enable = 1;
+      blend->blend_enable = 1;
 
-      blend.rgb_func = translate_blend(st->ctx->Color.BlendEquationRGB);
+      blend->rgb_func = translate_blend(st->ctx->Color.BlendEquationRGB);
       if (st->ctx->Color.BlendEquationRGB == GL_MIN ||
           st->ctx->Color.BlendEquationRGB == GL_MAX) {
          /* Min/max are special */
-         blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend.rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rgb_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
       }
       else {
-         blend.rgb_src_factor = translate_blend(st->ctx->Color.BlendSrcRGB);
-         blend.rgb_dst_factor = translate_blend(st->ctx->Color.BlendDstRGB);
+         blend->rgb_src_factor = translate_blend(st->ctx->Color.BlendSrcRGB);
+         blend->rgb_dst_factor = translate_blend(st->ctx->Color.BlendDstRGB);
       }
 
-      blend.alpha_func = translate_blend(st->ctx->Color.BlendEquationA);
+      blend->alpha_func = translate_blend(st->ctx->Color.BlendEquationA);
       if (st->ctx->Color.BlendEquationA == GL_MIN ||
           st->ctx->Color.BlendEquationA == GL_MAX) {
          /* Min/max are special */
-         blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-         blend.alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
+         blend->alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+         blend->alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
       }
       else {
-         blend.alpha_src_factor = translate_blend(st->ctx->Color.BlendSrcA);
-         blend.alpha_dst_factor = translate_blend(st->ctx->Color.BlendDstA);
+         blend->alpha_src_factor = translate_blend(st->ctx->Color.BlendSrcA);
+         blend->alpha_dst_factor = translate_blend(st->ctx->Color.BlendDstA);
       }
    }
    else {
@@ -201,25 +200,18 @@ update_blend( struct st_context *st )
 
    /* Colormask - maybe reverse these bits? */
    if (st->ctx->Color.ColorMask[0])
-      blend.colormask |= PIPE_MASK_R;
+      blend->colormask |= PIPE_MASK_R;
    if (st->ctx->Color.ColorMask[1])
-      blend.colormask |= PIPE_MASK_G;
+      blend->colormask |= PIPE_MASK_G;
    if (st->ctx->Color.ColorMask[2])
-      blend.colormask |= PIPE_MASK_B;
+      blend->colormask |= PIPE_MASK_B;
    if (st->ctx->Color.ColorMask[3])
-      blend.colormask |= PIPE_MASK_A;
+      blend->colormask |= PIPE_MASK_A;
 
    if (st->ctx->Color.DitherFlag)
-      blend.dither = 1;
+      blend->dither = 1;
 
-   cso = st_cached_blend_state(st, &blend);
-
-   if (st->state.blend != cso) {
-      /* state has changed */
-      st->state.blend = cso;
-      /* bind new state */
-      st->pipe->bind_blend_state(st->pipe, cso->data);
-   }
+   cso_set_blend(st->cso_context, blend);
 
    if (memcmp(st->ctx->Color.BlendColor, &st->state.blend_color, 4 * sizeof(GLfloat)) != 0) {
       /* state has changed */
diff --git a/src/mesa/state_tracker/st_atom_depth.c b/src/mesa/state_tracker/st_atom_depth.c
index 7aecdbfbcc0..827ad3b548b 100644
--- a/src/mesa/state_tracker/st_atom_depth.c
+++ b/src/mesa/state_tracker/st_atom_depth.c
@@ -34,10 +34,10 @@
  
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_atom.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "cso_cache/cso_context.h"
 
 
 /**
@@ -93,53 +93,47 @@ gl_stencil_op_to_pipe(GLenum func)
 static void
 update_depth_stencil_alpha(struct st_context *st)
 {
-   struct pipe_depth_stencil_alpha_state depth_stencil;
-   const struct cso_depth_stencil_alpha *cso;
+   struct pipe_depth_stencil_alpha_state *dsa = &st->state.depth_stencil;
 
-   memset(&depth_stencil, 0, sizeof(depth_stencil));
+   memset(dsa, 0, sizeof(*dsa));
 
-   depth_stencil.depth.enabled = st->ctx->Depth.Test;
-   depth_stencil.depth.writemask = st->ctx->Depth.Mask;
-   depth_stencil.depth.func = st_compare_func_to_pipe(st->ctx->Depth.Func);
+   dsa->depth.enabled = st->ctx->Depth.Test;
+   dsa->depth.writemask = st->ctx->Depth.Mask;
+   dsa->depth.func = st_compare_func_to_pipe(st->ctx->Depth.Func);
 
    if (st->ctx->Query.CurrentOcclusionObject &&
        st->ctx->Query.CurrentOcclusionObject->Active)
-      depth_stencil.depth.occlusion_count = 1;
+      dsa->depth.occlusion_count = 1;
 
    if (st->ctx->Stencil.Enabled) {
-      depth_stencil.stencil[0].enabled = 1;
-      depth_stencil.stencil[0].func = st_compare_func_to_pipe(st->ctx->Stencil.Function[0]);
-      depth_stencil.stencil[0].fail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.FailFunc[0]);
-      depth_stencil.stencil[0].zfail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZFailFunc[0]);
-      depth_stencil.stencil[0].zpass_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZPassFunc[0]);
-      depth_stencil.stencil[0].ref_value = st->ctx->Stencil.Ref[0] & 0xff;
-      depth_stencil.stencil[0].value_mask = st->ctx->Stencil.ValueMask[0] & 0xff;
-      depth_stencil.stencil[0].write_mask = st->ctx->Stencil.WriteMask[0] & 0xff;
+      dsa->stencil[0].enabled = 1;
+      dsa->stencil[0].func = st_compare_func_to_pipe(st->ctx->Stencil.Function[0]);
+      dsa->stencil[0].fail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.FailFunc[0]);
+      dsa->stencil[0].zfail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZFailFunc[0]);
+      dsa->stencil[0].zpass_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZPassFunc[0]);
+      dsa->stencil[0].ref_value = st->ctx->Stencil.Ref[0] & 0xff;
+      dsa->stencil[0].value_mask = st->ctx->Stencil.ValueMask[0] & 0xff;
+      dsa->stencil[0].write_mask = st->ctx->Stencil.WriteMask[0] & 0xff;
 
       if (st->ctx->Stencil.TestTwoSide) {
-         depth_stencil.stencil[1].enabled = 1;
-         depth_stencil.stencil[1].func = st_compare_func_to_pipe(st->ctx->Stencil.Function[1]);
-         depth_stencil.stencil[1].fail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.FailFunc[1]);
-         depth_stencil.stencil[1].zfail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZFailFunc[1]);
-         depth_stencil.stencil[1].zpass_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZPassFunc[1]);
-         depth_stencil.stencil[1].ref_value = st->ctx->Stencil.Ref[1] & 0xff;
-         depth_stencil.stencil[1].value_mask = st->ctx->Stencil.ValueMask[1] & 0xff;
-         depth_stencil.stencil[1].write_mask = st->ctx->Stencil.WriteMask[1] & 0xff;
+         dsa->stencil[1].enabled = 1;
+         dsa->stencil[1].func = st_compare_func_to_pipe(st->ctx->Stencil.Function[1]);
+         dsa->stencil[1].fail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.FailFunc[1]);
+         dsa->stencil[1].zfail_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZFailFunc[1]);
+         dsa->stencil[1].zpass_op = gl_stencil_op_to_pipe(st->ctx->Stencil.ZPassFunc[1]);
+         dsa->stencil[1].ref_value = st->ctx->Stencil.Ref[1] & 0xff;
+         dsa->stencil[1].value_mask = st->ctx->Stencil.ValueMask[1] & 0xff;
+         dsa->stencil[1].write_mask = st->ctx->Stencil.WriteMask[1] & 0xff;
       }
    }
 
    if (st->ctx->Color.AlphaEnabled) {
-      depth_stencil.alpha.enabled = 1;
-      depth_stencil.alpha.func = st_compare_func_to_pipe(st->ctx->Color.AlphaFunc);
-      depth_stencil.alpha.ref = st->ctx->Color.AlphaRef;
+      dsa->alpha.enabled = 1;
+      dsa->alpha.func = st_compare_func_to_pipe(st->ctx->Color.AlphaFunc);
+      dsa->alpha.ref = st->ctx->Color.AlphaRef;
    }
 
-   cso = st_cached_depth_stencil_alpha_state(st, &depth_stencil);
-   if (st->state.depth_stencil != cso) {
-      /* state has changed */
-      st->state.depth_stencil = cso;
-      st->pipe->bind_depth_stencil_alpha_state(st->pipe, cso->data); /* bind new state */
-   }
+   cso_set_depth_stencil_alpha(st->cso_context, dsa);
 }
 
 
diff --git a/src/mesa/state_tracker/st_atom_rasterizer.c b/src/mesa/state_tracker/st_atom_rasterizer.c
index 229839d8b2c..77cef9236bb 100644
--- a/src/mesa/state_tracker/st_atom_rasterizer.c
+++ b/src/mesa/state_tracker/st_atom_rasterizer.c
@@ -32,10 +32,11 @@
  
 #include "main/macros.h"
 #include "st_context.h"
-#include "st_cache.h"
+#include "st_atom.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
-#include "st_atom.h"
+#include "cso_cache/cso_context.h"
+
 
 static GLuint translate_fill( GLenum mode )
 {
@@ -72,22 +73,21 @@ static GLboolean get_offset_flag( GLuint fill_mode,
 static void update_raster_state( struct st_context *st )
 {
    GLcontext *ctx = st->ctx;
-   struct pipe_rasterizer_state raster;
-   const struct cso_rasterizer *cso;
+   struct pipe_rasterizer_state *raster = &st->state.rasterizer;
    const struct gl_vertex_program *vertProg = ctx->VertexProgram._Current;
    uint i;
 
-   memset(&raster, 0, sizeof(raster));
+   memset(raster, 0, sizeof(*raster));
 
-   raster.origin_lower_left = 1; /* Always true for OpenGL */
+   raster->origin_lower_left = 1; /* Always true for OpenGL */
    
    /* _NEW_POLYGON, _NEW_BUFFERS
     */
    {
       if (ctx->Polygon.FrontFace == GL_CCW)
-         raster.front_winding = PIPE_WINDING_CCW;
+         raster->front_winding = PIPE_WINDING_CCW;
       else
-         raster.front_winding = PIPE_WINDING_CW;
+         raster->front_winding = PIPE_WINDING_CW;
 
       /* XXX
        * I think the intention here is that user-created framebuffer objects
@@ -96,13 +96,13 @@ static void update_raster_state( struct st_context *st )
        * But this is an implementation/driver-specific artifact - remove...
        */
       if (ctx->DrawBuffer && ctx->DrawBuffer->Name != 0)
-         raster.front_winding ^= PIPE_WINDING_BOTH;
+         raster->front_winding ^= PIPE_WINDING_BOTH;
    }
 
    /* _NEW_LIGHT
     */
    if (ctx->Light.ShadeModel == GL_FLAT)
-      raster.flatshade = 1;
+      raster->flatshade = 1;
 
    /* _NEW_LIGHT | _NEW_PROGRAM
     *
@@ -113,28 +113,28 @@ static void update_raster_state( struct st_context *st )
    if (ctx->VertexProgram._Current) {
       if (ctx->VertexProgram._Enabled) {
          /* user-defined program */
-         raster.light_twoside = ctx->VertexProgram.TwoSideEnabled;
+         raster->light_twoside = ctx->VertexProgram.TwoSideEnabled;
       }
       else {
          /* TNL-generated program */
-         raster.light_twoside = ctx->Light.Enabled && ctx->Light.Model.TwoSide;
+         raster->light_twoside = ctx->Light.Enabled && ctx->Light.Model.TwoSide;
       }
    }
    else if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) {
-      raster.light_twoside = 1;
+      raster->light_twoside = 1;
    }
 
    /* _NEW_POLYGON
     */
    if (ctx->Polygon.CullFlag) {
       if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) {
-	 raster.cull_mode = PIPE_WINDING_BOTH;
+	 raster->cull_mode = PIPE_WINDING_BOTH;
       }
       else if (ctx->Polygon.CullFaceMode == GL_FRONT) {
-	 raster.cull_mode = raster.front_winding;
+	 raster->cull_mode = raster->front_winding;
       }
       else {
-	 raster.cull_mode = raster.front_winding ^ PIPE_WINDING_BOTH;
+	 raster->cull_mode = raster->front_winding ^ PIPE_WINDING_BOTH;
       }
    }
 
@@ -144,23 +144,23 @@ static void update_raster_state( struct st_context *st )
       GLuint fill_front = translate_fill( ctx->Polygon.FrontMode );
       GLuint fill_back = translate_fill( ctx->Polygon.BackMode );
       
-      if (raster.front_winding == PIPE_WINDING_CW) {
-	 raster.fill_cw = fill_front;
-	 raster.fill_ccw = fill_back;
+      if (raster->front_winding == PIPE_WINDING_CW) {
+	 raster->fill_cw = fill_front;
+	 raster->fill_ccw = fill_back;
       }
       else {
-	 raster.fill_cw = fill_back;
-	 raster.fill_ccw = fill_front;
+	 raster->fill_cw = fill_back;
+	 raster->fill_ccw = fill_front;
       }
 
       /* Simplify when culling is active:
        */
-      if (raster.cull_mode & PIPE_WINDING_CW) {
-	 raster.fill_cw = raster.fill_ccw;
+      if (raster->cull_mode & PIPE_WINDING_CW) {
+	 raster->fill_cw = raster->fill_ccw;
       }
       
-      if (raster.cull_mode & PIPE_WINDING_CCW) {
-	 raster.fill_ccw = raster.fill_cw;
+      if (raster->cull_mode & PIPE_WINDING_CCW) {
+	 raster->fill_ccw = raster->fill_cw;
       }
    }
 
@@ -168,95 +168,91 @@ static void update_raster_state( struct st_context *st )
     */
    if (ctx->Polygon.OffsetUnits != 0.0 ||
        ctx->Polygon.OffsetFactor != 0.0) {
-      raster.offset_cw = get_offset_flag( raster.fill_cw, &ctx->Polygon );
-      raster.offset_ccw = get_offset_flag( raster.fill_ccw, &ctx->Polygon );
-      raster.offset_units = ctx->Polygon.OffsetUnits;
-      raster.offset_scale = ctx->Polygon.OffsetFactor;
+      raster->offset_cw = get_offset_flag( raster->fill_cw, &ctx->Polygon );
+      raster->offset_ccw = get_offset_flag( raster->fill_ccw, &ctx->Polygon );
+      raster->offset_units = ctx->Polygon.OffsetUnits;
+      raster->offset_scale = ctx->Polygon.OffsetFactor;
    }
 
    if (ctx->Polygon.SmoothFlag)
-      raster.poly_smooth = 1;
+      raster->poly_smooth = 1;
 
    if (ctx->Polygon.StippleFlag)
-      raster.poly_stipple_enable = 1;
+      raster->poly_stipple_enable = 1;
 
 
    /* _NEW_BUFFERS, _NEW_POLYGON
     */
-   if (raster.fill_cw != PIPE_POLYGON_MODE_FILL ||
-       raster.fill_ccw != PIPE_POLYGON_MODE_FILL)
+   if (raster->fill_cw != PIPE_POLYGON_MODE_FILL ||
+       raster->fill_ccw != PIPE_POLYGON_MODE_FILL)
    {
       GLfloat mrd = (ctx->DrawBuffer ? 
 		     ctx->DrawBuffer->_MRD : 
 		     1.0);
 
-      raster.offset_units = ctx->Polygon.OffsetFactor * mrd;
-      raster.offset_scale = (ctx->Polygon.OffsetUnits * mrd *
+      raster->offset_units = ctx->Polygon.OffsetFactor * mrd;
+      raster->offset_scale = (ctx->Polygon.OffsetUnits * mrd *
 			    st->polygon_offset_scale);
    }
       
    /* _NEW_POINT
     */
-   raster.point_size = ctx->Point.Size;
-   raster.point_smooth = ctx->Point.SmoothFlag;
-   raster.point_sprite = ctx->Point.PointSprite;
+   raster->point_size = ctx->Point.Size;
+   raster->point_smooth = ctx->Point.SmoothFlag;
+   raster->point_sprite = ctx->Point.PointSprite;
    for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
       if (ctx->Point.CoordReplace[i]) {
          if (ctx->Point.SpriteOrigin == GL_UPPER_LEFT)
-            raster.sprite_coord_mode[i] = PIPE_SPRITE_COORD_UPPER_LEFT;
+            raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_UPPER_LEFT;
          else 
-            raster.sprite_coord_mode[i] = PIPE_SPRITE_COORD_LOWER_LEFT;
+            raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_LOWER_LEFT;
       }
       else {
-         raster.sprite_coord_mode[i] = PIPE_SPRITE_COORD_NONE;
+         raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_NONE;
       }
    }
    if (vertProg) {
       if (vertProg->Base.Id == 0) {
          if (vertProg->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ)) {
             /* generated program which emits point size */
-            raster.point_size_per_vertex = TRUE;
+            raster->point_size_per_vertex = TRUE;
          }
       }
       else if (ctx->VertexProgram.PointSizeEnabled) {
          /* user-defined program and GL_VERTEX_PROGRAM_POINT_SIZE set */
-         raster.point_size_per_vertex = ctx->VertexProgram.PointSizeEnabled;
+         raster->point_size_per_vertex = ctx->VertexProgram.PointSizeEnabled;
       }
    }
 
 
    /* _NEW_LINE
     */
-   raster.line_smooth = ctx->Line.SmoothFlag;
+   raster->line_smooth = ctx->Line.SmoothFlag;
    if (ctx->Line.SmoothFlag) {
-      raster.line_width = CLAMP(ctx->Line.Width,
+      raster->line_width = CLAMP(ctx->Line.Width,
                                 ctx->Const.MinLineWidthAA,
                                 ctx->Const.MaxLineWidthAA);
    }
    else {
-      raster.line_width = CLAMP(ctx->Line.Width,
+      raster->line_width = CLAMP(ctx->Line.Width,
                                 ctx->Const.MinLineWidth,
                                 ctx->Const.MaxLineWidth);
    }
 
-   raster.line_stipple_enable = ctx->Line.StippleFlag;
-   raster.line_stipple_pattern = ctx->Line.StipplePattern;
+   raster->line_stipple_enable = ctx->Line.StippleFlag;
+   raster->line_stipple_pattern = ctx->Line.StipplePattern;
    /* GL stipple factor is in [1,256], remap to [0, 255] here */
-   raster.line_stipple_factor = ctx->Line.StippleFactor - 1;
+   raster->line_stipple_factor = ctx->Line.StippleFactor - 1;
 
    /* _NEW_MULTISAMPLE */
    if (ctx->Multisample.Enabled)
-      raster.multisample = 1;
+      raster->multisample = 1;
 
    /* _NEW_SCISSOR */
    if (ctx->Scissor.Enabled)
-      raster.scissor = 1;
+      raster->scissor = 1;
 
-   cso = st_cached_rasterizer_state(st, &raster);
-   if (st->state.rasterizer != cso) {
-      st->state.rasterizer = cso;
-      st->pipe->bind_rasterizer_state(st->pipe, cso->data);
-   }
+   cso_set_rasterizer(st->cso_context, raster);
 }
 
 const struct st_tracked_state st_update_rasterizer = {
diff --git a/src/mesa/state_tracker/st_atom_sampler.c b/src/mesa/state_tracker/st_atom_sampler.c
index 1000f98ffc0..1babba9b4fa 100644
--- a/src/mesa/state_tracker/st_atom_sampler.c
+++ b/src/mesa/state_tracker/st_atom_sampler.c
@@ -33,11 +33,11 @@
  
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_atom.h"
 #include "st_program.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "cso_cache/cso_context.h"
 
 
 /**
@@ -124,9 +124,9 @@ update_samplers(struct st_context *st)
 
    /* loop over sampler units (aka tex image units) */
    for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) {
-      struct pipe_sampler_state sampler;
+      struct pipe_sampler_state *sampler = st->state.samplers + su;
 
-      memset(&sampler, 0, sizeof(sampler));
+      memset(sampler, 0, sizeof(*sampler));
 
       if (fs->Base.Base.SamplersUsed & (1 << su)) {
          GLuint texUnit = fs->Base.Base.SamplerUnits[su];
@@ -135,37 +135,37 @@ update_samplers(struct st_context *st)
 
          assert(texobj);
 
-         sampler.wrap_s = gl_wrap_to_sp(texobj->WrapS);
-         sampler.wrap_t = gl_wrap_to_sp(texobj->WrapT);
-         sampler.wrap_r = gl_wrap_to_sp(texobj->WrapR);
+         sampler->wrap_s = gl_wrap_to_sp(texobj->WrapS);
+         sampler->wrap_t = gl_wrap_to_sp(texobj->WrapT);
+         sampler->wrap_r = gl_wrap_to_sp(texobj->WrapR);
 
-         sampler.min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
-         sampler.min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
-         sampler.mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
+         sampler->min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
+         sampler->min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
+         sampler->mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
 
          if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB)
-            sampler.normalized_coords = 1;
+            sampler->normalized_coords = 1;
 
-         sampler.lod_bias = st->ctx->Texture.Unit[su].LodBias;
+         sampler->lod_bias = st->ctx->Texture.Unit[su].LodBias;
 #if 1
-         sampler.min_lod = (texobj->MinLod) < 0.0 ? 0.0 : texobj->MinLod;
-         sampler.max_lod = texobj->MaxLod;
+         sampler->min_lod = (texobj->MinLod) < 0.0 ? 0.0 : texobj->MinLod;
+         sampler->max_lod = texobj->MaxLod;
 #else
          /* min/max lod should really be as follows (untested).
           * Also, calculate_first_last_level() needs to be overhauled
           * since today's hardware had real support for LOD clamping.
           */
-         sampler.min_lod = MAX2(texobj->BaseLevel, texobj->MinLod);
-         sampler.max_lod = MIN2(texobj->MaxLevel, texobj->MaxLod);
+         sampler->min_lod = MAX2(texobj->BaseLevel, texobj->MinLod);
+         sampler->max_lod = MIN2(texobj->MaxLevel, texobj->MaxLod);
 #endif
 
-	 sampler.max_anisotropy = texobj->MaxAnisotropy;
+	 sampler->max_anisotropy = texobj->MaxAnisotropy;
 
          /* only care about ARB_shadow, not SGI shadow */
          if (texobj->CompareMode == GL_COMPARE_R_TO_TEXTURE) {
-            sampler.compare = 1;
-            sampler.compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
-            sampler.compare_func
+            sampler->compare = 1;
+            sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
+            sampler->compare_func
                = st_compare_func_to_pipe(texobj->CompareFunc);
          }
 
@@ -174,11 +174,10 @@ update_samplers(struct st_context *st)
          /* XXX more sampler state here */
       }
 
-      st->state.sampler[su] = st_cached_sampler_state(st, &sampler)->data;
+      cso_single_sampler(st->cso_context, su, sampler);
    }
 
-   st->pipe->bind_sampler_states(st->pipe, st->state.num_samplers,
-                                 st->state.sampler);
+   cso_single_sampler_done(st->cso_context);
 }
 
 
diff --git a/src/mesa/state_tracker/st_atom_shader.c b/src/mesa/state_tracker/st_atom_shader.c
index 10c131d5549..07266884930 100644
--- a/src/mesa/state_tracker/st_atom_shader.c
+++ b/src/mesa/state_tracker/st_atom_shader.c
@@ -43,10 +43,9 @@
 #include "pipe/p_context.h"
 #include "pipe/p_shader_tokens.h"
 
-#include "cso_cache/cso_cache.h"
+#include "cso_cache/cso_context.h"
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_atom.h"
 #include "st_program.h"
 #include "st_atom_shader.h"
@@ -70,9 +69,6 @@ struct translated_vertex_program
    /** Maps VERT_RESULT_x to slot */
    GLuint output_to_slot[VERT_RESULT_MAX];
 
-   /** The program in TGSI format */
-   struct tgsi_token tokens[ST_MAX_SHADER_TOKENS];
-
    /** Pointer to the translated vertex program */
    struct st_vertex_program *vp;
 
@@ -158,7 +154,7 @@ find_translated_vp(struct st_context *st,
    /*
     * Translate fragment program if needed.
     */
-   if (!stfp->cso) {
+   if (!stfp->state.tokens) {
       GLuint inAttr, numIn = 0;
 
       for (inAttr = 0; inAttr < FRAG_ATTRIB_MAX; inAttr++) {
@@ -175,11 +171,7 @@ find_translated_vp(struct st_context *st,
 
       assert(stfp->Base.Base.NumInstructions > 1);
 
-      (void) st_translate_fragment_program(st, stfp,
-                                           stfp->input_to_slot,
-                                           stfp->tokens,
-                                           ST_MAX_SHADER_TOKENS);
-      assert(stfp->cso);
+      st_translate_fragment_program(st, stfp, stfp->input_to_slot);
    }
 
 
@@ -261,12 +253,8 @@ find_translated_vp(struct st_context *st,
 
       assert(stvp->Base.Base.NumInstructions > 1);
 
-      st_translate_vertex_program(st, stvp,
-                                  xvp->output_to_slot,
-                                  xvp->tokens,
-                                  ST_MAX_SHADER_TOKENS);
+      st_translate_vertex_program(st, stvp, xvp->output_to_slot);
 
-      assert(stvp->cso);
       xvp->vp = stvp;
 
       /* translated VP is up to date now */
@@ -296,12 +284,10 @@ update_linkage( struct st_context *st )
    xvp = find_translated_vp(st, stvp, stfp);
 
    st->vp = stvp;
-   st->state.vs = xvp->vp;
-   st->pipe->bind_vs_state(st->pipe, st->state.vs->cso->data);
-
    st->fp = stfp;
-   st->state.fs = stfp->cso;
-   st->pipe->bind_fs_state(st->pipe, st->state.fs->data);
+
+   st->pipe->bind_vs_state(st->pipe, stvp->driver_shader);
+   st->pipe->bind_fs_state(st->pipe, stfp->driver_shader);
 
    st->vertex_result_to_slot = xvp->output_to_slot;
 }
diff --git a/src/mesa/state_tracker/st_cb_accum.c b/src/mesa/state_tracker/st_cb_accum.c
index 663c4f205d8..f1fddc4e026 100644
--- a/src/mesa/state_tracker/st_cb_accum.c
+++ b/src/mesa/state_tracker/st_cb_accum.c
@@ -35,7 +35,6 @@
 #include "main/macros.h"
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_cb_accum.h"
 #include "st_cb_fbo.h"
 #include "st_draw.h"
diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index e712fd84cd5..eae40f2a4f1 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -35,7 +35,6 @@
 #include "main/macros.h"
 #include "shader/prog_instruction.h"
 #include "st_atom.h"
-#include "st_cache.h"
 #include "st_context.h"
 #include "st_cb_accum.h"
 #include "st_cb_clear.h"
@@ -50,6 +49,8 @@
 #include "pipe/p_defines.h"
 #include "pipe/p_winsys.h"
 
+#include "cso_cache/cso_context.h"
+
 
 
 
@@ -157,8 +158,7 @@ make_frag_shader(struct st_context *st)
    p->OutputsWritten = (1 << FRAG_RESULT_COLR);
 
    stfp = (struct st_fragment_program *) p;
-   st_translate_fragment_program(st, stfp, NULL,
-                                 stfp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_fragment_program(st, stfp, NULL);
 
    return stfp;
 }
@@ -206,9 +206,10 @@ make_vertex_shader(struct st_context *st)
                         (1 << VERT_RESULT_HPOS));
 
    stvp = (struct st_vertex_program *) p;
-   st_translate_vertex_program(st, stvp, NULL,
-                               stvp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_vertex_program(st, stvp, NULL);
+#if 0
    assert(stvp->cso);
+#endif
 
    return stvp;
 }
@@ -284,7 +285,6 @@ clear_with_quad(GLcontext *ctx,
    /* blend state: RGBA masking */
    {
       struct pipe_blend_state blend;
-      const struct cso_blend *cso;
       memset(&blend, 0, sizeof(blend));
       if (color) {
          if (ctx->Color.ColorMask[0])
@@ -298,14 +298,12 @@ clear_with_quad(GLcontext *ctx,
          if (st->ctx->Color.DitherFlag)
             blend.dither = 1;
       }
-      cso = st_cached_blend_state(st, &blend);
-      pipe->bind_blend_state(pipe, cso->data);
+      cso_set_blend(st->cso_context, &blend);
    }
 
    /* depth_stencil state: always pass/set to ref value */
    {
       struct pipe_depth_stencil_alpha_state depth_stencil;
-      const struct cso_depth_stencil_alpha *cso;
       memset(&depth_stencil, 0, sizeof(depth_stencil));
       if (depth) {
          depth_stencil.depth.enabled = 1;
@@ -323,14 +321,13 @@ clear_with_quad(GLcontext *ctx,
          depth_stencil.stencil[0].value_mask = 0xff;
          depth_stencil.stencil[0].write_mask = ctx->Stencil.WriteMask[0] & 0xff;
       }
-      cso = st_cached_depth_stencil_alpha_state(st, &depth_stencil);
-      pipe->bind_depth_stencil_alpha_state(pipe, cso->data);
+
+      cso_set_depth_stencil_alpha(st->cso_context, &depth_stencil);
    }
 
    /* rasterizer state: nothing */
    {
       struct pipe_rasterizer_state raster;
-      const struct cso_rasterizer *cso;
       memset(&raster, 0, sizeof(raster));
 #if 0
       /* don't do per-pixel scissor; we'll just draw a PIPE_PRIM_QUAD
@@ -339,8 +336,7 @@ clear_with_quad(GLcontext *ctx,
       if (ctx->Scissor.Enabled)
          raster.scissor = 1;
 #endif
-      cso = st_cached_rasterizer_state(st, &raster);
-      pipe->bind_rasterizer_state(pipe, cso->data);
+      cso_set_rasterizer(st->cso_context, &raster);
    }
 
    /* fragment shader state: color pass-through program */
@@ -349,7 +345,7 @@ clear_with_quad(GLcontext *ctx,
       if (!stfp) {
          stfp = make_frag_shader(st);
       }
-      pipe->bind_fs_state(pipe, stfp->cso->data);
+      pipe->bind_fs_state(pipe, stfp->driver_shader);
    }
 
    /* vertex shader state: color/position pass-through */
@@ -358,7 +354,7 @@ clear_with_quad(GLcontext *ctx,
       if (!stvp) {
          stvp = make_vertex_shader(st);
       }
-      pipe->bind_vs_state(pipe, stvp->cso->data);
+      pipe->bind_vs_state(pipe, stvp->driver_shader);
    }
 
    /* viewport state: viewport matching window dims */
@@ -380,16 +376,19 @@ clear_with_quad(GLcontext *ctx,
    /* draw quad matching scissor rect (XXX verify coord round-off) */
    draw_quad(ctx, x0, y0, x1, y1, ctx->Depth.Clear, ctx->Color.ClearColor);
 
+#if 0
+   /* Can't depend on old state objects still existing -- may have
+    * been deleted to make room in the hash, etc.  (Should get
+    * fixed...)
+    */
+   st_invalidate_state(ctx, _NEW_COLOR | _NEW_DEPTH | _NEW_STENCIL);
+#else
    /* Restore pipe state */
-   pipe->bind_blend_state(pipe, st->state.blend->data);
-   pipe->bind_depth_stencil_alpha_state(pipe, st->state.depth_stencil->data);
-   pipe->bind_fs_state(pipe, st->state.fs->data);
-   pipe->bind_vs_state(pipe, st->state.vs->cso->data);
-   pipe->bind_rasterizer_state(pipe, st->state.rasterizer->data);
+   cso_set_rasterizer(st->cso_context, &st->state.rasterizer);
+   pipe->bind_fs_state(pipe, st->fp->driver_shader);
+   pipe->bind_vs_state(pipe, st->vp->driver_shader);
+#endif
    pipe->set_viewport_state(pipe, &st->state.viewport);
-   /* OR:
-   st_invalidate_state(ctx, _NEW_COLOR | _NEW_DEPTH | _NEW_STENCIL);
-   */
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index dee4c4132a4..18ec9645c44 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -41,7 +41,6 @@
 #include "st_context.h"
 #include "st_atom.h"
 #include "st_atom_constbuf.h"
-#include "st_cache.h"
 #include "st_draw.h"
 #include "st_program.h"
 #include "st_cb_drawpixels.h"
@@ -58,6 +57,7 @@
 #include "pipe/p_winsys.h"
 #include "util/p_tile.h"
 #include "shader/prog_instruction.h"
+#include "cso_cache/cso_context.h"
 
 
 /**
@@ -159,8 +159,7 @@ make_bitmap_fragment_program(GLcontext *ctx)
 
    stfp = (struct st_fragment_program *) p;
    stfp->Base.UsesKill = GL_TRUE;
-   st_translate_fragment_program(ctx->st, stfp, NULL,
-                                 stfp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_fragment_program(ctx->st, stfp, NULL);
 
    return stfp;
 }
@@ -204,8 +203,7 @@ combined_bitmap_fragment_program(GLcontext *ctx)
 #endif
 
       /* translate to TGSI tokens */
-      st_translate_fragment_program(st, stfp, NULL,
-                                    stfp->tokens, ST_MAX_SHADER_TOKENS);
+      st_translate_fragment_program(st, stfp, NULL);
 
       /* save new program, update serial numbers */
       st->bitmap.user_prog_sn = st->fp->serialNo;
@@ -266,8 +264,7 @@ combined_drawpix_fragment_program(GLcontext *ctx)
 #endif
 
       /* translate to TGSI tokens */
-      st_translate_fragment_program(st, stfp, NULL,
-                                    stfp->tokens, ST_MAX_SHADER_TOKENS);
+      st_translate_fragment_program(st, stfp, NULL);
 
       /* save new program, update serial numbers */
       st->pixel_xfer.xfer_prog_sn = st->pixel_xfer.program->serialNo;
@@ -343,8 +340,7 @@ make_fragment_shader_z(struct st_context *st)
    p->OutputsWritten = (1 << FRAG_RESULT_COLR) | (1 << FRAG_RESULT_DEPR);
 
    stfp = (struct st_fragment_program *) p;
-   st_translate_fragment_program(st, stfp, NULL,
-                                 stfp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_fragment_program(st, stfp, NULL);
 
    return stfp;
 }
@@ -421,8 +417,7 @@ st_make_passthrough_vertex_shader(struct st_context *st, GLboolean passColor)
    }
 
    stvp = (struct st_vertex_program *) p;
-   st_translate_vertex_program(st, stvp, NULL,
-                               stvp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_vertex_program(st, stvp, NULL);
 
    progs[passColor] = stvp;
 
@@ -641,7 +636,9 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
                    const GLfloat *color,
                    GLboolean invertTex)
 {
+   struct st_context *st = ctx->st;
    struct pipe_context *pipe = ctx->st->pipe;
+   struct cso_context *cso = ctx->st->cso_context;
    GLfloat x0, y0, x1, y1;
    GLuint maxSize;
 
@@ -656,24 +653,23 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
    /* setup state: just scissor */
    {
       struct pipe_rasterizer_state  setup;
-      const struct cso_rasterizer  *cso;
       memset(&setup, 0, sizeof(setup));
       if (ctx->Scissor.Enabled)
          setup.scissor = 1;
-      cso = st_cached_rasterizer_state(ctx->st, &setup);
-      pipe->bind_rasterizer_state(pipe, cso->data);
+
+      cso_set_rasterizer(cso, &setup);
    }
 
    /* fragment shader state: TEX lookup program */
-   pipe->bind_fs_state(pipe, stfp->cso->data);
+   pipe->bind_fs_state(pipe, stfp->driver_shader);
 
    /* vertex shader state: position + texcoord pass-through */
-   pipe->bind_vs_state(pipe, stvp->cso->data);
+   pipe->bind_vs_state(pipe, stvp->driver_shader);
+
 
    /* texture sampling state: */
    {
       struct pipe_sampler_state sampler;
-      const struct cso_sampler *cso;
       memset(&sampler, 0, sizeof(sampler));
       sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
       sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
@@ -682,8 +678,9 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
       sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
       sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
       sampler.normalized_coords = 1;
-      cso = st_cached_sampler_state(ctx->st, &sampler);
-      pipe->bind_sampler_states(pipe, 1, (void**)&cso->data);
+
+      cso_single_sampler(cso, 0, &sampler);
+      cso_single_sampler_done(cso);
    }
 
    /* viewport state: viewport matching window dims */
@@ -723,14 +720,25 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
       draw_quad(ctx, x0, y0, z, x1, y1, invertTex);
 
    /* restore GL state */
-   pipe->bind_rasterizer_state(pipe, ctx->st->state.rasterizer->data);
-   pipe->bind_fs_state(pipe, ctx->st->state.fs->data);
-   pipe->bind_vs_state(pipe, ctx->st->state.vs->cso->data);
    pipe->set_sampler_textures(pipe, ctx->st->state.num_textures,
                               ctx->st->state.sampler_texture);
-   pipe->bind_sampler_states(pipe, ctx->st->state.num_samplers,
-                             ctx->st->state.sampler);
+
    pipe->set_viewport_state(pipe, &ctx->st->state.viewport);
+
+#if 0
+   /* Can't depend on old state objects still existing -- may have
+    * been deleted to make room in the hash, etc.  (Should get
+    * fixed...)
+    */
+   st_invalidate_state(ctx, _NEW_COLOR | _NEW_TEXTURE);
+#else
+   /* restore state */
+   pipe->bind_fs_state(pipe, st->fp->driver_shader);
+   pipe->bind_vs_state(pipe, st->vp->driver_shader);
+   cso_set_rasterizer(cso, &st->state.rasterizer);
+   cso_set_samplers(cso, PIPE_MAX_SAMPLERS,
+                 (const struct pipe_sampler_state **) st->state.sampler_list);
+#endif
 }
 
 
@@ -798,10 +806,10 @@ compatible_formats(GLenum format, GLenum type, enum pipe_format pipeFormat)
 static GLboolean
 any_fragment_ops(const struct st_context *st)
 {
-   if (st->state.depth_stencil->state.alpha.enabled ||
-       st->state.blend->state.blend_enable ||
-       st->state.blend->state.logicop_enable ||
-       st->state.depth_stencil->state.depth.enabled)
+   if (st->state.depth_stencil.alpha.enabled ||
+       st->state.depth_stencil.depth.enabled ||
+       st->state.blend.blend_enable ||
+       st->state.blend.logicop_enable)
       /* XXX more checks */
       return GL_TRUE;
    else
diff --git a/src/mesa/state_tracker/st_cb_program.c b/src/mesa/state_tracker/st_cb_program.c
index 61d4f4c41c6..4dc76f19b10 100644
--- a/src/mesa/state_tracker/st_cb_program.c
+++ b/src/mesa/state_tracker/st_cb_program.c
@@ -168,11 +168,13 @@ static void st_program_string_notify( GLcontext *ctx,
 
       stfp->serialNo++;
 
+#if 0
       if (stfp->cso) {
          /* free the TGSI code */
          // cso_delete(stfp->vs);
          stfp->cso = NULL;
       }
+#endif
 
       stfp->param_state = stfp->Base.Base.Parameters->StateFlags;
 
@@ -184,13 +186,14 @@ static void st_program_string_notify( GLcontext *ctx,
 
       stvp->serialNo++;
 
+#if 0
       if (stvp->cso) {
          /* free the CSO data */
          st->pipe->delete_vs_state(st->pipe, stvp->cso->data);
          FREE((void *) stvp->cso);
          stvp->cso = NULL;
       }
-
+#endif
       if (stvp->draw_shader) {
          draw_delete_vertex_shader(st->draw, stvp->draw_shader);
          stvp->draw_shader = NULL;
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index 09e389f9dc7..5458ab420e4 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -56,6 +56,7 @@
 #include "pipe/p_inlines.h"
 #include "draw/draw_context.h"
 #include "cso_cache/cso_cache.h"
+#include "cso_cache/cso_context.h"
 
 
 /**
@@ -78,6 +79,7 @@ void st_invalidate_state(GLcontext * ctx, GLuint new_state)
 static struct st_context *
 st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
 {
+   uint i;
    struct st_context *st = CALLOC_STRUCT( st_context );
    
    ctx->st = st;
@@ -93,12 +95,15 @@ st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
    st->dirty.mesa = ~0;
    st->dirty.st = ~0;
 
-   st->cache = cso_cache_create();
+   st->cso_context = cso_create_context(pipe);
 
    st_init_atoms( st );
    st_init_draw( st );
    st_init_generate_mipmap(st);
 
+   for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
+      st->state.sampler_list[i] = &st->state.samplers[i];
+
    /* we want all vertex data to be placed in buffer objects */
    vbo_use_buffer_objects(ctx);
 
@@ -149,7 +154,7 @@ static void st_destroy_context_priv( struct st_context *st )
 
    _vbo_DestroyContext(st->ctx);
 
-   cso_cache_delete( st->cache );
+   cso_destroy_context(st->cso_context);
 
    _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);
 
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 897a5109b7e..e81aebba3d2 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -74,14 +74,11 @@ struct st_context
     * Other state is just parameter values.
     */
    struct {
-      const struct cso_alpha_test      *alpha_test;
-      const struct cso_blend           *blend;
-      void                             *sampler[PIPE_MAX_SAMPLERS];
-      const struct cso_depth_stencil_alpha   *depth_stencil;
-      const struct cso_rasterizer      *rasterizer;
-      const struct cso_fragment_shader *fs;
-      struct st_vertex_program   *vs;
-
+      struct pipe_blend_state               blend;
+      struct pipe_depth_stencil_alpha_state depth_stencil;
+      struct pipe_rasterizer_state          rasterizer;
+      struct pipe_sampler_state             samplers[PIPE_MAX_SAMPLERS];
+      struct pipe_sampler_state             *sampler_list[PIPE_MAX_SAMPLERS];
       struct pipe_blend_color  blend_color;
       struct pipe_clip_state clip;
       struct pipe_constant_buffer constants[2];
@@ -151,6 +148,10 @@ struct st_context
 
    /** For gen/render mipmap feature */
    struct {
+      struct pipe_blend_state blend;
+      struct pipe_depth_stencil_alpha_state depthstencil;
+      struct pipe_rasterizer_state rasterizer;
+
       void *blend_cso;
       void *depthstencil_cso;
       void *rasterizer_cso;
@@ -158,7 +159,7 @@ struct st_context
       struct st_vertex_program *stvp;
    } gen_mipmap;
 
-   struct cso_cache *cache;
+   struct cso_context *cso_context;
 };
 
 
diff --git a/src/mesa/state_tracker/st_debug.c b/src/mesa/state_tracker/st_debug.c
index 5888bcb98a3..9c13010da85 100644
--- a/src/mesa/state_tracker/st_debug.c
+++ b/src/mesa/state_tracker/st_debug.c
@@ -53,15 +53,15 @@ st_print_current(void)
    int i;
 
    printf("Vertex Transform Inputs:\n");
-   for (i = 0; i < st->state.vs->cso->state.num_inputs; i++) {
+   for (i = 0; i < st->vp->state.num_inputs; i++) {
       printf("  Slot %d:  VERT_ATTRIB_%d\n", i, st->vp->index_to_input[i]);
    }
 
-   tgsi_dump( st->state.vs->cso->state.tokens, 0 );
+   tgsi_dump( st->vp->state.tokens, 0 );
    if (st->vp->Base.Base.Parameters)
       _mesa_print_parameter_list(st->vp->Base.Base.Parameters);
 
-   tgsi_dump( st->state.fs->state.tokens, 0 );
+   tgsi_dump( st->fp->state.tokens, 0 );
    if (st->fp->Base.Base.Parameters)
       _mesa_print_parameter_list(st->fp->Base.Base.Parameters);
 }
diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 1c0fa8c6aad..98504e46c1a 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -36,7 +36,6 @@
 #include "vbo/vbo.h"
 
 #include "st_atom.h"
-#include "st_cache.h"
 #include "st_context.h"
 #include "st_cb_bufferobjects.h"
 #include "st_draw.h"
@@ -219,7 +218,7 @@ st_draw_vbo(GLcontext *ctx,
 
    /* must get these after state validation! */
    vp = ctx->st->vp;
-   vs = &ctx->st->state.vs->cso->state;
+   vs = &ctx->st->vp->state;
 
    /* loop over TGSI shader inputs to determine vertex buffer
     * and attribute info
@@ -481,10 +480,10 @@ st_feedback_draw_vbo(GLcontext *ctx,
 
    /* must get these after state validation! */
    vp = ctx->st->vp;
-   vs = &ctx->st->state.vs->cso->state;
+   vs = &st->vp->state;
 
-   if (!st->state.vs->draw_shader) {
-      st->state.vs->draw_shader = draw_create_vertex_shader(draw, vs);
+   if (!st->vp->draw_shader) {
+      st->vp->draw_shader = draw_create_vertex_shader(draw, vs);
    }
 
    /*
@@ -496,8 +495,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
    assert(draw);
    draw_set_viewport_state(draw, &st->state.viewport);
    draw_set_clip_state(draw, &st->state.clip);
-   draw_set_rasterizer_state(draw, &st->state.rasterizer->state);
-   draw_bind_vertex_shader(draw, st->state.vs->draw_shader);
+   draw_set_rasterizer_state(draw, &st->state.rasterizer);
+   draw_bind_vertex_shader(draw, st->vp->draw_shader);
    set_feedback_vertex_format(ctx);
 
    /* loop over TGSI shader inputs to determine vertex buffer
diff --git a/src/mesa/state_tracker/st_gen_mipmap.c b/src/mesa/state_tracker/st_gen_mipmap.c
index 3723e26d45d..9c4e1032efe 100644
--- a/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/src/mesa/state_tracker/st_gen_mipmap.c
@@ -38,6 +38,7 @@
 #include "pipe/p_inlines.h"
 #include "pipe/p_winsys.h"
 #include "cso_cache/cso_cache.h"
+#include "cso_cache/cso_context.h"
 
 #include "st_context.h"
 #include "st_draw.h"
@@ -89,8 +90,7 @@ make_tex_fragment_program(GLcontext *ctx)
 
    stfp = (struct st_fragment_program *) p;
 
-   st_translate_fragment_program(ctx->st, stfp, NULL,
-                                 stfp->tokens, ST_MAX_SHADER_TOKENS);
+   st_translate_fragment_program(ctx->st, stfp, NULL);
 
    return stfp;
 }
@@ -118,6 +118,7 @@ st_init_generate_mipmap(struct st_context *st)
    blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
    blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
    blend.colormask = PIPE_MASK_RGBA;
+   st->gen_mipmap.blend = blend;
    st->gen_mipmap.blend_cso = pipe->create_blend_state(pipe, &blend);
 
    memset(&depthstencil, 0, sizeof(depthstencil));
@@ -257,14 +258,14 @@ st_render_mipmap(struct st_context *st,
    sampler.normalized_coords = 1;
 
 
-   /* bind CSOs */
-   pipe->bind_blend_state(pipe, st->gen_mipmap.blend_cso);
-   pipe->bind_depth_stencil_alpha_state(pipe, st->gen_mipmap.depthstencil_cso);
-   pipe->bind_rasterizer_state(pipe, st->gen_mipmap.rasterizer_cso);
+   /* bind state */
+   cso_set_blend(st->cso_context, &st->gen_mipmap.blend);
+   cso_set_depth_stencil_alpha(st->cso_context, &st->gen_mipmap.depthstencil);
+   cso_set_rasterizer(st->cso_context, &st->gen_mipmap.rasterizer);
 
    /* bind shaders */
-   pipe->bind_fs_state(pipe, st->gen_mipmap.stfp->cso->data);
-   pipe->bind_vs_state(pipe, st->gen_mipmap.stvp->cso->data);
+   pipe->bind_fs_state(pipe, st->gen_mipmap.stfp->driver_shader);
+   pipe->bind_vs_state(pipe, st->gen_mipmap.stvp->driver_shader);
 
    /*
     * XXX for small mipmap levels, it may be faster to use the software
@@ -304,17 +305,18 @@ st_render_mipmap(struct st_context *st,
    /*pt->first_level = first_level_save;*/
 
    /* restore pipe state */
-   if (st->state.rasterizer)
-      pipe->bind_rasterizer_state(pipe, st->state.rasterizer->data);
-   if (st->state.fs)
-      pipe->bind_fs_state(pipe, st->state.fs->data);
-   if (st->state.vs)
-      pipe->bind_vs_state(pipe, st->state.vs->cso->data);
-   pipe->bind_sampler_states(pipe, st->state.num_samplers,
-                             st->state.sampler);
+#if 0
+   cso_set_rasterizer(st->cso_context, &st->state.rasterizer);
+   cso_set_samplers(st->cso_context, st->state.samplers_list);
+   pipe->bind_fs_state(pipe, st->fp->shader_program);
+   pipe->bind_vs_state(pipe, st->vp->shader_program);
    pipe->set_sampler_textures(pipe, st->state.num_textures,
                               st->state.sampler_texture);
    pipe->set_viewport_state(pipe, &st->state.viewport);
+#else
+   /* XXX is this sufficient? */
+   st_invalidate_state(st->ctx, _NEW_COLOR | _NEW_TEXTURE);
+#endif
 
    return TRUE;
 }
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index 97206752af3..9446b012ad7 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -683,8 +683,9 @@ find_temporaries(const struct gl_program *program,
  * \param tokens  array to store translated tokens in
  * \param maxTokens  size of the tokens array
  *
+ * \return number of tokens placed in 'tokens' buffer, or zero if error
  */
-GLboolean
+GLuint
 tgsi_translate_mesa_program(
    uint procType,
    const struct gl_program *program,
@@ -918,6 +919,6 @@ tgsi_translate_mesa_program(
          maxTokens - ti );
    }
 
-   return GL_TRUE;
+   return ti;
 }
 
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.h b/src/mesa/state_tracker/st_mesa_to_tgsi.h
index 3ababf13397..63fc855b535 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.h
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.h
@@ -39,7 +39,7 @@ extern "C" {
 struct tgsi_token;
 struct gl_program;
 
-GLboolean
+GLuint
 tgsi_translate_mesa_program(
    uint procType,
    const struct gl_program *program,
diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index aa252c845ad..0f8784e132e 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -42,15 +42,29 @@
 #include "tgsi/util/tgsi_dump.h"
 
 #include "st_context.h"
-#include "st_cache.h"
 #include "st_atom.h"
 #include "st_program.h"
 #include "st_mesa_to_tgsi.h"
+#include "cso_cache/cso_context.h"
 
 
 #define TGSI_DEBUG 0
 
 
+/** XXX we should use the version of this from p_util.h but including
+ * that header causes symbol collisions.
+ */
+static INLINE void *
+mem_dup(const void *src, uint size)
+{
+   void *dup = MALLOC(size);
+   if (dup)
+      memcpy(dup, src, size);
+   return dup;
+}
+
+
+
 /**
  * Translate a Mesa vertex shader into a TGSI shader.
  * \param outputMapping  to map vertex program output registers to TGSI
@@ -61,15 +75,15 @@
 void
 st_translate_vertex_program(struct st_context *st,
                             struct st_vertex_program *stvp,
-                            const GLuint outputMapping[],
-                            struct tgsi_token *tokensOut,
-                            GLuint maxTokens)
+                            const GLuint outputMapping[])
 {
+   struct pipe_context *pipe = st->pipe;
+   struct tgsi_token tokens[ST_MAX_SHADER_TOKENS];
    GLuint defaultOutputMapping[VERT_RESULT_MAX];
    struct pipe_shader_state vs;
-   const struct cso_vertex_shader *cso;
    GLuint attr, i;
    GLuint num_generic = 0;
+   GLuint num_tokens;
 
    memset(&vs, 0, sizeof(vs));
 
@@ -240,7 +254,7 @@ st_translate_vertex_program(struct st_context *st,
 
    /* XXX: fix static allocation of tokens:
     */
-   tgsi_translate_mesa_program( TGSI_PROCESSOR_VERTEX,
+   num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_VERTEX,
                                 &stvp->Base.Base,
                                 /* inputs */
                                 vs.num_inputs,
@@ -252,20 +266,21 @@ st_translate_vertex_program(struct st_context *st,
                                 vs.num_outputs,
                                 outputMapping,
                                 vs.output_semantic_name,
-                                 vs.output_semantic_index,
+                                vs.output_semantic_index,
                                 /* tokenized result */
-                                tokensOut, maxTokens);
+                                tokens, ST_MAX_SHADER_TOKENS);
 
-   vs.tokens = tokensOut;
+   vs.tokens = (struct tgsi_token *)
+      mem_dup(tokens, num_tokens * sizeof(tokens[0]));
 
-   cso = st_cached_vs_state(st, &vs);
-   stvp->cso = cso;
+   stvp->state = vs; /* struct copy */
+   stvp->driver_shader = pipe->create_vs_state(pipe, &vs);
 
    if (0)
       _mesa_print_program(&stvp->Base.Base);
 
    if (TGSI_DEBUG)
-      tgsi_dump( tokensOut, 0 );
+      tgsi_dump( vs.tokens, 0 );
 }
 
 
@@ -280,10 +295,10 @@ st_translate_vertex_program(struct st_context *st,
 const struct cso_fragment_shader *
 st_translate_fragment_program(struct st_context *st,
                               struct st_fragment_program *stfp,
-                              const GLuint inputMapping[],
-                              struct tgsi_token *tokensOut,
-                              GLuint maxTokens)
+                              const GLuint inputMapping[])
 {
+   struct pipe_context *pipe = st->pipe;
+   struct tgsi_token tokens[ST_MAX_SHADER_TOKENS];
    GLuint outputMapping[FRAG_RESULT_MAX];
    GLuint defaultInputMapping[FRAG_ATTRIB_MAX];
    struct pipe_shader_state fs;
@@ -293,6 +308,7 @@ st_translate_fragment_program(struct st_context *st,
    const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
    GLuint vslot = 0;
    GLuint num_generic = 0;
+   GLuint num_tokens;
 
    memset(&fs, 0, sizeof(fs));
 
@@ -401,7 +417,7 @@ st_translate_fragment_program(struct st_context *st,
 
    /* XXX: fix static allocation of tokens:
     */
-   tgsi_translate_mesa_program( TGSI_PROCESSOR_FRAGMENT,
+   num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_FRAGMENT,
                                 &stfp->Base.Base,
                                 /* inputs */
                                 fs.num_inputs,
@@ -415,18 +431,19 @@ st_translate_fragment_program(struct st_context *st,
                                 fs.output_semantic_name,
                                 fs.output_semantic_index,
                                 /* tokenized result */
-                                tokensOut, maxTokens);
+                                tokens, ST_MAX_SHADER_TOKENS);
 
-   fs.tokens = tokensOut;
+   fs.tokens = (struct tgsi_token *)
+      mem_dup(tokens, num_tokens * sizeof(tokens[0]));
 
-   cso = st_cached_fs_state(st, &fs);
-   stfp->cso = cso;
+   stfp->state = fs; /* struct copy */
+   stfp->driver_shader = pipe->create_fs_state(pipe, &fs);
 
    if (0)
       _mesa_print_program(&stfp->Base.Base);
 
    if (TGSI_DEBUG)
-      tgsi_dump( tokensOut, 0/*TGSI_DUMP_VERBOSE*/ );
+      tgsi_dump( fs.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
 
    return cso;
 }
diff --git a/src/mesa/state_tracker/st_program.h b/src/mesa/state_tracker/st_program.h
index 31558af6ced..78786dcbb61 100644
--- a/src/mesa/state_tracker/st_program.h
+++ b/src/mesa/state_tracker/st_program.h
@@ -60,11 +60,8 @@ struct st_fragment_program
    /** map FP input back to VP output */
    GLuint input_map[PIPE_MAX_SHADER_INPUTS];
 
-   /** The program in TGSI format */
-   struct tgsi_token tokens[ST_MAX_SHADER_TOKENS];
-
-   /** Pointer to the corresponding cached shader */
-   const struct cso_fragment_shader *cso;
+   struct pipe_shader_state state;
+   struct pipe_shader_state *driver_shader;
 
    GLuint param_state;
 
@@ -88,11 +85,8 @@ struct st_vertex_program
    /** maps a TGSI input index back to a Mesa VERT_ATTRIB_x */
    GLuint index_to_input[PIPE_MAX_SHADER_INPUTS];
 
-   /** The program in TGSI format */
-   struct tgsi_token tokens[ST_MAX_SHADER_TOKENS];
-
-   /** Pointer to the corresponding cached shader */
-   const struct cso_vertex_shader *cso;
+   struct pipe_shader_state state;
+   struct pipe_shader_state *driver_shader;
 
    /** For using our private draw module (glRasterPos) */
    struct draw_vertex_shader *draw_shader;
@@ -122,16 +116,12 @@ st_vertex_program( struct gl_vertex_program *vp )
 extern const struct cso_fragment_shader *
 st_translate_fragment_program(struct st_context *st,
                               struct st_fragment_program *fp,
-                              const GLuint inputMapping[],
-                              struct tgsi_token *tokens,
-                              GLuint maxTokens);
+                              const GLuint inputMapping[]);
 
 
 extern void
 st_translate_vertex_program(struct st_context *st,
                             struct st_vertex_program *vp,
-                            const GLuint vert_output_to_slot[],
-                            struct tgsi_token *tokens,
-                            GLuint maxTokens);
+                            const GLuint vert_output_to_slot[]);
 
 #endif