Merge remote branch 'main/master' into radeon-rewrite

Conflicts:
	src/mesa/drivers/dri/r300/r300_cmdbuf.c
	src/mesa/drivers/dri/r300/r300_state.c
	src/mesa/drivers/dri/r300/r300_swtcl.c
	src/mesa/drivers/dri/r300/radeon_ioctl.c
	src/mesa/drivers/dri/radeon/radeon_screen.c

192 files changed, 7644 insertions, 3681 deletions

diff --git a/src/gallium/drivers/Makefile b/src/gallium/drivers/Makefile
index 6161cb6ff8f..9fe9b2c11d0 100644
--- a/src/gallium/drivers/Makefile
+++ b/src/gallium/drivers/Makefile
@@ -1,20 +1,12 @@
+# src/gallium/drivers/Makefile
 TOP = ../../..
 include $(TOP)/configs/current
 
+SUBDIRS = $(GALLIUM_DRIVERS_DIRS)
 
-SUBDIRS = $(GALLIUM_DRIVER_DIRS)
-
-
-default: subdirs
-
-
-subdirs:
+default install clean:
 	@for dir in $(SUBDIRS) ; do \
 		if [ -d $$dir ] ; then \
-			(cd $$dir && $(MAKE)) || exit 1 ; \
+			(cd $$dir && $(MAKE) $@) || exit 1; \
 		fi \
 	done
-
-
-clean:
-	rm -f `find . -name \*.[oa]`
diff --git a/src/gallium/drivers/cell/ppu/cell_clear.c b/src/gallium/drivers/cell/ppu/cell_clear.c
index c2e276988ca..edc06747ac1 100644
--- a/src/gallium/drivers/cell/ppu/cell_clear.c
+++ b/src/gallium/drivers/cell/ppu/cell_clear.c
@@ -70,18 +70,12 @@ void
 cell_clear_surface(struct pipe_context *pipe, struct pipe_surface *ps,
                    unsigned clearValue)
 {
-   struct pipe_screen *screen = pipe->screen;
    struct cell_context *cell = cell_context(pipe);
    uint surfIndex;
 
    if (cell->dirty)
       cell_update_derived(cell);
 
-
-   if (!cell->cbuf_map[0])
-      cell->cbuf_map[0] = screen->surface_map(screen, ps,
-                                              PIPE_BUFFER_USAGE_GPU_WRITE);
-
    if (ps == cell->framebuffer.zsbuf) {
       /* clear z/stencil buffer */
       surfIndex = 1;
diff --git a/src/gallium/drivers/cell/ppu/cell_context.h b/src/gallium/drivers/cell/ppu/cell_context.h
index eb1397bb3fa..5c3188e7f9d 100644
--- a/src/gallium/drivers/cell/ppu/cell_context.h
+++ b/src/gallium/drivers/cell/ppu/cell_context.h
@@ -130,9 +130,6 @@ struct cell_context
    ubyte *cbuf_map[PIPE_MAX_COLOR_BUFS];
    ubyte *zsbuf_map;
 
-   struct pipe_surface *tex_surf;
-   uint *tex_map;
-
    uint dirty;
    uint dirty_textures;  /* bitmask of texture units */
    uint dirty_samplers;  /* bitmask of sampler units */
diff --git a/src/gallium/drivers/cell/ppu/cell_fence.c b/src/gallium/drivers/cell/ppu/cell_fence.c
index 867b5dcaa09..13125a9fa30 100644
--- a/src/gallium/drivers/cell/ppu/cell_fence.c
+++ b/src/gallium/drivers/cell/ppu/cell_fence.c
@@ -96,7 +96,7 @@ cell_add_buffer_to_list(struct cell_context *cell,
    struct cell_buffer_node *node = CALLOC_STRUCT(cell_buffer_node);
    /* create new list node which references the buffer, insert at head */
    if (node) {
-      pipe_buffer_reference(ps, &node->buffer, buffer);
+      pipe_buffer_reference(&node->buffer, buffer);
       node->next = list->head;
       list->head = node;
    }
@@ -127,10 +127,10 @@ cell_free_fenced_buffers(struct cell_context *cell,
          pipe_buffer_unmap(ps, node->buffer);
 #if 0
          printf("Unref buffer %p\n", node->buffer);
-         if (node->buffer->refcount == 1)
+         if (node->buffer->reference.count == 1)
             printf("   Delete!\n");
 #endif
-         pipe_buffer_reference(ps, &node->buffer, NULL);
+         pipe_buffer_reference(&node->buffer, NULL);
          FREE(node);
          node = next;
       }
@@ -153,16 +153,12 @@ cell_add_fenced_textures(struct cell_context *cell)
    for (i = 0; i < cell->num_textures; i++) {
       struct cell_texture *ct = cell->texture[i];
       if (ct) {
-         uint level;
-         for (level = 0; level < CELL_MAX_TEXTURE_LEVELS; level++) {
-            if (ct->tiled_buffer[level]) {
 #if 0
-               printf("Adding texture %p buffer %p to list\n",
-                      ct, ct->tiled_buffer[level]);
+         printf("Adding texture %p buffer %p to list\n",
+                ct, ct->tiled_buffer[level]);
 #endif
-               cell_add_buffer_to_list(cell, list, ct->tiled_buffer[level]);
-            }
-         }
+         if (ct->buffer)
+            cell_add_buffer_to_list(cell, list, ct->buffer);
       }
    }
 }
diff --git a/src/gallium/drivers/cell/ppu/cell_pipe_state.c b/src/gallium/drivers/cell/ppu/cell_pipe_state.c
index ca358ed031e..ccd0fef6e84 100644
--- a/src/gallium/drivers/cell/ppu/cell_pipe_state.c
+++ b/src/gallium/drivers/cell/ppu/cell_pipe_state.c
@@ -253,10 +253,13 @@ cell_set_sampler_textures(struct pipe_context *pipe,
    assert(num <= CELL_MAX_SAMPLERS);
 
    for (i = 0; i < CELL_MAX_SAMPLERS; i++) {
-      struct pipe_texture *new_tex = i < num ? texture[i] : NULL;
-      if ((struct pipe_texture *) cell->texture[i] != new_tex) {
+      struct cell_texture *new_tex = cell_texture(i < num ? texture[i] : NULL);
+      struct cell_texture *old_tex = cell->texture[i];
+      if (old_tex != new_tex) {
+
          pipe_texture_reference((struct pipe_texture **) &cell->texture[i],
-                                new_tex);
+                                (struct pipe_texture *) new_tex);
+
          changed |= (1 << i);
       }
    }
@@ -270,6 +273,70 @@ cell_set_sampler_textures(struct pipe_context *pipe,
 }
 
 
+/**
+ * Map color and z/stencil framebuffer surfaces.
+ */
+static void
+cell_map_surfaces(struct cell_context *cell)
+{
+   struct pipe_screen *screen = cell->pipe.screen;
+   uint i;
+
+   for (i = 0; i < 1; i++) {
+      struct pipe_surface *ps = cell->framebuffer.cbufs[i];
+      if (ps) {
+         struct cell_texture *ct = cell_texture(ps->texture);
+         cell->cbuf_map[i] = screen->buffer_map(screen,
+                                                ct->buffer,
+                                                (PIPE_BUFFER_USAGE_GPU_READ |
+                                                 PIPE_BUFFER_USAGE_GPU_WRITE));
+      }
+   }
+
+   {
+      struct pipe_surface *ps = cell->framebuffer.zsbuf;
+      if (ps) {
+         struct cell_texture *ct = cell_texture(ps->texture);
+         cell->zsbuf_map = screen->buffer_map(screen,
+                                              ct->buffer,
+                                              (PIPE_BUFFER_USAGE_GPU_READ |
+                                               PIPE_BUFFER_USAGE_GPU_WRITE));
+      }
+   }
+}
+
+
+/**
+ * Unmap color and z/stencil framebuffer surfaces.
+ */
+static void
+cell_unmap_surfaces(struct cell_context *cell)
+{
+   struct pipe_screen *screen = cell->pipe.screen;
+   uint i;
+
+   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
+      struct pipe_surface *ps = cell->framebuffer.cbufs[i];
+      if (ps && cell->cbuf_map[i]) {
+         struct cell_texture *ct = cell_texture(ps->texture);
+         assert(ps->texture);
+         assert(ct->buffer);
+
+         screen->buffer_unmap(screen, ct->buffer);
+         cell->cbuf_map[i] = NULL;
+      }
+   }
+
+   {
+      struct pipe_surface *ps = cell->framebuffer.zsbuf;
+      if (ps && cell->zsbuf_map) {
+         struct cell_texture *ct = cell_texture(ps->texture);
+         screen->buffer_unmap(screen, ct->buffer);
+         cell->zsbuf_map = NULL;
+      }
+   }
+}
+
 
 static void
 cell_set_framebuffer_state(struct pipe_context *pipe,
@@ -278,24 +345,10 @@ cell_set_framebuffer_state(struct pipe_context *pipe,
    struct cell_context *cell = cell_context(pipe);
 
    if (1 /*memcmp(&cell->framebuffer, fb, sizeof(*fb))*/) {
-      struct pipe_surface *csurf = fb->cbufs[0];
-      struct pipe_surface *zsurf = fb->zsbuf;
       uint i;
-      uint flags = (PIPE_BUFFER_USAGE_GPU_WRITE |
-                    PIPE_BUFFER_USAGE_GPU_READ);
 
       /* unmap old surfaces */
-      for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
-         if (cell->framebuffer.cbufs[i] && cell->cbuf_map[i]) {
-            pipe_surface_unmap(cell->framebuffer.cbufs[i]);
-            cell->cbuf_map[i] = NULL;
-         }
-      }
-
-      if (cell->framebuffer.zsbuf && cell->zsbuf_map) {
-         pipe_surface_unmap(cell->framebuffer.zsbuf);
-         cell->zsbuf_map = NULL;
-      }
+      cell_unmap_surfaces(cell);
 
       /* Finish any pending rendering to the current surface before
        * installing a new surface!
@@ -314,11 +367,7 @@ cell_set_framebuffer_state(struct pipe_context *pipe,
       pipe_surface_reference(&cell->framebuffer.zsbuf, fb->zsbuf);
 
       /* map new surfaces */
-      if (csurf)
-         cell->cbuf_map[0] = pipe_surface_map(csurf, flags);
-
-      if (zsurf)
-         cell->zsbuf_map = pipe_surface_map(zsurf, flags);
+      cell_map_surfaces(cell);
 
       cell->dirty |= CELL_NEW_FRAMEBUFFER;
    }
diff --git a/src/gallium/drivers/cell/ppu/cell_state_emit.c b/src/gallium/drivers/cell/ppu/cell_state_emit.c
index ff529fe22cb..9479c0898fd 100644
--- a/src/gallium/drivers/cell/ppu/cell_state_emit.c
+++ b/src/gallium/drivers/cell/ppu/cell_state_emit.c
@@ -287,19 +287,23 @@ cell_emit_state(struct cell_context *cell)
       for (i = 0;i < CELL_MAX_SAMPLERS; i++) {
          if (cell->dirty_textures & (1 << i)) {
             STATIC_ASSERT(sizeof(struct cell_command_texture) % 16 == 0);
-            struct cell_command_texture *texture
-               =  (struct cell_command_texture *)cell_batch_alloc16(cell, sizeof(*texture));
+            struct cell_command_texture *texture =
+               (struct cell_command_texture *)
+               cell_batch_alloc16(cell, sizeof(*texture));
+
             texture->opcode[0] = CELL_CMD_STATE_TEXTURE;
             texture->unit = i;
             if (cell->texture[i]) {
+               struct cell_texture *ct = cell->texture[i];
                uint level;
                for (level = 0; level < CELL_MAX_TEXTURE_LEVELS; level++) {
-                  texture->start[level] = cell->texture[i]->tiled_mapped[level];
-                  texture->width[level] = cell->texture[i]->base.width[level];
-                  texture->height[level] = cell->texture[i]->base.height[level];
-                  texture->depth[level] = cell->texture[i]->base.depth[level];
+                  texture->start[level] = (ct->mapped +
+                                           ct->level_offset[level]);
+                  texture->width[level] = ct->base.width[level];
+                  texture->height[level] = ct->base.height[level];
+                  texture->depth[level] = ct->base.depth[level];
                }
-               texture->target = cell->texture[i]->base.target;
+               texture->target = ct->base.target;
             }
             else {
                uint level;
diff --git a/src/gallium/drivers/cell/ppu/cell_state_shader.c b/src/gallium/drivers/cell/ppu/cell_state_shader.c
index bf517ea5635..6568c784fec 100644
--- a/src/gallium/drivers/cell/ppu/cell_state_shader.c
+++ b/src/gallium/drivers/cell/ppu/cell_state_shader.c
@@ -193,9 +193,7 @@ cell_set_constant_buffer(struct pipe_context *pipe,
    draw_flush(cell->draw);
 
    /* note: reference counting */
-   pipe_buffer_reference(pipe->screen,
-                         &cell->constants[shader].buffer,
-                         buf->buffer);
+   pipe_buffer_reference(&cell->constants[shader].buffer, buf->buffer);
 
    if (shader == PIPE_SHADER_VERTEX)
       cell->dirty |= CELL_NEW_VS_CONSTANTS;
diff --git a/src/gallium/drivers/cell/ppu/cell_surface.c b/src/gallium/drivers/cell/ppu/cell_surface.c
index c9203fee087..ffb8595d828 100644
--- a/src/gallium/drivers/cell/ppu/cell_surface.c
+++ b/src/gallium/drivers/cell/ppu/cell_surface.c
@@ -30,9 +30,21 @@
 #include "cell_surface.h"
 
 
+static void
+cell_surface_copy(struct pipe_context *pipe,
+                  struct pipe_surface *dest, unsigned destx, unsigned desty,
+                  struct pipe_surface *src, unsigned srcx, unsigned srcy,
+                  unsigned width, unsigned height)
+{
+   util_surface_copy(pipe, FALSE,
+                     dest, destx, desty,
+                     src, srcx, srcy,
+                     width, height);
+}
+
 void
 cell_init_surface_functions(struct cell_context *cell)
 {
-   cell->pipe.surface_copy = util_surface_copy;
+   cell->pipe.surface_copy = cell_surface_copy;
    cell->pipe.surface_fill = util_surface_fill;
 }
diff --git a/src/gallium/drivers/cell/ppu/cell_texture.c b/src/gallium/drivers/cell/ppu/cell_texture.c
index 9ba995ab7d3..e26594448f0 100644
--- a/src/gallium/drivers/cell/ppu/cell_texture.c
+++ b/src/gallium/drivers/cell/ppu/cell_texture.c
@@ -62,7 +62,7 @@ cell_texture_layout(struct cell_texture *ct)
 
    ct->buffer_size = 0;
 
-   for ( level = 0 ; level <= pt->last_level ; level++ ) {
+   for (level = 0; level <= pt->last_level; level++) {
       unsigned size;
       unsigned w_tile, h_tile;
 
@@ -90,7 +90,7 @@ cell_texture_layout(struct cell_texture *ct)
 
       ct->buffer_size += size;
 
-      width  = minify(width);
+      width = minify(width);
       height = minify(height);
       depth = minify(depth);
    }
@@ -101,18 +101,17 @@ static struct pipe_texture *
 cell_texture_create(struct pipe_screen *screen,
                     const struct pipe_texture *templat)
 {
-   struct pipe_winsys *ws = screen->winsys;
    struct cell_texture *ct = CALLOC_STRUCT(cell_texture);
    if (!ct)
       return NULL;
 
    ct->base = *templat;
-   ct->base.refcount = 1;
+   pipe_reference_init(&ct->base.reference, 1);
    ct->base.screen = screen;
 
    cell_texture_layout(ct);
 
-   ct->buffer = ws->buffer_create(ws, 32, PIPE_BUFFER_USAGE_PIXEL,
+   ct->buffer = screen->buffer_create(screen, 32, PIPE_BUFFER_USAGE_PIXEL,
                                    ct->buffer_size);
 
    if (!ct->buffer) {
@@ -125,42 +124,18 @@ cell_texture_create(struct pipe_screen *screen,
 
 
 static void
-cell_texture_release(struct pipe_screen *screen,
-                     struct pipe_texture **pt)
+cell_texture_destroy(struct pipe_texture *pt)
 {
-   if (!*pt)
-      return;
-
-   /*
-   DBG("%s %p refcount will be %d\n",
-       __FUNCTION__, (void *) *pt, (*pt)->refcount - 1);
-   */
-   if (--(*pt)->refcount <= 0) {
-      /* Delete this texture now.
-       * But note that the underlying pipe_buffer may linger...
-       */
-      struct cell_texture *ct = cell_texture(*pt);
-      uint i;
+   struct cell_texture *ct = cell_texture(pt);
 
-      /*
-      DBG("%s deleting %p\n", __FUNCTION__, (void *) ct);
-      */
+   if (ct->mapped) {
+      pipe_buffer_unmap(ct->buffer->screen, ct->buffer);
+      ct->mapped = NULL;
+   }
 
-      pipe_buffer_reference(screen, &ct->buffer, NULL);
+   pipe_buffer_reference(&ct->buffer, NULL);
 
-      for (i = 0; i < CELL_MAX_TEXTURE_LEVELS; i++) {
-         /* Unreference the tiled image buffer.
-          * It may not actually be deleted until a fence is hit.
-          */
-         if (ct->tiled_buffer[i]) {
-            ct->tiled_mapped[i] = NULL;
-            pipe_buffer_reference(screen, &ct->tiled_buffer[i], NULL);
-         }
-      }
-
-      FREE(ct);
-   }
-   *pt = NULL;
+   FREE(ct);
 }
 
 
@@ -294,103 +269,6 @@ untwiddle_image_uint(uint w, uint h, uint tile_size, uint *dst,
 }
 
 
-/**
- * Convert linear texture image data to tiled format for SPU usage.
- */
-static void
-cell_twiddle_texture(struct pipe_screen *screen,
-                     struct pipe_surface *surface)
-{
-   struct cell_texture *ct = cell_texture(surface->texture);
-   const uint level = surface->level;
-   const uint texWidth = ct->base.width[level];
-   const uint texHeight = ct->base.height[level];
-   const uint bufWidth = align(texWidth, TILE_SIZE);
-   const uint bufHeight = align(texHeight, TILE_SIZE);
-   const void *map = screen->surface_map(screen, surface, PIPE_BUFFER_USAGE_CPU_READ);
-   const uint *src = (const uint *) map;
-
-   switch (ct->base.format) {
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-   case PIPE_FORMAT_S8Z24_UNORM:
-      {
-         int numFaces = ct->base.target == PIPE_TEXTURE_CUBE ? 6 : 1;
-         int offset = bufWidth * bufHeight * 4 * surface->face;
-         uint *dst;
-
-         if (!ct->tiled_buffer[level]) {
-            /* allocate buffer for tiled data now */
-            struct pipe_winsys *ws = screen->winsys;
-            uint bytes = bufWidth * bufHeight * 4 * numFaces;
-            ct->tiled_buffer[level] =
-               ws->buffer_create(ws, 16, PIPE_BUFFER_USAGE_PIXEL, bytes);
-            /* and map it */
-            ct->tiled_mapped[level] =
-               ws->buffer_map(ws, ct->tiled_buffer[level],
-                              PIPE_BUFFER_USAGE_GPU_READ);
-         }
-         dst = (uint *) ((ubyte *) ct->tiled_mapped[level] + offset);
-
-         twiddle_image_uint(texWidth, texHeight, TILE_SIZE, dst,
-                            surface->stride, src);
-      }
-      break;
-   default:
-      printf("Cell: twiddle unsupported texture format %s\n",
-             pf_name(ct->base.format));
-   }
-
-   screen->surface_unmap(screen, surface);
-}
-
-
-/**
- * Convert SPU tiled texture image data to linear format for app usage.
- */
-static void
-cell_untwiddle_texture(struct pipe_screen *screen,
-                     struct pipe_surface *surface)
-{
-   struct cell_texture *ct = cell_texture(surface->texture);
-   const uint level = surface->level;
-   const uint texWidth = ct->base.width[level];
-   const uint texHeight = ct->base.height[level];
-   const void *map = screen->surface_map(screen, surface, PIPE_BUFFER_USAGE_CPU_READ);
-   const uint *src = (const uint *) ((const ubyte *) map + surface->offset);
-
-   switch (ct->base.format) {
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-   case PIPE_FORMAT_S8Z24_UNORM:
-      {
-         int numFaces = ct->base.target == PIPE_TEXTURE_CUBE ? 6 : 1;
-         int offset = surface->stride * texHeight * 4 * surface->face;
-         uint *dst;
-
-         if (!ct->untiled_data[level]) {
-            ct->untiled_data[level] =
-               align_malloc(surface->stride * texHeight * 4 * numFaces, 16);
-         }
-
-         dst = (uint *) ((ubyte *) ct->untiled_data[level] + offset);
-
-         untwiddle_image_uint(texWidth, texHeight, TILE_SIZE, dst,
-                              surface->stride, src);
-      }
-      break;
-   default:
-      {
-         ct->untiled_data[level] = NULL;
-         printf("Cell: untwiddle unsupported texture format %s\n",
-                pf_name(ct->base.format));
-      }
-   }
-
-   screen->surface_unmap(screen, surface);
-}
-
-
 static struct pipe_surface *
 cell_get_tex_surface(struct pipe_screen *screen,
                      struct pipe_texture *pt,
@@ -402,130 +280,223 @@ cell_get_tex_surface(struct pipe_screen *screen,
 
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
-      ps->refcount = 1;
+      pipe_reference_init(&ps->reference, 1);
       pipe_texture_reference(&ps->texture, pt);
       ps->format = pt->format;
-      ps->block = pt->block;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->nblocksx = pt->nblocksx[level];
-      ps->nblocksy = pt->nblocksy[level];
-      ps->stride = ct->stride[level];
       ps->offset = ct->level_offset[level];
-      ps->usage = usage;
-
       /* XXX may need to override usage flags (see sp_texture.c) */
-
-      pipe_texture_reference(&ps->texture, pt); 
+      ps->usage = usage;
       ps->face = face;
       ps->level = level;
       ps->zslice = zslice;
 
-      if (pt->target == PIPE_TEXTURE_CUBE || pt->target == PIPE_TEXTURE_3D) {
-         ps->offset += ((pt->target == PIPE_TEXTURE_CUBE) ? face : zslice) *
-            ps->nblocksy *
-            ps->stride;
+      if (pt->target == PIPE_TEXTURE_CUBE) {
+         ps->offset += face * pt->nblocksy[level] * ct->stride[level];
+      }
+      else if (pt->target == PIPE_TEXTURE_3D) {
+         ps->offset += zslice * pt->nblocksy[level] * ct->stride[level];
       }
       else {
          assert(face == 0);
          assert(zslice == 0);
       }
-
-      if (ps->usage & PIPE_BUFFER_USAGE_CPU_READ) {
-         /* convert from tiled to linear layout */
-         cell_untwiddle_texture(screen, ps);
-      }
    }
    return ps;
 }
 
 
 static void 
-cell_tex_surface_release(struct pipe_screen *screen, 
-                         struct pipe_surface **s)
+cell_tex_surface_destroy(struct pipe_surface *surf)
 {
-   struct cell_texture *ct = cell_texture((*s)->texture);
-   const uint level = (*s)->level;
-   struct pipe_surface *surf = *s;
-
-   if ((surf->usage & PIPE_BUFFER_USAGE_CPU_READ) && (ct->untiled_data[level]))
-   {
-      align_free(ct->untiled_data[level]);
-      ct->untiled_data[level] = NULL;
-   }
+   pipe_texture_reference(&surf->texture, NULL);
+   FREE(surf);
+}
 
-   if ((ct->base.tex_usage & PIPE_TEXTURE_USAGE_SAMPLER) &&
-       (surf->usage & PIPE_BUFFER_USAGE_CPU_WRITE)) {
-      /* convert from linear to tiled layout */
-      cell_twiddle_texture(screen, surf);
+
+/**
+ * Create new pipe_transfer object.
+ * This is used by the user to put tex data into a texture (and get it
+ * back out for glGetTexImage).
+ */
+static struct pipe_transfer *
+cell_get_tex_transfer(struct pipe_screen *screen,
+                      struct pipe_texture *texture,
+                      unsigned face, unsigned level, unsigned zslice,
+                      enum pipe_transfer_usage usage,
+                      unsigned x, unsigned y, unsigned w, unsigned h)
+{
+   struct cell_texture *ct = cell_texture(texture);
+   struct cell_transfer *ctrans;
+
+   assert(texture);
+   assert(level <= texture->last_level);
+
+   ctrans = CALLOC_STRUCT(cell_transfer);
+   if (ctrans) {
+      struct pipe_transfer *pt = &ctrans->base;
+      pipe_texture_reference(&pt->texture, texture);
+      pt->format = texture->format;
+      pt->block = texture->block;
+      pt->x = x;
+      pt->y = y;
+      pt->width = w;
+      pt->height = h;
+      pt->nblocksx = texture->nblocksx[level];
+      pt->nblocksy = texture->nblocksy[level];
+      pt->stride = ct->stride[level];
+      pt->usage = usage;
+      pt->face = face;
+      pt->level = level;
+      pt->zslice = zslice;
+
+      ctrans->offset = ct->level_offset[level];
+
+      if (texture->target == PIPE_TEXTURE_CUBE) {
+         ctrans->offset += face * pt->nblocksy * pt->stride;
+      }
+      else if (texture->target == PIPE_TEXTURE_3D) {
+         ctrans->offset += zslice * pt->nblocksy * pt->stride;
+      }
+      else {
+         assert(face == 0);
+         assert(zslice == 0);
+      }
+      return pt;
    }
+   return NULL;
+}
 
-   /* XXX if done rendering to teximage, re-tile */
 
-   if (--surf->refcount == 0) {
-      pipe_texture_reference(&surf->texture, NULL);
-      FREE(surf);
-   }
-   *s = NULL;
+static void 
+cell_tex_transfer_destroy(struct pipe_transfer *t)
+{
+   struct cell_transfer *transfer = cell_transfer(t);
+   /* Effectively do the texture_update work here - if texture images
+    * needed post-processing to put them into hardware layout, this is
+    * where it would happen.  For cell, nothing to do.
+    */
+   assert (transfer->base.texture);
+   pipe_texture_reference(&transfer->base.texture, NULL);
+   FREE(transfer);
 }
 
 
+/**
+ * Return pointer to texture image data in linear layout.
+ */
 static void *
-cell_surface_map(struct pipe_screen *screen,
-                 struct pipe_surface *surface,
-                 unsigned flags)
+cell_transfer_map(struct pipe_screen *screen, struct pipe_transfer *transfer)
 {
-   ubyte *map;
-   struct cell_texture *ct = cell_texture(surface->texture);
-   const uint level = surface->level;
+   struct cell_transfer *ctrans = cell_transfer(transfer);
+   struct pipe_texture *pt = transfer->texture;
+   struct cell_texture *ct = cell_texture(pt);
+   const uint level = ctrans->base.level;
+   const uint texWidth = pt->width[level];
+   const uint texHeight = pt->height[level];
+   const uint stride = ct->stride[level];
+   unsigned flags = 0x0;
+   unsigned size;
 
-   assert(ct);
+   assert(transfer->texture);
 
-#if 0
-   if (flags & ~surface->usage) {
-      assert(0);
-      return NULL;
+   if (transfer->usage != PIPE_TRANSFER_READ) {
+      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
    }
-#endif
 
-   map = pipe_buffer_map( screen, ct->buffer, flags );
-   if (map == NULL) {
-      return NULL;
+   if (transfer->usage != PIPE_TRANSFER_WRITE) {
+      flags |= PIPE_BUFFER_USAGE_CPU_READ;
+   }
+
+   if (!ct->mapped) {
+      /* map now */
+      ct->mapped = pipe_buffer_map(screen, ct->buffer, flags);
    }
-   else {
-      if ((surface->usage & PIPE_BUFFER_USAGE_CPU_READ) &&
-          (ct->untiled_data[level])) {
-         return (void *) ((ubyte *) ct->untiled_data[level] + surface->offset);
+
+   /*
+    * Create a buffer of ordinary memory for the linear texture.
+    * This is the memory that the user will read/write.
+    */
+   size = pt->nblocksx[level] * pt->nblocksy[level] * pt->block.size;
+
+   ctrans->map = align_malloc(size, 16);
+   if (!ctrans->map)
+      return NULL; /* out of memory */
+
+   if (transfer->usage & PIPE_TRANSFER_READ) {
+      /* need to untwiddle the texture to make a linear version */
+      const uint bpp = pf_get_size(ct->base.format);
+      if (bpp == 4) {
+         const uint *src = (uint *) (ct->mapped + ctrans->offset);
+         uint *dst = ctrans->map;
+         untwiddle_image_uint(texWidth, texHeight, TILE_SIZE,
+                              dst, stride, src);
       }
       else {
-         return (void *) (map + surface->offset);
+         // xxx fix
       }
    }
+
+   return ctrans->map;
 }
 
 
+/**
+ * Called when user is done reading/writing texture data.
+ * If new data was written, this is where we convert the linear data
+ * to tiled data.
+ */
 static void
-cell_surface_unmap(struct pipe_screen *screen,
-                   struct pipe_surface *surface)
+cell_transfer_unmap(struct pipe_screen *screen,
+                    struct pipe_transfer *transfer)
 {
-   struct cell_texture *ct = cell_texture(surface->texture);
+   struct cell_transfer *ctrans = cell_transfer(transfer);
+   struct pipe_texture *pt = transfer->texture;
+   struct cell_texture *ct = cell_texture(pt);
+   const uint level = ctrans->base.level;
+   const uint texWidth = pt->width[level];
+   const uint texHeight = pt->height[level];
+   const uint stride = ct->stride[level];
+
+   if (!ct->mapped) {
+      /* map now */
+      ct->mapped = pipe_buffer_map(screen, ct->buffer,
+                                   PIPE_BUFFER_USAGE_CPU_READ);
+   }
 
-   assert(ct);
+   if (transfer->usage & PIPE_TRANSFER_WRITE) {
+      /* The user wrote new texture data into the mapped buffer.
+       * We need to convert the new linear data into the twiddled/tiled format.
+       */
+      const uint bpp = pf_get_size(ct->base.format);
+      if (bpp == 4) {
+         const uint *src = ctrans->map;
+         uint *dst = (uint *) (ct->mapped + ctrans->offset);
+         twiddle_image_uint(texWidth, texHeight, TILE_SIZE, dst, stride, src);
+      }
+      else {
+         // xxx fix
+      }
+   }
 
-   pipe_buffer_unmap( screen, ct->buffer );
+   align_free(ctrans->map);
+   ctrans->map = NULL;
 }
 
 
-
 void
 cell_init_screen_texture_funcs(struct pipe_screen *screen)
 {
    screen->texture_create = cell_texture_create;
-   screen->texture_release = cell_texture_release;
+   screen->texture_destroy = cell_texture_destroy;
 
    screen->get_tex_surface = cell_get_tex_surface;
-   screen->tex_surface_release = cell_tex_surface_release;
+   screen->tex_surface_destroy = cell_tex_surface_destroy;
+
+   screen->get_tex_transfer = cell_get_tex_transfer;
+   screen->tex_transfer_destroy = cell_tex_transfer_destroy;
 
-   screen->surface_map = cell_surface_map;
-   screen->surface_unmap = cell_surface_unmap;
+   screen->transfer_map = cell_transfer_map;
+   screen->transfer_unmap = cell_transfer_unmap;
 }
diff --git a/src/gallium/drivers/cell/ppu/cell_texture.h b/src/gallium/drivers/cell/ppu/cell_texture.h
index 7018b0c9bf7..3ffc0bfdb51 100644
--- a/src/gallium/drivers/cell/ppu/cell_texture.h
+++ b/src/gallium/drivers/cell/ppu/cell_texture.h
@@ -43,16 +43,23 @@ struct cell_texture
    unsigned long level_offset[CELL_MAX_TEXTURE_LEVELS];
    unsigned long stride[CELL_MAX_TEXTURE_LEVELS];
 
-   /* The data is held here:
-    */
+   /** The tiled texture data is held in this buffer */
    struct pipe_buffer *buffer;
    unsigned long buffer_size;
 
-   /** Texture data in tiled layout is held here */
-   struct pipe_buffer *tiled_buffer[CELL_MAX_TEXTURE_LEVELS];
-   /** Mapped, tiled texture data */
-   void *tiled_mapped[CELL_MAX_TEXTURE_LEVELS];
-   void *untiled_data[CELL_MAX_TEXTURE_LEVELS];
+   /** The buffer above, mapped.  This is the memory from which the
+    * SPUs will fetch texels.  This texture data is in the tiled layout.
+    */
+   ubyte *mapped;
+};
+
+
+struct cell_transfer
+{
+   struct pipe_transfer base;
+
+   unsigned long offset;
+   void *map;
 };
 
 
@@ -64,6 +71,13 @@ cell_texture(struct pipe_texture *pt)
 }
 
 
+/** cast wrapper */
+static INLINE struct cell_transfer *
+cell_transfer(struct pipe_transfer *pt)
+{
+   return (struct cell_transfer *) pt;
+}
+
 
 extern void
 cell_init_screen_texture_funcs(struct pipe_screen *screen);
diff --git a/src/gallium/drivers/cell/ppu/cell_vbuf.c b/src/gallium/drivers/cell/ppu/cell_vbuf.c
index ab54e796895..cfaffb52a85 100644
--- a/src/gallium/drivers/cell/ppu/cell_vbuf.c
+++ b/src/gallium/drivers/cell/ppu/cell_vbuf.c
@@ -62,6 +62,7 @@ struct cell_vbuf_render
    uint vertex_size;     /**< in bytes */
    void *vertex_buffer;  /**< just for debug, really */
    uint vertex_buf;      /**< in [0, CELL_NUM_BUFFERS-1] */
+   uint vertex_buffer_size;  /**< size in bytes */
 };
 
 
@@ -82,24 +83,26 @@ cell_vbuf_get_vertex_info(struct vbuf_render *vbr)
 }
 
 
-static void *
+static boolean
 cell_vbuf_allocate_vertices(struct vbuf_render *vbr,
                             ushort vertex_size, ushort nr_vertices)
 {
    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
+   unsigned size = vertex_size * nr_vertices;
    /*printf("Alloc verts %u * %u\n", vertex_size, nr_vertices);*/
 
    assert(cvbr->vertex_buf == ~0);
    cvbr->vertex_buf = cell_get_empty_buffer(cvbr->cell);
    cvbr->vertex_buffer = cvbr->cell->buffer[cvbr->vertex_buf];
+   cvbr->vertex_buffer_size = size;
    cvbr->vertex_size = vertex_size;
-   return cvbr->vertex_buffer;
+
+   return cvbr->vertex_buffer != NULL;
 }
 
 
 static void
-cell_vbuf_release_vertices(struct vbuf_render *vbr, void *vertices, 
-                           unsigned vertex_size, unsigned vertices_used)
+cell_vbuf_release_vertices(struct vbuf_render *vbr)
 {
    struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
    struct cell_context *cell = cvbr->cell;
@@ -127,11 +130,29 @@ cell_vbuf_release_vertices(struct vbuf_render *vbr, void *vertices,
    cvbr->vertex_buf = ~0;
    cell_flush_int(cell, 0x0);
 
-   assert(vertices == cvbr->vertex_buffer);
    cvbr->vertex_buffer = NULL;
 }
 
 
+static void *
+cell_vbuf_map_vertices(struct vbuf_render *vbr)
+{
+   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
+   return cvbr->vertex_buffer;
+}
+
+
+static void 
+cell_vbuf_unmap_vertices(struct vbuf_render *vbr, 
+                         ushort min_index,
+                         ushort max_index )
+{
+   struct cell_vbuf_render *cvbr = cell_vbuf_render(vbr);
+   assert( cvbr->vertex_buffer_size >= (max_index+1) * cvbr->vertex_size );
+   /* do nothing */
+}
+
+
 
 static boolean
 cell_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
@@ -295,6 +316,8 @@ cell_init_vbuf(struct cell_context *cell)
 
    cell->vbuf_render->base.get_vertex_info = cell_vbuf_get_vertex_info;
    cell->vbuf_render->base.allocate_vertices = cell_vbuf_allocate_vertices;
+   cell->vbuf_render->base.map_vertices = cell_vbuf_map_vertices;
+   cell->vbuf_render->base.unmap_vertices = cell_vbuf_unmap_vertices;
    cell->vbuf_render->base.set_primitive = cell_vbuf_set_primitive;
    cell->vbuf_render->base.draw = cell_vbuf_draw;
    cell->vbuf_render->base.release_vertices = cell_vbuf_release_vertices;
diff --git a/src/gallium/drivers/cell/spu/Makefile b/src/gallium/drivers/cell/spu/Makefile
index 116453b79c5..3cc52301da2 100644
--- a/src/gallium/drivers/cell/spu/Makefile
+++ b/src/gallium/drivers/cell/spu/Makefile
@@ -33,9 +33,10 @@ OLD_SOURCES = \
 	spu_vertex_shader.c
 
 
-SPU_OBJECTS = $(SOURCES:.c=.o) \
+SPU_OBJECTS = $(SOURCES:.c=.o)
+
+SPU_ASM_OUT = $(SOURCES:.c=.s)
 
-SPU_ASM_OUT = $(SOURCES:.c=.s) \
 
 INCLUDE_DIRS = \
 	-I$(TOP)/src/mesa \
diff --git a/src/gallium/drivers/cell/spu/spu_tri.c b/src/gallium/drivers/cell/spu/spu_tri.c
index 0d9fcb99970..d727268475e 100644
--- a/src/gallium/drivers/cell/spu/spu_tri.c
+++ b/src/gallium/drivers/cell/spu/spu_tri.c
@@ -29,7 +29,6 @@
  * Triangle rendering within a tile.
  */
 
-#include <transpose_matrix4x4.h>
 #include "pipe/p_compiler.h"
 #include "pipe/p_format.h"
 #include "util/u_math.h"
@@ -71,6 +70,12 @@ struct vertex_header {
 #define MASK_ALL          0xf
 
 
+#define CHAN0 0
+#define CHAN1 1
+#define CHAN2 2
+#define CHAN3 3
+
+
 #define DEBUG_VERTS 0
 
 /**
@@ -144,99 +149,97 @@ struct setup_stage {
 static struct setup_stage setup;
 
 
-/**
- * Evaluate attribute coefficients (plane equations) to compute
- * attribute values for the four fragments in a quad.
- * Eg: four colors will be computed (in AoS format).
- */
-static INLINE void
-eval_coeff(uint slot, float x, float y, vector float w, vector float result[4])
+static INLINE vector float
+splatx(vector float v)
 {
-   switch (spu.vertex_info.attrib[slot].interp_mode) {
-   case INTERP_CONSTANT:
-      result[QUAD_TOP_LEFT] =
-      result[QUAD_TOP_RIGHT] =
-      result[QUAD_BOTTOM_LEFT] =
-      result[QUAD_BOTTOM_RIGHT] = setup.coef[slot].a0;
-      break;
-   case INTERP_LINEAR:
-      {
-         vector float dadx = setup.coef[slot].dadx;
-         vector float dady = setup.coef[slot].dady;
-         vector float topLeft =
-            spu_add(setup.coef[slot].a0,
-                    spu_add(spu_mul(spu_splats(x), dadx),
-                            spu_mul(spu_splats(y), dady)));
-
-         result[QUAD_TOP_LEFT] = topLeft;
-         result[QUAD_TOP_RIGHT] = spu_add(topLeft, dadx);
-         result[QUAD_BOTTOM_LEFT] = spu_add(topLeft, dady);
-         result[QUAD_BOTTOM_RIGHT] = spu_add(spu_add(topLeft, dadx), dady);
-      }
-      break;
-   case INTERP_PERSPECTIVE:
-      {
-         vector float dadx = setup.coef[slot].dadx;
-         vector float dady = setup.coef[slot].dady;
-         vector float topLeft =
-            spu_add(setup.coef[slot].a0,
-                    spu_add(spu_mul(spu_splats(x), dadx),
-                            spu_mul(spu_splats(y), dady)));
-
-         vector float wInv = spu_re(w);  /* 1.0 / w */
-
-         result[QUAD_TOP_LEFT] = spu_mul(topLeft, wInv);
-         result[QUAD_TOP_RIGHT] = spu_mul(spu_add(topLeft, dadx), wInv);
-         result[QUAD_BOTTOM_LEFT] = spu_mul(spu_add(topLeft, dady), wInv);
-         result[QUAD_BOTTOM_RIGHT] = spu_mul(spu_add(spu_add(topLeft, dadx), dady), wInv);
-      }
-      break;
-   case INTERP_POS:
-   case INTERP_NONE:
-      break;
-   default:
-      ASSERT(0);
-   }
+   return spu_splats(spu_extract(v, CHAN0));
 }
 
-
-/**
- * As above, but return 4 vectors in SOA format.
- * XXX this will all be re-written someday.
- */
-static INLINE void
-eval_coeff_soa(uint slot, float x, float y, vector float w, vector float result[4])
+static INLINE vector float
+splaty(vector float v)
 {
-   eval_coeff(slot, x, y, w, result);
-   _transpose_matrix4x4(result, result);
+   return spu_splats(spu_extract(v, CHAN1));
 }
 
+static INLINE vector float
+splatz(vector float v)
+{
+   return spu_splats(spu_extract(v, CHAN2));
+}
 
-/** Evalute coefficients to get Z for four pixels in a quad */
 static INLINE vector float
-eval_z(float x, float y)
+splatw(vector float v)
 {
-   const uint slot = 0;
-   const float dzdx = spu_extract(setup.coef[slot].dadx, 2);
-   const float dzdy = spu_extract(setup.coef[slot].dady, 2);
-   const float topLeft = spu_extract(setup.coef[slot].a0, 2) + x * dzdx + y * dzdy;
-   const vector float topLeftv = spu_splats(topLeft);
-   const vector float derivs = (vector float) { 0.0, dzdx, dzdy, dzdx + dzdy };
-   return spu_add(topLeftv, derivs);
+   return spu_splats(spu_extract(v, CHAN3));
 }
 
 
-/** Evalute coefficients to get W for four pixels in a quad */
-static INLINE vector float
-eval_w(float x, float y)
+/**
+ * Setup fragment shader inputs by evaluating triangle's vertex
+ * attribute coefficient info.
+ * \param x  quad x pos
+ * \param y  quad y pos
+ * \param fragZ  returns quad Z values
+ * \param fragInputs  returns fragment program inputs
+ * Note: this code could be incorporated into the fragment program
+ * itself to avoid the loop and switch.
+ */
+static void
+eval_inputs(float x, float y, vector float *fragZ, vector float fragInputs[])
 {
-   const uint slot = 0;
-   const float dwdx = spu_extract(setup.coef[slot].dadx, 3);
-   const float dwdy = spu_extract(setup.coef[slot].dady, 3);
-   const float topLeft = spu_extract(setup.coef[slot].a0, 3) + x * dwdx + y * dwdy;
-   const vector float topLeftv = spu_splats(topLeft);
-   const vector float derivs = (vector float) { 0.0, dwdx, dwdy, dwdx + dwdy };
-   return spu_add(topLeftv, derivs);
+   static const vector float deltaX = (const vector float) {0, 1, 0, 1};
+   static const vector float deltaY = (const vector float) {0, 0, 1, 1};
+
+   const uint posSlot = 0;
+   const vector float pos = setup.coef[posSlot].a0;
+   const vector float dposdx = setup.coef[posSlot].dadx;
+   const vector float dposdy = setup.coef[posSlot].dady;
+   const vector float fragX = spu_splats(x) + deltaX;
+   const vector float fragY = spu_splats(y) + deltaY;
+   vector float fragW, wInv;
+   uint i;
+
+   *fragZ = splatz(pos) + fragX * splatz(dposdx) + fragY * splatz(dposdy);
+   fragW =  splatw(pos) + fragX * splatw(dposdx) + fragY * splatw(dposdy);
+   wInv = spu_re(fragW);  /* 1 / w */
+
+   /* loop over fragment program inputs */
+   for (i = 0; i < spu.vertex_info.num_attribs; i++) {
+      uint attr = i + 1;
+      enum interp_mode interp = spu.vertex_info.attrib[attr].interp_mode;
+
+      /* constant term */
+      vector float a0 = setup.coef[attr].a0;
+      vector float r0 = splatx(a0);
+      vector float r1 = splaty(a0);
+      vector float r2 = splatz(a0);
+      vector float r3 = splatw(a0);
+
+      if (interp == INTERP_LINEAR || interp == INTERP_PERSPECTIVE) {
+         /* linear term */
+         vector float dadx = setup.coef[attr].dadx;
+         vector float dady = setup.coef[attr].dady;
+         /* Use SPU intrinsics here to get slightly better code.
+          * originally: r0 += fragX * splatx(dadx) + fragY * splatx(dady);
+          */
+         r0 = spu_madd(fragX, splatx(dadx), spu_madd(fragY, splatx(dady), r0));
+         r1 = spu_madd(fragX, splaty(dadx), spu_madd(fragY, splaty(dady), r1));
+         r2 = spu_madd(fragX, splatz(dadx), spu_madd(fragY, splatz(dady), r2));
+         r3 = spu_madd(fragX, splatw(dadx), spu_madd(fragY, splatw(dady), r3));
+         if (interp == INTERP_PERSPECTIVE) {
+            /* perspective term */
+            r0 *= wInv;
+            r1 *= wInv;
+            r2 *= wInv;
+            r3 *= wInv;
+         }
+      }
+      fragInputs[CHAN0] = r0;
+      fragInputs[CHAN1] = r1;
+      fragInputs[CHAN2] = r2;
+      fragInputs[CHAN3] = r3;
+      fragInputs += 4;
+   }
 }
 
 
@@ -262,19 +265,11 @@ emit_quad( int x, int y, mask_t mask)
           * Run fragment shader, execute per-fragment ops, update fb/tile.
           */
          vector float inputs[4*4], outputs[2*4];
-         vector float fragZ = eval_z((float) x, (float) y);
-         vector float fragW = eval_w((float) x, (float) y);
          vector unsigned int kill_mask;
+         vector float fragZ;
+
+         eval_inputs((float) x, (float) y, &fragZ, inputs);
 
-         /* setup inputs */
-#if 0
-         eval_coeff_soa(1, (float) x, (float) y, fragW, inputs);
-#else
-         uint i;
-         for (i = 0; i < spu.vertex_info.num_attribs; i++) {
-            eval_coeff_soa(i+1, (float) x, (float) y, fragW, inputs + i * 4);
-         }
-#endif
          ASSERT(spu.fragment_program);
          ASSERT(spu.fragment_ops);
 
diff --git a/src/gallium/drivers/cell/spu/spu_util.c b/src/gallium/drivers/cell/spu/spu_util.c
index b8a0d4a265f..af25dd3718a 100644
--- a/src/gallium/drivers/cell/spu/spu_util.c
+++ b/src/gallium/drivers/cell/spu/spu_util.c
@@ -1,7 +1,7 @@
 
 #include "cell/common.h"
 #include "pipe/p_shader_tokens.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "tgsi/tgsi_parse.h"
 //#include "tgsi_build.h"
 #include "tgsi/tgsi_util.h"
diff --git a/src/gallium/drivers/failover/Makefile b/src/gallium/drivers/failover/Makefile
index f08b8df07a1..dfb7f5dcf60 100644
--- a/src/gallium/drivers/failover/Makefile
+++ b/src/gallium/drivers/failover/Makefile
@@ -9,6 +9,3 @@ C_SOURCES = \
 	fo_context.c 
 
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/failover/fo_context.c b/src/gallium/drivers/failover/fo_context.c
index 0742b27b8fd..fcad717cf83 100644
--- a/src/gallium/drivers/failover/fo_context.c
+++ b/src/gallium/drivers/failover/fo_context.c
@@ -145,7 +145,7 @@ struct pipe_context *failover_create( struct pipe_context *hw,
 
 #if 0
    failover->pipe.texture_create = hw->texture_create;
-   failover->pipe.texture_release = hw->texture_release;
+   failover->pipe.texture_destroy = hw->texture_destroy;
    failover->pipe.get_tex_surface = hw->get_tex_surface;
    failover->pipe.texture_update = hw->texture_update;
 #endif
diff --git a/src/gallium/drivers/failover/fo_state.c b/src/gallium/drivers/failover/fo_state.c
index 6a797066322..c8eb9262994 100644
--- a/src/gallium/drivers/failover/fo_state.c
+++ b/src/gallium/drivers/failover/fo_state.c
@@ -28,8 +28,6 @@
 /* Authors:  Keith Whitwell <[email protected]>
  */
 
-#include "pipe/p_inlines.h"
-
 #include "fo_context.h"
 
 
diff --git a/src/gallium/drivers/i915simple/Makefile b/src/gallium/drivers/i915simple/Makefile
index 41a61a0020b..12821c5a761 100644
--- a/src/gallium/drivers/i915simple/Makefile
+++ b/src/gallium/drivers/i915simple/Makefile
@@ -26,6 +26,3 @@ C_SOURCES = \
 	i915_surface.c 
 
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/i915simple/i915_debug.c b/src/gallium/drivers/i915simple/i915_debug.c
index a300b61c3b9..e08582efaba 100644
--- a/src/gallium/drivers/i915simple/i915_debug.c
+++ b/src/gallium/drivers/i915simple/i915_debug.c
@@ -31,7 +31,7 @@
 #include "i915_debug.h"
 #include "i915_batch.h"
 #include "pipe/internal/p_winsys_screen.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 
 static void
diff --git a/src/gallium/drivers/i915simple/i915_fpc_translate.c b/src/gallium/drivers/i915simple/i915_fpc_translate.c
index d92bdc1bc65..961c1bf2134 100644
--- a/src/gallium/drivers/i915simple/i915_fpc_translate.c
+++ b/src/gallium/drivers/i915simple/i915_fpc_translate.c
@@ -321,16 +321,27 @@ static uint
 translate_tex_src_target(struct i915_fp_compile *p, uint tex)
 {
    switch (tex) {
+   case TGSI_TEXTURE_SHADOW1D:
+      /* fall-through */
    case TGSI_TEXTURE_1D:
       return D0_SAMPLE_TYPE_2D;
+
+   case TGSI_TEXTURE_SHADOW2D:
+      /* fall-through */
    case TGSI_TEXTURE_2D:
       return D0_SAMPLE_TYPE_2D;
+
+   case TGSI_TEXTURE_SHADOWRECT:
+      /* fall-through */
    case TGSI_TEXTURE_RECT:
       return D0_SAMPLE_TYPE_2D;
+
    case TGSI_TEXTURE_3D:
       return D0_SAMPLE_TYPE_VOLUME;
+
    case TGSI_TEXTURE_CUBE:
       return D0_SAMPLE_TYPE_CUBE;
+
    default:
       i915_program_error(p, "TexSrc type");
       return 0;
diff --git a/src/gallium/drivers/i915simple/i915_prim_vbuf.c b/src/gallium/drivers/i915simple/i915_prim_vbuf.c
index f49f6d6ed16..9bdd91f2881 100644
--- a/src/gallium/drivers/i915simple/i915_prim_vbuf.c
+++ b/src/gallium/drivers/i915simple/i915_prim_vbuf.c
@@ -40,7 +40,7 @@
 
 #include "draw/draw_context.h"
 #include "draw/draw_vbuf.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_inlines.h"
 #include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
@@ -62,7 +62,7 @@ struct i915_vbuf_render {
    struct i915_context *i915;   
 
    /** Vertex size in bytes */
-   unsigned vertex_size;
+   size_t vertex_size;
 
    /** Software primitive */
    unsigned prim;
@@ -79,6 +79,7 @@ struct i915_vbuf_render {
    size_t vbo_offset;
    void *vbo_ptr;
    size_t vbo_alloc_size;
+   size_t vbo_max_used;
 };
 
 
@@ -108,7 +109,7 @@ i915_vbuf_render_get_vertex_info( struct vbuf_render *render )
 }
 
 
-static void *
+static boolean
 i915_vbuf_render_allocate_vertices( struct vbuf_render *render,
                                     ushort vertex_size,
                                     ushort nr_vertices )
@@ -124,7 +125,8 @@ i915_vbuf_render_allocate_vertices( struct vbuf_render *render,
    if (i915_render->vbo_size > size + i915_render->vbo_offset && !i915->vbo_flushed) {
    } else {
       i915->vbo_flushed = 0;
-      pipe_buffer_reference(screen, &i915_render->vbo, NULL);
+      if (i915_render->vbo)
+         pipe_buffer_reference(&i915_render->vbo, NULL);
    }
 
    if (!i915_render->vbo) {
@@ -134,19 +136,49 @@ i915_vbuf_render_allocate_vertices( struct vbuf_render *render,
                                             64,
                                             I915_BUFFER_USAGE_LIT_VERTEX,
                                             i915_render->vbo_size);
-      i915_render->vbo_ptr = pipe_buffer_map(screen,
-                                             i915_render->vbo,
-                                             PIPE_BUFFER_USAGE_CPU_WRITE);
-      pipe_buffer_unmap(screen, i915_render->vbo);
+
    }
 
+   i915_render->vertex_size = vertex_size;
    i915->vbo = i915_render->vbo;
    i915->vbo_offset = i915_render->vbo_offset;
    i915->dirty |= I915_NEW_VBO;
 
+   if (!i915_render->vbo)
+      return FALSE;
+   return TRUE;
+}
+
+
+static void *
+i915_vbuf_render_map_vertices( struct vbuf_render *render )
+{
+   struct i915_vbuf_render *i915_render = i915_vbuf_render(render);
+   struct i915_context *i915 = i915_render->i915;
+   struct pipe_screen *screen = i915->pipe.screen;
+
+   if (i915->vbo_flushed)
+      debug_printf("%s bad vbo flush occured stalling on hw\n");
+
+   i915_render->vbo_ptr = pipe_buffer_map(screen,
+                                          i915_render->vbo,
+                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+
    return (unsigned char *)i915_render->vbo_ptr + i915->vbo_offset;
 }
 
+static void
+i915_vbuf_render_unmap_vertices( struct vbuf_render *render,
+                                 ushort min_index,
+                                 ushort max_index )
+{
+   struct i915_vbuf_render *i915_render = i915_vbuf_render(render);
+   struct i915_context *i915 = i915_render->i915;
+   struct pipe_screen *screen = i915->pipe.screen;
+
+   i915_render->vbo_max_used = MAX2(i915_render->vbo_max_used, i915_render->vertex_size * (max_index + 1));
+   pipe_buffer_unmap(screen, i915_render->vbo);
+}
 
 static boolean
 i915_vbuf_render_set_primitive( struct vbuf_render *render, 
@@ -454,18 +486,15 @@ out:
 
 
 static void
-i915_vbuf_render_release_vertices( struct vbuf_render *render,
-			           void *vertices, 
-			           unsigned vertex_size,
-			           unsigned vertices_used )
+i915_vbuf_render_release_vertices( struct vbuf_render *render )
 {
    struct i915_vbuf_render *i915_render = i915_vbuf_render(render);
    struct i915_context *i915 = i915_render->i915;
-   size_t size = (size_t)vertex_size * (size_t)vertices_used;
 
    assert(i915->vbo);
 
-   i915_render->vbo_offset += size;
+   i915_render->vbo_offset += i915_render->vbo_max_used;
+   i915_render->vbo_max_used = 0;
    i915->vbo = NULL;
    i915->dirty |= I915_NEW_VBO;
 }
@@ -499,6 +528,8 @@ i915_vbuf_render_create( struct i915_context *i915 )
 
    i915_render->base.get_vertex_info = i915_vbuf_render_get_vertex_info;
    i915_render->base.allocate_vertices = i915_vbuf_render_allocate_vertices;
+   i915_render->base.map_vertices = i915_vbuf_render_map_vertices;
+   i915_render->base.unmap_vertices = i915_vbuf_render_unmap_vertices;
    i915_render->base.set_primitive = i915_vbuf_render_set_primitive;
    i915_render->base.draw = i915_vbuf_render_draw;
    i915_render->base.draw_arrays = i915_vbuf_render_draw_arrays;
diff --git a/src/gallium/drivers/i915simple/i915_screen.c b/src/gallium/drivers/i915simple/i915_screen.c
index 39e48105b3e..f4aa8e60d81 100644
--- a/src/gallium/drivers/i915simple/i915_screen.c
+++ b/src/gallium/drivers/i915simple/i915_screen.c
@@ -36,6 +36,7 @@
 #include "i915_context.h"
 #include "i915_screen.h"
 #include "i915_texture.h"
+#include "i915_winsys.h"
 
 
 static const char *
@@ -204,17 +205,71 @@ i915_destroy_screen( struct pipe_screen *screen )
 }
 
 
+static struct pipe_transfer*
+i915_get_tex_transfer(struct pipe_screen *screen,
+                      struct pipe_texture *texture,
+                      unsigned face, unsigned level, unsigned zslice,
+                      enum pipe_transfer_usage usage, unsigned x, unsigned y,
+                      unsigned w, unsigned h)
+{
+   struct i915_texture *tex = (struct i915_texture *)texture;
+   struct i915_transfer *trans;
+   unsigned offset;  /* in bytes */
+
+   if (texture->target == PIPE_TEXTURE_CUBE) {
+      offset = tex->image_offset[level][face];
+   }
+   else if (texture->target == PIPE_TEXTURE_3D) {
+      offset = tex->image_offset[level][zslice];
+   }
+   else {
+      offset = tex->image_offset[level][0];
+      assert(face == 0);
+      assert(zslice == 0);
+   }
+
+   trans = CALLOC_STRUCT(i915_transfer);
+   if (trans) {
+      pipe_texture_reference(&trans->base.texture, texture);
+      trans->base.format = trans->base.format;
+      trans->base.width = w;
+      trans->base.height = h;
+      trans->base.block = texture->block;
+      trans->base.nblocksx = texture->nblocksx[level];
+      trans->base.nblocksy = texture->nblocksy[level];
+      trans->base.stride = tex->stride;
+      trans->offset = offset;
+      trans->base.usage = usage;
+   }
+   return &trans->base;
+}
+
+static void
+i915_tex_transfer_destroy(struct pipe_transfer *trans)
+{
+   pipe_texture_reference(&trans->texture, NULL);
+   FREE(trans);
+}
+
 static void *
-i915_surface_map( struct pipe_screen *screen,
-                  struct pipe_surface *surface,
-                  unsigned flags )
+i915_transfer_map( struct pipe_screen *screen,
+                   struct pipe_transfer *transfer )
 {
-   struct i915_texture *tex = (struct i915_texture *)surface->texture;
-   char *map = pipe_buffer_map( screen, tex->buffer, flags );
+   struct i915_texture *tex = (struct i915_texture *)transfer->texture;
+   char *map;
+   unsigned flags = 0;
+
+   if (transfer->usage != PIPE_TRANSFER_WRITE)
+      flags |= PIPE_BUFFER_USAGE_CPU_READ;
+
+   if (transfer->usage != PIPE_TRANSFER_READ)
+      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+
+   map = pipe_buffer_map( screen, tex->buffer, flags );
    if (map == NULL)
       return NULL;
 
-   if (surface->texture &&
+   if (transfer->texture &&
        (flags & PIPE_BUFFER_USAGE_CPU_WRITE)) 
    {
       /* Do something to notify contexts of a texture change.  
@@ -222,14 +277,16 @@ i915_surface_map( struct pipe_screen *screen,
       /* i915_screen(screen)->timestamp++; */
    }
    
-   return map + surface->offset;
+   return map + i915_transfer(transfer)->offset +
+      transfer->y / transfer->block.height * transfer->stride +
+      transfer->x / transfer->block.width * transfer->block.size;
 }
 
 static void
-i915_surface_unmap(struct pipe_screen *screen,
-                   struct pipe_surface *surface)
+i915_transfer_unmap(struct pipe_screen *screen,
+                    struct pipe_transfer *transfer)
 {
-   struct i915_texture *tex = (struct i915_texture *)surface->texture;
+   struct i915_texture *tex = (struct i915_texture *)transfer->texture;
    pipe_buffer_unmap( screen, tex->buffer );
 }
 
@@ -278,8 +335,10 @@ i915_create_screen(struct pipe_winsys *winsys, uint pci_id)
    i915screen->screen.get_param = i915_get_param;
    i915screen->screen.get_paramf = i915_get_paramf;
    i915screen->screen.is_format_supported = i915_is_format_supported;
-   i915screen->screen.surface_map = i915_surface_map;
-   i915screen->screen.surface_unmap = i915_surface_unmap;
+   i915screen->screen.get_tex_transfer = i915_get_tex_transfer;
+   i915screen->screen.tex_transfer_destroy = i915_tex_transfer_destroy;
+   i915screen->screen.transfer_map = i915_transfer_map;
+   i915screen->screen.transfer_unmap = i915_transfer_unmap;
 
    i915_init_screen_texture_functions(&i915screen->screen);
    u_simple_screen_init(&i915screen->screen);
diff --git a/src/gallium/drivers/i915simple/i915_screen.h b/src/gallium/drivers/i915simple/i915_screen.h
index 73b0ff05ce7..5284c325951 100644
--- a/src/gallium/drivers/i915simple/i915_screen.h
+++ b/src/gallium/drivers/i915simple/i915_screen.h
@@ -50,16 +50,29 @@ struct i915_screen
 };
 
 
-/** cast wrapper */
+/**
+ * Subclass of pipe_transfer
+ */
+struct i915_transfer
+{
+   struct pipe_transfer base;
+
+   unsigned offset;
+};
+
+
+/** cast wrappers */
 static INLINE struct i915_screen *
 i915_screen(struct pipe_screen *pscreen)
 {
    return (struct i915_screen *) pscreen;
 }
 
-
-extern struct pipe_screen *
-i915_create_screen(struct pipe_winsys *winsys, uint pci_id);
+static INLINE struct i915_transfer *
+i915_transfer( struct pipe_transfer *transfer )
+{
+   return (struct i915_transfer *)transfer;
+}
 
 
 #ifdef __cplusplus
diff --git a/src/gallium/drivers/i915simple/i915_state_emit.c b/src/gallium/drivers/i915simple/i915_state_emit.c
index 6558cf1c3e5..1e1fb968b47 100644
--- a/src/gallium/drivers/i915simple/i915_state_emit.c
+++ b/src/gallium/drivers/i915simple/i915_state_emit.c
@@ -211,11 +211,9 @@ i915_emit_hardware_state(struct i915_context *i915 )
       struct pipe_surface *depth_surface = i915->framebuffer.zsbuf;
 
       if (cbuf_surface) {
-	 unsigned cpitch = cbuf_surface->stride;
 	 unsigned ctile = BUF_3D_USE_FENCE;
          struct i915_texture *tex = (struct i915_texture *)
                                     cbuf_surface->texture;
-         struct pipe_buffer *buffer = tex->buffer;
          assert(tex);
 
 	 if (tex && tex->tiled) {
@@ -225,7 +223,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
 	 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 
 	 OUT_BATCH(BUF_3D_ID_COLOR_BACK |
-		   BUF_3D_PITCH(cpitch) |  /* pitch in bytes */
+		   BUF_3D_PITCH(tex->stride) |  /* pitch in bytes */
 		   ctile);
 
 	 OUT_RELOC(tex->buffer,
@@ -236,11 +234,9 @@ i915_emit_hardware_state(struct i915_context *i915 )
       /* What happens if no zbuf??
        */
       if (depth_surface) {
-	 unsigned zpitch = depth_surface->stride;
 	 unsigned ztile = BUF_3D_USE_FENCE;
          struct i915_texture *tex = (struct i915_texture *)
                                     depth_surface->texture;
-         struct pipe_buffer *buffer = tex->buffer;
          assert(tex);
 
 	 if (tex && tex->tiled) {
@@ -250,7 +246,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
 	 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 
 	 OUT_BATCH(BUF_3D_ID_DEPTH |
-		   BUF_3D_PITCH(zpitch) |  /* pitch in bytes */
+		   BUF_3D_PITCH(tex->stride) |  /* pitch in bytes */
 		   ztile);
 
 	 OUT_RELOC(tex->buffer,
diff --git a/src/gallium/drivers/i915simple/i915_state_sampler.c b/src/gallium/drivers/i915simple/i915_state_sampler.c
index c09c10601b4..3667ed1afa7 100644
--- a/src/gallium/drivers/i915simple/i915_state_sampler.c
+++ b/src/gallium/drivers/i915simple/i915_state_sampler.c
@@ -116,7 +116,7 @@ static void update_sampler(struct i915_context *i915,
            ws == PIPE_TEX_WRAP_CLAMP_TO_BORDER ||
            wt == PIPE_TEX_WRAP_CLAMP_TO_BORDER || 
            wr == PIPE_TEX_WRAP_CLAMP_TO_BORDER)) {
-         if (i915->strict_conformance) {
+         if (i915->conformance_mode > 0) {
             assert(0);
             /* 	    sampler->fallback = true; */
             /* TODO */
diff --git a/src/gallium/drivers/i915simple/i915_surface.c b/src/gallium/drivers/i915simple/i915_surface.c
index 94e2deaf615..09b2c499b8f 100644
--- a/src/gallium/drivers/i915simple/i915_surface.c
+++ b/src/gallium/drivers/i915simple/i915_surface.c
@@ -41,50 +41,27 @@
  */
 static void
 i915_surface_copy(struct pipe_context *pipe,
-                  boolean do_flip,
 		  struct pipe_surface *dst,
 		  unsigned dstx, unsigned dsty,
 		  struct pipe_surface *src,
 		  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
-   assert( dst != src );
-   assert( dst->block.size == src->block.size );
-   assert( dst->block.width == src->block.height );
-   assert( dst->block.height == src->block.height );
+   struct i915_texture *dst_tex = (struct i915_texture *)dst->texture;
+   struct i915_texture *src_tex = (struct i915_texture *)src->texture;
 
-   if (0) {
-      void *dst_map = pipe->screen->surface_map( pipe->screen,
-                                                 dst,
-                                                 PIPE_BUFFER_USAGE_CPU_WRITE );
-      
-      const void *src_map = pipe->screen->surface_map( pipe->screen,
-                                                       src,
-                                                       PIPE_BUFFER_USAGE_CPU_READ );
-      
-      pipe_copy_rect(dst_map,
-                     &dst->block,
-                     dst->stride,
-                     dstx, dsty,
-                     width, height,
-                     src_map,
-                     do_flip ? -(int) src->stride : src->stride,
-                     srcx, do_flip ? height - 1 - srcy : srcy);
+   assert( dst != src );
+   assert( dst_tex->base.block.size == src_tex->base.block.size );
+   assert( dst_tex->base.block.width == src_tex->base.block.height );
+   assert( dst_tex->base.block.height == src_tex->base.block.height );
+   assert( dst_tex->base.block.width == 1 );
+   assert( dst_tex->base.block.height == 1 );
 
-      pipe->screen->surface_unmap(pipe->screen, src);
-      pipe->screen->surface_unmap(pipe->screen, dst);
-   }
-   else {
-      struct i915_texture *dst_tex = (struct i915_texture *)dst->texture;
-      struct i915_texture *src_tex = (struct i915_texture *)src->texture;
-      assert(dst->block.width == 1);
-      assert(dst->block.height == 1);
-      i915_copy_blit( i915_context(pipe),
-                      do_flip,
-                      dst->block.size,
-		      (unsigned short) src->stride, src_tex->buffer, src->offset,
-		      (unsigned short) dst->stride, dst_tex->buffer, dst->offset,
-		      (short) srcx, (short) srcy, (short) dstx, (short) dsty, (short) width, (short) height );
-   }
+   i915_copy_blit( i915_context(pipe),
+                   FALSE,
+                   dst_tex->base.block.size,
+                   (unsigned short) src_tex->stride, src_tex->buffer, src->offset,
+                   (unsigned short) dst_tex->stride, dst_tex->buffer, dst->offset,
+                   (short) srcx, (short) srcy, (short) dstx, (short) dsty, (short) width, (short) height );
 }
 
 
@@ -94,27 +71,18 @@ i915_surface_fill(struct pipe_context *pipe,
 		  unsigned dstx, unsigned dsty,
 		  unsigned width, unsigned height, unsigned value)
 {
-   if (0) {
-      void *dst_map = pipe->screen->surface_map( pipe->screen,
-                                                 dst,
-                                                 PIPE_BUFFER_USAGE_CPU_WRITE );
+   struct i915_texture *tex = (struct i915_texture *)dst->texture;
 
-      pipe_fill_rect(dst_map, &dst->block, dst->stride, dstx, dsty, width, height, value);
+   assert(tex->base.block.width == 1);
+   assert(tex->base.block.height == 1);
 
-      pipe->screen->surface_unmap(pipe->screen, dst);
-   }
-   else {
-      struct i915_texture *tex = (struct i915_texture *)dst->texture;
-      assert(dst->block.width == 1);
-      assert(dst->block.height == 1);
-      i915_fill_blit( i915_context(pipe),
-		      dst->block.size,
-		      (unsigned short) dst->stride,
-		      tex->buffer, dst->offset,
-		      (short) dstx, (short) dsty,
-		      (short) width, (short) height,
-		      value );
-   }
+   i915_fill_blit( i915_context(pipe),
+                   tex->base.block.size,
+                   (unsigned short) tex->stride,
+                   tex->buffer, dst->offset,
+                   (short) dstx, (short) dsty,
+                   (short) width, (short) height,
+                   value );
 }
 
 
diff --git a/src/gallium/drivers/i915simple/i915_texture.c b/src/gallium/drivers/i915simple/i915_texture.c
index b2ca3a2286b..39aca9f8173 100644
--- a/src/gallium/drivers/i915simple/i915_texture.c
+++ b/src/gallium/drivers/i915simple/i915_texture.c
@@ -42,6 +42,7 @@
 #include "i915_texture.h"
 #include "i915_debug.h"
 #include "i915_screen.h"
+#include "i915_winsys.h"
 
 /*
  * Helper function and arrays
@@ -581,7 +582,6 @@ i915_texture_create(struct pipe_screen *screen,
                     const struct pipe_texture *templat)
 {
    struct i915_screen *i915screen = i915_screen(screen);
-   struct pipe_winsys *ws = screen->winsys;
    struct i915_texture *tex = CALLOC_STRUCT(i915_texture);
    size_t tex_size;
 
@@ -589,7 +589,7 @@ i915_texture_create(struct pipe_screen *screen,
       return NULL;
 
    tex->base = *templat;
-   tex->base.refcount = 1;
+   pipe_reference_init(&tex->base.reference, 1);
    tex->base.screen = screen;
 
    tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
@@ -605,7 +605,7 @@ i915_texture_create(struct pipe_screen *screen,
 
    tex_size = tex->stride * tex->total_nblocksy;
 
-   tex->buffer = ws->buffer_create(ws, 64,
+   tex->buffer = screen->buffer_create(screen, 64,
                                     PIPE_BUFFER_USAGE_PIXEL,
                                     tex_size);
 
@@ -628,33 +628,22 @@ fail:
 
 
 static void
-i915_texture_release(struct pipe_screen *screen,
-                     struct pipe_texture **pt)
+i915_texture_destroy(struct pipe_texture *pt)
 {
-   if (!*pt)
-      return;
+   struct i915_texture *tex = (struct i915_texture *)pt;
+   uint i;
 
    /*
-   DBG("%s %p refcount will be %d\n",
-       __FUNCTION__, (void *) *pt, (*pt)->refcount - 1);
+     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
    */
-   if (--(*pt)->refcount <= 0) {
-      struct i915_texture *tex = (struct i915_texture *)*pt;
-      uint i;
-
-      /*
-      DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
-      */
 
-      pipe_buffer_reference(screen, &tex->buffer, NULL);
+   pipe_buffer_reference(&tex->buffer, NULL);
 
-      for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
-         if (tex->image_offset[i])
-            FREE(tex->image_offset[i]);
+   for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
+      if (tex->image_offset[i])
+         FREE(tex->image_offset[i]);
 
-      FREE(tex);
-   }
-   *pt = NULL;
+   FREE(tex);
 }
 
 static struct pipe_surface *
@@ -681,15 +670,11 @@ i915_get_tex_surface(struct pipe_screen *screen,
 
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
-      ps->refcount = 1;
+      pipe_reference_init(&ps->reference, 1);
       pipe_texture_reference(&ps->texture, pt);
       ps->format = pt->format;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->block = pt->block;
-      ps->nblocksx = pt->nblocksx[level];
-      ps->nblocksy = pt->nblocksy[level];
-      ps->stride = tex->stride;
       ps->offset = offset;
       ps->usage = flags;
       ps->status = PIPE_SURFACE_STATUS_DEFINED;
@@ -718,7 +703,7 @@ i915_texture_blanket(struct pipe_screen * screen,
       return NULL;
 
    tex->base = *base;
-   tex->base.refcount = 1;
+   pipe_reference_init(&tex->base.reference, 1);
    tex->base.screen = screen;
 
    tex->stride = stride[0];
@@ -726,7 +711,7 @@ i915_texture_blanket(struct pipe_screen * screen,
    i915_miptree_set_level_info(tex, 0, 1, base->width[0], base->height[0], 1);
    i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
 
-   pipe_buffer_reference(screen, &tex->buffer, buffer);
+   pipe_buffer_reference(&tex->buffer, buffer);
 
    return &tex->base;
 }
@@ -738,34 +723,43 @@ i915_init_texture_functions(struct i915_context *i915)
 }
 
 static void
-i915_tex_surface_release(struct pipe_screen *screen,
-                         struct pipe_surface **surface)
+i915_tex_surface_destroy(struct pipe_surface *surf)
 {
-   struct pipe_surface *surf = *surface;
-
-   if (--surf->refcount == 0) {
-
-      /* This really should not be possible, but it's actually
-       * happening quite a bit...  Will fix.
-       */
-      if (surf->status == PIPE_SURFACE_STATUS_CLEAR) {
-         debug_printf("XXX destroying a surface with pending clears...\n");
-         assert(0);
-      }
-
-      pipe_texture_reference(&surf->texture, NULL);
-      FREE(surf);
+   /* This really should not be possible, but it's actually
+    * happening quite a bit...  Will fix.
+    */
+   if (surf->status == PIPE_SURFACE_STATUS_CLEAR) {
+      debug_printf("XXX destroying a surface with pending clears...\n");
+      assert(0);
    }
 
-   *surface = NULL;
+   pipe_texture_reference(&surf->texture, NULL);
+   FREE(surf);
 }
 
 void
 i915_init_screen_texture_functions(struct pipe_screen *screen)
 {
    screen->texture_create = i915_texture_create;
-   screen->texture_release = i915_texture_release;
+   screen->texture_destroy = i915_texture_destroy;
    screen->get_tex_surface = i915_get_tex_surface;
    screen->texture_blanket = i915_texture_blanket;
-   screen->tex_surface_release = i915_tex_surface_release;
+   screen->tex_surface_destroy = i915_tex_surface_destroy;
+}
+
+boolean i915_get_texture_buffer( struct pipe_texture *texture,
+                                 struct pipe_buffer **buf,
+                                 unsigned *stride )
+{
+   struct i915_texture *tex = (struct i915_texture *)texture;
+
+   if (!tex)
+      return FALSE;
+
+   pipe_buffer_reference(buf, tex->buffer);
+
+   if (stride)
+      *stride = tex->stride;
+
+   return TRUE;
 }
diff --git a/src/gallium/drivers/i915simple/i915_winsys.h b/src/gallium/drivers/i915simple/i915_winsys.h
index 81904c2a742..ff5b34f193a 100644
--- a/src/gallium/drivers/i915simple/i915_winsys.h
+++ b/src/gallium/drivers/i915simple/i915_winsys.h
@@ -30,7 +30,8 @@
  * This is the interface that i915simple requires any window system
  * hosting it to implement.  This is the only include file in i915simple
  * which is public.
- * 
+ *
+ * This isn't currently true as the winsys needs i915_batchbuffer.h
  */
 
 #ifndef I915_WINSYS_H
@@ -45,10 +46,9 @@ extern "C" {
 #endif
 
    
-/* Pipe drivers are (meant to be!) independent of both GL and the
- * window system.  The window system provides a buffer manager and a
- * set of additional hooks for things like command buffer submission,
- * etc.
+/* Pipe drivers are independent of both GL and the window system.
+ * The window system provides a buffer manager and a set of additional
+ * hooks for things like command buffer submission, etc.
  *
  * There clearly has to be some agreement between the window system
  * driver and the hardware driver about the format of command buffers,
@@ -56,6 +56,7 @@ extern "C" {
  */
 
 struct i915_batchbuffer;
+struct pipe_texture;
 struct pipe_buffer;
 struct pipe_fence_handle;
 struct pipe_winsys;
@@ -64,7 +65,7 @@ struct pipe_screen;
 
 /**
  * Additional winsys interface for i915simple.
- * 
+ *
  * It is an over-simple batchbuffer mechanism.  Will want to improve the
  * performance of this, perhaps based on the cmdstream stuff.  It
  * would be pretty impossible to implement swz on top of this
@@ -110,12 +111,33 @@ struct i915_winsys {
 #define I915_BUFFER_USAGE_LIT_VERTEX  (PIPE_BUFFER_USAGE_CUSTOM << 0)
 
 
-struct pipe_context *i915_create_context( struct pipe_screen *,
-                                          struct pipe_winsys *,
-                                          struct i915_winsys * );
+/**
+ * Create i915 pipe_screen.
+ */
+struct pipe_screen *i915_create_screen( struct pipe_winsys *winsys,
+                                        uint pci_id );
+
+/**
+ * Create a i915 pipe_context.
+ */
+struct pipe_context *i915_create_context( struct pipe_screen *screen,
+                                          struct pipe_winsys *winsys,
+                                          struct i915_winsys *i915 );
+
+/**
+ * Used for the winsys to get the buffer used for a texture
+ * and also the stride used for the texture.
+ *
+ * Buffer is referenced for you so you need to unref after use.
+ *
+ * This is needed for example kms.
+ */
+boolean i915_get_texture_buffer( struct pipe_texture *texture,
+                                 struct pipe_buffer **buf,
+                                 unsigned *stride );
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif 
+#endif
diff --git a/src/gallium/drivers/i965simple/Makefile b/src/gallium/drivers/i965simple/Makefile
index e97146e57ca..19182afa75d 100644
--- a/src/gallium/drivers/i965simple/Makefile
+++ b/src/gallium/drivers/i965simple/Makefile
@@ -50,5 +50,3 @@ C_SOURCES = \
 	brw_wm_surface_state.c
 
 include ../../Makefile.template
-
-symlinks:
diff --git a/src/gallium/drivers/i965simple/brw_eu_debug.c b/src/gallium/drivers/i965simple/brw_eu_debug.c
index 4a94ddefa6a..4adfb0c02f5 100644
--- a/src/gallium/drivers/i965simple/brw_eu_debug.c
+++ b/src/gallium/drivers/i965simple/brw_eu_debug.c
@@ -30,7 +30,7 @@
   */
     
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #include "brw_eu.h"
 
diff --git a/src/gallium/drivers/i965simple/brw_surface.c b/src/gallium/drivers/i965simple/brw_surface.c
index 0a95dce1940..511779dbfa0 100644
--- a/src/gallium/drivers/i965simple/brw_surface.c
+++ b/src/gallium/drivers/i965simple/brw_surface.c
@@ -41,7 +41,6 @@
  */
 static void
 brw_surface_copy(struct pipe_context *pipe,
-                 boolean do_flip,
                  struct pipe_surface *dst,
                  unsigned dstx, unsigned dsty,
                  struct pipe_surface *src,
@@ -64,11 +63,11 @@ brw_surface_copy(struct pipe_context *pipe,
       pipe_copy_rect(dst_map,
                      &dst->block,
                      dst->stride,
-                     dstx, dsty, 
-                     width, height, 
-                     src_map, 
-                     do_flip ? -(int) src->stride : src->stride, 
-                     srcx, do_flip ? height - 1 - srcy : srcy);
+                     dstx, dsty,
+                     width, height,
+                     src_map,
+                     src->stride,
+                     srcx, srcy);
 
       pipe->screen->surface_unmap(pipe->screen, src);
       pipe->screen->surface_unmap(pipe->screen, dst);
@@ -79,7 +78,7 @@ brw_surface_copy(struct pipe_context *pipe,
       assert(dst->block.width == 1);
       assert(dst->block.height == 1);
       brw_copy_blit(brw_context(pipe),
-                    do_flip,
+                    FALSE,
                     dst->block.size,
                     (short) src->stride/src->block.size, src_tex->buffer, src->offset, FALSE,
                     (short) dst->stride/dst->block.size, dst_tex->buffer, dst->offset, FALSE,
diff --git a/src/gallium/drivers/i965simple/brw_tex_layout.c b/src/gallium/drivers/i965simple/brw_tex_layout.c
index 448229ed4ee..c921c0d38be 100644
--- a/src/gallium/drivers/i965simple/brw_tex_layout.c
+++ b/src/gallium/drivers/i965simple/brw_tex_layout.c
@@ -284,18 +284,17 @@ static struct pipe_texture *
 brw_texture_create_screen(struct pipe_screen *screen,
                           const struct pipe_texture *templat)
 {
-   struct pipe_winsys *ws = screen->winsys;
    struct brw_texture *tex = CALLOC_STRUCT(brw_texture);
 
    if (tex) {
       tex->base = *templat;
-      tex->base.refcount = 1;
+      pipe_reference_init(&tex->base.reference, 1);
 
       tex->base.nblocksx[0] = pf_get_nblocksx(&tex->base.block, tex->base.width[0]);
       tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
    
       if (brw_miptree_layout(tex))
-	 tex->buffer = ws->buffer_create(ws, 64,
+	 tex->buffer = screen->buffer_create(screen, 64,
                                           PIPE_BUFFER_USAGE_PIXEL,
                                           tex->stride *
                                           tex->total_nblocksy);
@@ -311,33 +310,22 @@ brw_texture_create_screen(struct pipe_screen *screen,
 
 
 static void
-brw_texture_release_screen(struct pipe_screen *screen,
-                           struct pipe_texture **pt)
+brw_texture_destroy_screen(struct pipe_texture *pt)
 {
-   if (!*pt)
-      return;
+   struct brw_texture *tex = (struct brw_texture *)pt;
+   uint i;
 
    /*
-   DBG("%s %p refcount will be %d\n",
-       __FUNCTION__, (void *) *pt, (*pt)->refcount - 1);
+     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
    */
-   if (--(*pt)->refcount <= 0) {
-      struct brw_texture *tex = (struct brw_texture *)*pt;
-      uint i;
-
-      /*
-      DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
-      */
 
-      pipe_buffer_reference(screen, &tex->buffer, NULL);
+   pipe_buffer_reference(&tex->buffer, NULL);
 
-      for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
-         if (tex->image_offset[i])
-            free(tex->image_offset[i]);
+   for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
+      if (tex->image_offset[i])
+         free(tex->image_offset[i]);
 
-      free(tex);
-   }
-   *pt = NULL;
+   free(tex);
 }
 
 
@@ -365,7 +353,7 @@ brw_get_tex_surface_screen(struct pipe_screen *screen,
 
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
-      ps->refcount = 1;
+      pipe_reference_init(&ps->reference, 1);
       pipe_texture_reference(&ps->texture, pt);
       ps->format = pt->format;
       ps->width = pt->width[level];
@@ -392,7 +380,7 @@ void
 brw_init_screen_texture_funcs(struct pipe_screen *screen)
 {
    screen->texture_create  = brw_texture_create_screen;
-   screen->texture_release = brw_texture_release_screen;
+   screen->texture_destroy = brw_texture_destroy_screen;
    screen->get_tex_surface = brw_get_tex_surface_screen;
 }
 
diff --git a/src/gallium/drivers/i965simple/brw_wm_surface_state.c b/src/gallium/drivers/i965simple/brw_wm_surface_state.c
index 1bab5bfdb3a..b5b9e0e7026 100644
--- a/src/gallium/drivers/i965simple/brw_wm_surface_state.c
+++ b/src/gallium/drivers/i965simple/brw_wm_surface_state.c
@@ -242,7 +242,7 @@ static void upload_wm_surfaces(struct brw_context *brw )
       const struct brw_texture *texUnit = brw->attribs.Texture[i];
 
       if (texUnit &&
-	  texUnit->base.refcount/*(texUnit->refcount > 0) == really used */) {
+	  texUnit->base.reference.count/*(texUnit->reference.count > 0) == really used */) {
 
 	 brw_update_texture_surface(brw, i);
 
diff --git a/src/gallium/drivers/nouveau/nouveau_stateobj.h b/src/gallium/drivers/nouveau/nouveau_stateobj.h
index 4ae4ff49404..97859110b5f 100644
--- a/src/gallium/drivers/nouveau/nouveau_stateobj.h
+++ b/src/gallium/drivers/nouveau/nouveau_stateobj.h
@@ -1,7 +1,7 @@
 #ifndef __NOUVEAU_STATEOBJ_H__
 #define __NOUVEAU_STATEOBJ_H__
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 struct nouveau_stateobj_reloc {
 	struct pipe_buffer *bo;
@@ -16,7 +16,7 @@ struct nouveau_stateobj_reloc {
 };
 
 struct nouveau_stateobj {
-	int refcount;
+	struct pipe_reference reference;
 
 	unsigned *push;
 	struct nouveau_stateobj_reloc *reloc;
@@ -32,7 +32,7 @@ so_new(unsigned push, unsigned reloc)
 	struct nouveau_stateobj *so;
 
 	so = MALLOC(sizeof(struct nouveau_stateobj));
-	so->refcount = 0;
+	pipe_reference_init(&so->reference, 1);
 	so->push = MALLOC(sizeof(unsigned) * push);
 	so->reloc = MALLOC(sizeof(struct nouveau_stateobj_reloc) * reloc);
 
@@ -47,17 +47,11 @@ so_ref(struct nouveau_stateobj *ref, struct nouveau_stateobj **pso)
 {
 	struct nouveau_stateobj *so = *pso;
 
-	if (ref) {
-		ref->refcount++;
-	}
-
-	if (so && --so->refcount <= 0) {
+        if (pipe_reference((struct pipe_reference**)pso, &ref->reference)) {
 		free(so->push);
 		free(so->reloc);
 		free(so);
 	}
-
-	*pso = ref;
 }
 
 static INLINE void
diff --git a/src/gallium/drivers/nouveau/nouveau_winsys.h b/src/gallium/drivers/nouveau/nouveau_winsys.h
index b86c4b93388..ff7dd1c51c8 100644
--- a/src/gallium/drivers/nouveau/nouveau_winsys.h
+++ b/src/gallium/drivers/nouveau/nouveau_winsys.h
@@ -19,11 +19,12 @@
 
 #define NOUVEAU_TEXTURE_USAGE_LINEAR (1 << 16)
 
-#define NOUVEAU_BUFFER_USAGE_TEXTURE (1 << 16)
-#define NOUVEAU_BUFFER_USAGE_ZETA    (1 << 17)
+#define NOUVEAU_BUFFER_USAGE_TEXTURE  (1 << 16)
+#define NOUVEAU_BUFFER_USAGE_ZETA     (1 << 17)
+#define NOUVEAU_BUFFER_USAGE_TRANSFER (1 << 18)
 
 struct nouveau_winsys {
-	struct nouveau_context *nv;
+	struct pipe_winsys *ws;
 
 	struct nouveau_channel *channel;
 
diff --git a/src/gallium/drivers/nv04/Makefile b/src/gallium/drivers/nv04/Makefile
index 4ed62dae95d..7c14bacb1de 100644
--- a/src/gallium/drivers/nv04/Makefile
+++ b/src/gallium/drivers/nv04/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv04
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv04_surface_2d.c \
 	nv04_clear.c \
 	nv04_context.c \
@@ -15,15 +15,7 @@ DRIVER_SOURCES = \
 	nv04_state.c \
 	nv04_state_emit.c \
 	nv04_surface.c \
+	nv04_transfer.c \
 	nv04_vbo.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv04/nv04_miptree.c b/src/gallium/drivers/nv04/nv04_miptree.c
index 993c5ef5dd2..85dc017fbc4 100644
--- a/src/gallium/drivers/nv04/nv04_miptree.c
+++ b/src/gallium/drivers/nv04/nv04_miptree.c
@@ -41,23 +41,20 @@ nv04_miptree_layout(struct nv04_miptree *nv04mt)
 static struct pipe_texture *
 nv04_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 {
-	struct pipe_winsys *ws = pscreen->winsys;
 	struct nv04_miptree *mt;
 
 	mt = MALLOC(sizeof(struct nv04_miptree));
 	if (!mt)
 		return NULL;
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
-	mt->shadow_tex = NULL;
-	mt->shadow_surface = NULL;
 
 	//mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 
 	nv04_miptree_layout(mt);
 
-	mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL |
+	mt->buffer = pscreen->buffer_create(pscreen, 256, PIPE_BUFFER_USAGE_PIXEL |
 						NOUVEAU_BUFFER_USAGE_TEXTURE,
 						mt->total_size);
 	if (!mt->buffer) {
@@ -85,38 +82,27 @@ nv04_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->level[0].pitch = stride[0];
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
 static void
-nv04_miptree_release(struct pipe_screen *pscreen, struct pipe_texture **ppt)
+nv04_miptree_destroy(struct pipe_texture *pt)
 {
-	struct pipe_texture *pt = *ppt;
 	struct nv04_miptree *mt = (struct nv04_miptree *)pt;
 	int l;
 
-	*ppt = NULL;
-	if (--pt->refcount)
-		return;
-
-	pipe_buffer_reference(pscreen, &mt->buffer, NULL);
+	pipe_buffer_reference(&mt->buffer, NULL);
 	for (l = 0; l <= pt->last_level; l++) {
 		if (mt->level[l].image_offset)
 			FREE(mt->level[l].image_offset);
 	}
 
-	if (mt->shadow_tex) {
-		assert(mt->shadow_surface);
-		pscreen->tex_surface_release(pscreen, &mt->shadow_surface);
-		nv04_miptree_release(pscreen, &mt->shadow_tex);
-	}
-
 	FREE(mt);
 }
 
@@ -126,41 +112,31 @@ nv04_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 			 unsigned flags)
 {
 	struct nv04_miptree *nv04mt = (struct nv04_miptree *)pt;
-	struct pipe_surface *ps;
+	struct nv04_surface *ns;
 
-	ps = CALLOC_STRUCT(pipe_surface);
-	if (!ps)
+	ns = CALLOC_STRUCT(nv04_surface);
+	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
-	ps->format = pt->format;
-	ps->width = pt->width[level];
-	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = nv04mt->level[level].pitch;
-	ps->usage = flags;
-	ps->status = PIPE_SURFACE_STATUS_DEFINED;
-	ps->refcount = 1;
-	ps->face = face;
-	ps->level = level;
-	ps->zslice = zslice;
-
-	ps->offset = nv04mt->level[level].image_offset;
-
-	return ps;
+	pipe_texture_reference(&ns->base.texture, pt);
+	ns->base.format = pt->format;
+	ns->base.width = pt->width[level];
+	ns->base.height = pt->height[level];
+	ns->base.usage = flags;
+	ns->base.status = PIPE_SURFACE_STATUS_DEFINED;
+	pipe_reference_init(&ns->base.reference, 1);
+	ns->base.face = face;
+	ns->base.level = level;
+	ns->base.zslice = zslice;
+	ns->pitch = nv04mt->level[level].pitch;
+
+	ns->base.offset = nv04mt->level[level].image_offset;
+
+	return &ns->base;
 }
 
 static void
-nv04_miptree_surface_del(struct pipe_screen *pscreen,
-			 struct pipe_surface **psurface)
+nv04_miptree_surface_del(struct pipe_surface *ps)
 {
-	struct pipe_surface *ps = *psurface;
-
-	*psurface = NULL;
-	if (--ps->refcount > 0)
-		return;
-
 	pipe_texture_reference(&ps->texture, NULL);
 	FREE(ps);
 }
@@ -170,8 +146,8 @@ nv04_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv04_miptree_create;
 	pscreen->texture_blanket = nv04_miptree_blanket;
-	pscreen->texture_release = nv04_miptree_release;
+	pscreen->texture_destroy = nv04_miptree_destroy;
 	pscreen->get_tex_surface = nv04_miptree_surface_new;
-	pscreen->tex_surface_release = nv04_miptree_surface_del;
+	pscreen->tex_surface_destroy = nv04_miptree_surface_del;
 }
 
diff --git a/src/gallium/drivers/nv04/nv04_prim_vbuf.c b/src/gallium/drivers/nv04/nv04_prim_vbuf.c
index 18a8872ae38..f6458232ae5 100644
--- a/src/gallium/drivers/nv04/nv04_prim_vbuf.c
+++ b/src/gallium/drivers/nv04/nv04_prim_vbuf.c
@@ -1,5 +1,5 @@
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_inlines.h"
 #include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_compiler.h"
@@ -51,7 +51,7 @@ nv04_vbuf_render_get_vertex_info( struct vbuf_render *render )
 }
 
 
-static void *
+static boolean
 nv04_vbuf_render_allocate_vertices( struct vbuf_render *render,
 		ushort vertex_size,
 		ushort nr_vertices )
@@ -61,9 +61,22 @@ nv04_vbuf_render_allocate_vertices( struct vbuf_render *render,
 	nv04_render->buffer = (unsigned char*) MALLOC(VERTEX_BUFFER_SIZE);
 	assert(!nv04_render->buffer);
 
+	return nv04_render->buffer ? TRUE : FALSE;
+}
+
+static void *
+nv04_vbuf_render_map_vertices( struct vbuf_render *render )
+{
+	struct nv04_vbuf_render *nv04_render = nv04_vbuf_render(render);
 	return nv04_render->buffer;
 }
 
+static void
+nv04_vbuf_render_unmap_vertices( struct vbuf_render *render,
+		ushort min_index,
+		ushort max_index )
+{
+}
 
 static boolean 
 nv04_vbuf_render_set_primitive( struct vbuf_render *render, 
@@ -244,10 +257,7 @@ nv04_vbuf_render_draw( struct vbuf_render *render,
 
 
 static void
-nv04_vbuf_render_release_vertices( struct vbuf_render *render,
-		void *vertices, 
-		unsigned vertex_size,
-		unsigned vertices_used )
+nv04_vbuf_render_release_vertices( struct vbuf_render *render )
 {
 	struct nv04_vbuf_render *nv04_render = nv04_vbuf_render(render);
 
@@ -278,6 +288,8 @@ nv04_vbuf_render_create( struct nv04_context *nv04 )
 	nv04_render->base.max_indices = 65536; 
 	nv04_render->base.get_vertex_info = nv04_vbuf_render_get_vertex_info;
 	nv04_render->base.allocate_vertices = nv04_vbuf_render_allocate_vertices;
+	nv04_render->base.map_vertices = nv04_vbuf_render_map_vertices;
+	nv04_render->base.unmap_vertices = nv04_vbuf_render_unmap_vertices;
 	nv04_render->base.set_primitive = nv04_vbuf_render_set_primitive;
 	nv04_render->base.draw = nv04_vbuf_render_draw;
 	nv04_render->base.release_vertices = nv04_vbuf_render_release_vertices;
diff --git a/src/gallium/drivers/nv04/nv04_screen.c b/src/gallium/drivers/nv04/nv04_screen.c
index 9ef38bc244c..f9f6d974264 100644
--- a/src/gallium/drivers/nv04/nv04_screen.c
+++ b/src/gallium/drivers/nv04/nv04_screen.c
@@ -119,28 +119,6 @@ nv04_screen_is_format_supported(struct pipe_screen *screen,
 	return FALSE;
 }
 
-static void *
-nv04_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
-		 unsigned flags )
-{
-	void *map;
-	struct nv04_miptree *nv04mt = (struct nv04_miptree *)surface->texture;
-
-	map = pipe_buffer_map(screen, nv04mt->buffer, flags);
-	if (!map)
-		return NULL;
-
-	return map + surface->offset;
-}
-
-static void
-nv04_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
-{
-	struct nv04_miptree *nv04mt = (struct nv04_miptree *)surface->texture;
-
-	pipe_buffer_unmap(screen, nv04mt->buffer);
-}
-
 static void
 nv04_screen_destroy(struct pipe_screen *pscreen)
 {
@@ -226,10 +204,8 @@ nv04_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 
 	screen->pipe.is_format_supported = nv04_screen_is_format_supported;
 
-	screen->pipe.surface_map = nv04_surface_map;
-	screen->pipe.surface_unmap = nv04_surface_unmap;
-
 	nv04_screen_init_miptree_functions(&screen->pipe);
+	nv04_screen_init_transfer_functions(&screen->pipe);
 	u_simple_screen_init(&screen->pipe);
 
 	return &screen->pipe;
diff --git a/src/gallium/drivers/nv04/nv04_screen.h b/src/gallium/drivers/nv04/nv04_screen.h
index 540aec907bf..ee6fb6db44a 100644
--- a/src/gallium/drivers/nv04/nv04_screen.h
+++ b/src/gallium/drivers/nv04/nv04_screen.h
@@ -24,4 +24,7 @@ nv04_screen(struct pipe_screen *screen)
 	return (struct nv04_screen *)screen;
 }
 
+void
+nv04_screen_init_transfer_functions(struct pipe_screen *pscreen);
+
 #endif
diff --git a/src/gallium/drivers/nv04/nv04_state.h b/src/gallium/drivers/nv04/nv04_state.h
index 15d4685ec1a..0d51439e3ff 100644
--- a/src/gallium/drivers/nv04/nv04_state.h
+++ b/src/gallium/drivers/nv04/nv04_state.h
@@ -35,9 +35,6 @@ struct nv04_miptree {
 	struct pipe_buffer *buffer;
 	uint total_size;
 
-	struct pipe_texture *shadow_tex;
-	struct pipe_surface *shadow_surface;
-
 	struct {
 		uint pitch;
 		uint image_offset;
diff --git a/src/gallium/drivers/nv04/nv04_state_emit.c b/src/gallium/drivers/nv04/nv04_state_emit.c
index bd8ef1adbff..eb2c1c57c67 100644
--- a/src/gallium/drivers/nv04/nv04_state_emit.c
+++ b/src/gallium/drivers/nv04/nv04_state_emit.c
@@ -93,7 +93,7 @@ static void nv04_emit_sampler(struct nv04_context *nv04, int unit)
 static void nv04_state_emit_framebuffer(struct nv04_context* nv04)
 {
 	struct pipe_framebuffer_state* fb = nv04->framebuffer;
-	struct pipe_surface *rt, *zeta;
+	struct nv04_surface *rt, *zeta;
 	uint32_t rt_format, w, h;
 	int colour_format = 0, zeta_format = 0;
 	struct nv04_miptree *nv04mt = 0;
@@ -101,7 +101,7 @@ static void nv04_state_emit_framebuffer(struct nv04_context* nv04)
 	w = fb->cbufs[0]->width;
 	h = fb->cbufs[0]->height;
 	colour_format = fb->cbufs[0]->format;
-	rt = fb->cbufs[0];
+	rt = (struct nv04_surface *)fb->cbufs[0];
 
 	if (fb->zsbuf) {
 		if (colour_format) {
@@ -113,7 +113,7 @@ static void nv04_state_emit_framebuffer(struct nv04_context* nv04)
 		}
 
 		zeta_format = fb->zsbuf->format;
-		zeta = fb->zsbuf;
+		zeta = (struct nv04_surface *)fb->zsbuf;
 	}
 
 	switch (colour_format) {
@@ -131,13 +131,13 @@ static void nv04_state_emit_framebuffer(struct nv04_context* nv04)
 	BEGIN_RING(context_surfaces_3d, NV04_CONTEXT_SURFACES_3D_FORMAT, 1);
 	OUT_RING(rt_format);
 
-	nv04mt = (struct nv04_miptree *)rt->texture;
+	nv04mt = (struct nv04_miptree *)rt->base.texture;
 	/* FIXME pitches have to be aligned ! */
 	BEGIN_RING(context_surfaces_3d, NV04_CONTEXT_SURFACES_3D_PITCH, 2);
-	OUT_RING(rt->stride|(zeta->stride<<16));
+	OUT_RING(rt->pitch|(zeta->pitch<<16));
 	OUT_RELOCl(nv04mt->buffer, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	if (fb->zsbuf) {
-		nv04mt = (struct nv04_miptree *)zeta->texture;
+		nv04mt = (struct nv04_miptree *)zeta->base.texture;
 		BEGIN_RING(context_surfaces_3d, NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA, 1);
 		OUT_RELOCl(nv04mt->buffer, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	}
@@ -202,8 +202,11 @@ nv04_emit_hw_state(struct nv04_context *nv04)
 	 */
 
 	/* Render target */
+	unsigned rt_pitch = ((struct nv04_surface *)nv04->rt)->pitch;
+	unsigned zeta_pitch = ((struct nv04_surface *)nv04->zeta)->pitch;
+
 	BEGIN_RING(context_surfaces_3d, NV04_CONTEXT_SURFACES_3D_PITCH, 2);
-	OUT_RING(nv04->rt->stride|(nv04->zeta->stride<<16));
+	OUT_RING(rt_pitch|(zeta_pitch<<16));
 	OUT_RELOCl(nv04->rt, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	if (nv04->zeta) {
 		BEGIN_RING(context_surfaces_3d, NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA, 1);
diff --git a/src/gallium/drivers/nv04/nv04_surface.c b/src/gallium/drivers/nv04/nv04_surface.c
index 14abf166798..0387ff4e78b 100644
--- a/src/gallium/drivers/nv04/nv04_surface.c
+++ b/src/gallium/drivers/nv04/nv04_surface.c
@@ -33,7 +33,7 @@
 #include "util/u_tile.h"
 
 static void
-nv04_surface_copy(struct pipe_context *pipe, boolean do_flip,
+nv04_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -41,15 +41,6 @@ nv04_surface_copy(struct pipe_context *pipe, boolean do_flip,
 	struct nv04_context *nv04 = nv04_context(pipe);
 	struct nv04_surface_2d *eng2d = nv04->screen->eng2d;
 
-	if (do_flip) {
-		desty += height;
-		while (height--) {
-			eng2d->copy(eng2d, dest, destx, desty--, src,
-				    srcx, srcy++, width, 1);
-		}
-		return;
-	}
-
 	eng2d->copy(eng2d, dest, destx, desty, src, srcx, srcy, width, height);
 }
 
diff --git a/src/gallium/drivers/nv04/nv04_surface_2d.c b/src/gallium/drivers/nv04/nv04_surface_2d.c
index 230cfd17dd9..f3a8d7efeed 100644
--- a/src/gallium/drivers/nv04/nv04_surface_2d.c
+++ b/src/gallium/drivers/nv04/nv04_surface_2d.c
@@ -101,6 +101,7 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 	struct nouveau_grobj *sifm = ctx->sifm;
 	struct nouveau_bo *src_bo = ctx->nvws->get_bo(ctx->buf(src));
 	struct nouveau_bo *dst_bo = ctx->nvws->get_bo(ctx->buf(dst));
+	const unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
 	const unsigned max_w = 1024;
 	const unsigned max_h = 1024;
 	const unsigned sub_w = w > max_w ? max_w : w;
@@ -110,6 +111,8 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 
 	/* POT or GTFO */
 	assert(!(w & (w - 1)) && !(h & (h - 1)));
+	/* That's the way she likes it */
+	assert(src_pitch == ((struct nv04_surface *)dst)->pitch);
 
 	BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_DMA_IMAGE, 1);
 	OUT_RELOCo(chan, dst_bo,
@@ -130,7 +133,7 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 	  for (cx = 0; cx < w; cx += sub_w) {
 	    BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_OFFSET, 1);
 	    OUT_RELOCl(chan, dst_bo, dst->offset + nv04_swizzle_bits(cx, cy) *
-			     dst->block.size, NOUVEAU_BO_GART |
+			     dst->texture->block.size, NOUVEAU_BO_GART |
 			     NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 
 	    BEGIN_RING(chan, sifm, NV04_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 9);
@@ -146,11 +149,11 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 
 	    BEGIN_RING(chan, sifm, NV04_SCALED_IMAGE_FROM_MEMORY_SIZE, 4);
 	    OUT_RING  (chan, sub_h << 16 | sub_w);
-	    OUT_RING  (chan, src->stride |
+	    OUT_RING  (chan, src_pitch |
 			     NV04_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER |
 			     NV04_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE);
-	    OUT_RELOCl(chan, src_bo, src->offset + cy * src->stride +
-			     cx * src->block.size, NOUVEAU_BO_GART |
+	    OUT_RELOCl(chan, src_bo, src->offset + cy * src_pitch +
+			     cx * src->texture->block.size, NOUVEAU_BO_GART |
 			     NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
 	    OUT_RING  (chan, 0);
 	  }
@@ -168,10 +171,12 @@ nv04_surface_copy_m2mf(struct nv04_surface_2d *ctx,
 	struct nouveau_grobj *m2mf = ctx->m2mf;
 	struct nouveau_bo *src_bo = ctx->nvws->get_bo(ctx->buf(src));
 	struct nouveau_bo *dst_bo = ctx->nvws->get_bo(ctx->buf(dst));
-	unsigned dst_offset, src_offset;
-
-	dst_offset = dst->offset + (dy * dst->stride) + (dx * dst->block.size);
-	src_offset = src->offset + (sy * src->stride) + (sx * src->block.size);
+	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
+	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
+	unsigned dst_offset = dst->offset + dy * dst_pitch +
+	                      dx * dst->texture->block.size;
+	unsigned src_offset = src->offset + sy * src_pitch +
+	                      sx * src->texture->block.size;
 
 	WAIT_RING (chan, 3 + ((h / 2047) + 1) * 9);
 	BEGIN_RING(chan, m2mf, NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN, 2);
@@ -188,16 +193,16 @@ nv04_surface_copy_m2mf(struct nv04_surface_2d *ctx,
 			   NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD);
 		OUT_RELOCl(chan, dst_bo, dst_offset,
 			   NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_WR);
-		OUT_RING  (chan, src->stride);
-		OUT_RING  (chan, dst->stride);
-		OUT_RING  (chan, w * src->block.size);
+		OUT_RING  (chan, src_pitch);
+		OUT_RING  (chan, dst_pitch);
+		OUT_RING  (chan, w * src->texture->block.size);
 		OUT_RING  (chan, count);
 		OUT_RING  (chan, 0x0101);
 		OUT_RING  (chan, 0);
 
 		h -= count;
-		src_offset += src->stride * count;
-		dst_offset += dst->stride * count;
+		src_offset += src_pitch * count;
+		dst_offset += dst_pitch * count;
 	}
 
 	return 0;
@@ -213,6 +218,8 @@ nv04_surface_copy_blit(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	struct nouveau_grobj *blit = ctx->blit;
 	struct nouveau_bo *src_bo = ctx->nvws->get_bo(ctx->buf(src));
 	struct nouveau_bo *dst_bo = ctx->nvws->get_bo(ctx->buf(dst));
+	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
+	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	int format;
 
 	format = nv04_surface_format(dst->format);
@@ -225,7 +232,7 @@ nv04_surface_copy_blit(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	OUT_RELOCo(chan, dst_bo, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
 	OUT_RING  (chan, format);
-	OUT_RING  (chan, (dst->stride << 16) | src->stride);
+	OUT_RING  (chan, (dst_pitch << 16) | src_pitch);
 	OUT_RELOCl(chan, src_bo, src->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_RD);
 	OUT_RELOCl(chan, dst_bo, dst->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 
@@ -242,6 +249,8 @@ nv04_surface_copy(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 		  int dx, int dy, struct pipe_surface *src, int sx, int sy,
 		  int w, int h)
 {
+	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
+	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	int src_linear = src->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR;
 	int dst_linear = dst->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR;
 
@@ -257,7 +266,8 @@ nv04_surface_copy(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	 * to NV_MEMORY_TO_MEMORY_FORMAT in this case.
 	 */
 	if ((src->offset & 63) || (dst->offset & 63) ||
-	    (src->stride & 63) || (dst->stride & 63)) {
+	    (src_pitch & 63) || (dst_pitch & 63) ||
+	    debug_get_bool_option("NOUVEAU_NO_COPYBLIT", FALSE)) {
 		nv04_surface_copy_m2mf(ctx, dst, dx, dy, src, sx, sy, w, h);
 		return;
 	}
@@ -273,6 +283,7 @@ nv04_surface_fill(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	struct nouveau_grobj *surf2d = ctx->surf2d;
 	struct nouveau_grobj *rect = ctx->rect;
 	struct nouveau_bo *dst_bo = ctx->nvws->get_bo(ctx->buf(dst));
+	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	int cs2d_format, gdirect_format;
 
 	cs2d_format = nv04_surface_format(dst->format);
@@ -287,7 +298,7 @@ nv04_surface_fill(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	OUT_RELOCo(chan, dst_bo, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
 	OUT_RING  (chan, cs2d_format);
-	OUT_RING  (chan, (dst->stride << 16) | dst->stride);
+	OUT_RING  (chan, (dst_pitch << 16) | dst_pitch);
 	OUT_RELOCl(chan, dst_bo, dst->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	OUT_RELOCl(chan, dst_bo, dst->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 
@@ -426,13 +437,21 @@ nv04_surface_2d_init(struct nouveau_winsys *nvws)
 		return NULL;
 	}
 
-	if (chan->device->chipset < 0x10) {
-		class = NV04_SCALED_IMAGE_FROM_MEMORY;
-	} else
-	if (chan->device->chipset < 0x40) {
+	switch (chan->device->chipset & 0xf0) {
+	case 0x10:
+	case 0x20:
 		class = NV10_SCALED_IMAGE_FROM_MEMORY;
-	} else {
+		break;
+	case 0x30:
+		class = NV30_SCALED_IMAGE_FROM_MEMORY;
+		break;
+	case 0x40:
+	case 0x60:
 		class = NV40_SCALED_IMAGE_FROM_MEMORY;
+		break;
+	default:
+		class = NV04_SCALED_IMAGE_FROM_MEMORY;
+		break;
 	}
 
 	ret = nouveau_grobj_alloc(chan, handle++, class, &ctx->sifm);
diff --git a/src/gallium/drivers/nv04/nv04_surface_2d.h b/src/gallium/drivers/nv04/nv04_surface_2d.h
index 21b8f869606..82ce7189c8b 100644
--- a/src/gallium/drivers/nv04/nv04_surface_2d.h
+++ b/src/gallium/drivers/nv04/nv04_surface_2d.h
@@ -1,6 +1,11 @@
 #ifndef __NV04_SURFACE_2D_H__
 #define __NV04_SURFACE_2D_H__
 
+struct nv04_surface {
+	struct pipe_surface base;
+	unsigned pitch;
+};
+
 struct nv04_surface_2d {
 	struct nouveau_winsys *nvws;
 	struct nouveau_notifier *ntfy;
diff --git a/src/gallium/drivers/nv04/nv04_transfer.c b/src/gallium/drivers/nv04/nv04_transfer.c
new file mode 100644
index 00000000000..e925a44e298
--- /dev/null
+++ b/src/gallium/drivers/nv04/nv04_transfer.c
@@ -0,0 +1,196 @@
+#include <pipe/p_state.h>
+#include <pipe/p_defines.h>
+#include <pipe/p_inlines.h>
+#include <util/u_memory.h>
+#include <nouveau/nouveau_winsys.h>
+#include "nv04_context.h"
+#include "nv04_screen.h"
+#include "nv04_state.h"
+
+struct nv04_transfer {
+	struct pipe_transfer base;
+	struct pipe_surface *surface;
+	bool direct;
+};
+
+static unsigned nv04_usage_tx_to_buf(unsigned tx_usage)
+{
+	switch (tx_usage) {
+		case PIPE_TRANSFER_READ:
+			return PIPE_BUFFER_USAGE_CPU_READ;
+		case PIPE_TRANSFER_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_WRITE;
+		case PIPE_TRANSFER_READ_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+		default:
+			assert(0);
+	}
+
+	return -1;
+}
+
+static void
+nv04_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
+                             struct pipe_texture *template)
+{
+	memset(template, 0, sizeof(struct pipe_texture));
+	template->target = pt->target;
+	template->format = pt->format;
+	template->width[0] = pt->width[level];
+	template->height[0] = pt->height[level];
+	template->depth[0] = 1;
+	template->block = pt->block;
+	template->nblocksx[0] = pt->nblocksx[level];
+	template->nblocksy[0] = pt->nblocksx[level];
+	template->last_level = 0;
+	template->compressed = pt->compressed;
+	template->nr_samples = pt->nr_samples;
+
+	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
+	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+}
+
+static struct pipe_transfer *
+nv04_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv04_miptree *mt = (struct nv04_miptree *)pt;
+	struct nv04_transfer *tx;
+	struct pipe_texture tx_tex_template, *tx_tex;
+
+	tx = CALLOC_STRUCT(nv04_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.x = x;
+	tx->base.y = y;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = mt->level[level].pitch;
+	tx->base.usage = usage;
+	tx->base.face = face;
+	tx->base.level = level;
+	tx->base.zslice = zslice;
+
+	/* Direct access to texture */
+	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
+	     debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
+	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	{
+		tx->direct = true;
+		tx->surface = pscreen->get_tex_surface(pscreen, pt,
+	                                               0, 0, 0,
+	                                               nv04_usage_tx_to_buf(usage));
+		return &tx->base;
+	}
+
+	tx->direct = false;
+
+	nv04_compatible_transfer_tex(pt, level, &tx_tex_template);
+
+	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	if (!tx_tex)
+	{
+		FREE(tx);
+		return NULL;
+	}
+
+	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
+	                                       face, level, zslice,
+	                                       nv04_usage_tx_to_buf(usage));
+
+	pipe_texture_reference(&tx_tex, NULL);
+
+	if (!tx->surface)
+	{
+		pipe_surface_reference(&tx->surface, NULL);
+		FREE(tx);
+		return NULL;
+	}
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		struct nv04_screen *nvscreen = nv04_screen(pscreen);
+		struct pipe_surface *src;
+
+		src = pscreen->get_tex_surface(pscreen, pt,
+	                                       face, level, zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_READ);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		/* TODO: Check if SIFM can un-swizzle */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      tx->surface, 0, 0,
+		                      src, 0, 0,
+		                      src->width, src->height);
+
+		pipe_surface_reference(&src, NULL);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv04_transfer_del(struct pipe_transfer *ptx)
+{
+	struct nv04_transfer *tx = (struct nv04_transfer *)ptx;
+
+	if (!tx->direct && ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		struct nv04_screen *nvscreen = nv04_screen(pscreen);
+		struct pipe_surface *dst;
+
+		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
+	                                       ptx->face, ptx->level, ptx->zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_WRITE);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      dst, 0, 0,
+		                      tx->surface, 0, 0,
+		                      dst->width, dst->height);
+
+		pipe_surface_reference(&dst, NULL);
+	}
+
+	pipe_surface_reference(&tx->surface, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv04_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv04_transfer *tx = (struct nv04_transfer *)ptx;
+	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
+	struct nv04_miptree *mt = (struct nv04_miptree *)tx->surface->texture;
+	void *map = pipe_buffer_map(pscreen, mt->buffer,
+	                            nv04_usage_tx_to_buf(ptx->usage));
+
+	return map + ns->base.offset +
+	       ptx->y * ns->pitch + ptx->x * ptx->block.size;
+}
+
+static void
+nv04_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv04_transfer *tx = (struct nv04_transfer *)ptx;
+	struct nv04_miptree *mt = (struct nv04_miptree *)tx->surface->texture;
+
+	pipe_buffer_unmap(pscreen, mt->buffer);
+}
+
+void
+nv04_screen_init_transfer_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv04_transfer_new;
+	pscreen->tex_transfer_destroy = nv04_transfer_del;
+	pscreen->transfer_map = nv04_transfer_map;
+	pscreen->transfer_unmap = nv04_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv10/Makefile b/src/gallium/drivers/nv10/Makefile
index 4ba7ce586d6..62677f5194a 100644
--- a/src/gallium/drivers/nv10/Makefile
+++ b/src/gallium/drivers/nv10/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv10
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv10_clear.c \
 	nv10_context.c \
 	nv10_fragprog.c \
@@ -14,15 +14,7 @@ DRIVER_SOURCES = \
 	nv10_state.c \
 	nv10_state_emit.c \
 	nv10_surface.c \
+	nv10_transfer.c \
 	nv10_vbo.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv10/nv10_miptree.c b/src/gallium/drivers/nv10/nv10_miptree.c
index 96161354617..bb3a1c0f19e 100644
--- a/src/gallium/drivers/nv10/nv10_miptree.c
+++ b/src/gallium/drivers/nv10/nv10_miptree.c
@@ -66,31 +66,30 @@ nv10_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->level[0].pitch = stride[0];
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
 static struct pipe_texture *
 nv10_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 {
-	struct pipe_winsys *ws = screen->winsys;
 	struct nv10_miptree *mt;
 
 	mt = MALLOC(sizeof(struct nv10_miptree));
 	if (!mt)
 		return NULL;
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = screen;
 
 	nv10_miptree_layout(mt);
 
-	mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+	mt->buffer = screen->buffer_create(screen, 256, PIPE_BUFFER_USAGE_PIXEL,
 					   mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
@@ -101,22 +100,17 @@ nv10_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 }
 
 static void
-nv10_miptree_release(struct pipe_screen *screen, struct pipe_texture **pt)
+nv10_miptree_destroy(struct pipe_texture *pt)
 {
-	struct pipe_texture *mt = *pt;
-
-	*pt = NULL;
-	if (--mt->refcount <= 0) {
-		struct nv10_miptree *nv10mt = (struct nv10_miptree *)mt;
-		int l;
-
-		pipe_buffer_reference(screen, &nv10mt->buffer, NULL);
-		for (l = 0; l <= mt->last_level; l++) {
-			if (nv10mt->level[l].image_offset)
-				FREE(nv10mt->level[l].image_offset);
-		}
-		FREE(nv10mt);
-	}
+	struct nv10_miptree *nv10mt = (struct nv10_miptree *)pt;
+        int l;
+
+        pipe_buffer_reference(&nv10mt->buffer, NULL);
+        for (l = 0; l <= pt->last_level; l++) {
+		if (nv10mt->level[l].image_offset)
+			FREE(nv10mt->level[l].image_offset);
+        }
+        FREE(nv10mt);
 }
 
 static void
@@ -131,35 +125,35 @@ nv10_miptree_surface_get(struct pipe_screen *screen, struct pipe_texture *pt,
 			 unsigned face, unsigned level, unsigned zslice,
 			 unsigned flags)
 {
-	struct pipe_winsys *ws = screen->winsys;
 	struct nv10_miptree *nv10mt = (struct nv10_miptree *)pt;
-	struct pipe_surface *ps;
+	struct nv04_surface *ns;
 
-	ps = CALLOC_STRUCT(pipe_surface);
-	if (!ps)
+	ns = CALLOC_STRUCT(nv04_surface);
+	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
-	ps->format = pt->format;
-	ps->width = pt->width[level];
-	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = nv10mt->level[level].pitch;
-	ps->refcount = 1;
+	pipe_texture_reference(&ns->base.texture, pt);
+	ns->base.format = pt->format;
+	ns->base.width = pt->width[level];
+	ns->base.height = pt->height[level];
+	ns->base.usage = flags;
+	ns->base.status = PIPE_SURFACE_STATUS_DEFINED;
+	pipe_reference_init(&ns->base.reference, 1);
+	ns->base.face = face;
+	ns->base.level = level;
+	ns->base.zslice = zslice;
+	ns->pitch = nv10mt->level[level].pitch;
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
-		ps->offset = nv10mt->level[level].image_offset[face];
+		ns->base.offset = nv10mt->level[level].image_offset[face];
 	} else {
-		ps->offset = nv10mt->level[level].image_offset[0];
+		ns->base.offset = nv10mt->level[level].image_offset[0];
 	}
 
-	return ps;
+	return &ns->base;
 }
 
 static void
-nv10_miptree_surface_release(struct pipe_screen *screen,
-			     struct pipe_surface **surface)
+nv10_miptree_surface_destroy(struct pipe_surface *surface)
 {
 }
 
@@ -167,8 +161,8 @@ void nv10_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv10_miptree_create;
 	pscreen->texture_blanket = nv10_miptree_blanket;
-	pscreen->texture_release = nv10_miptree_release;
+	pscreen->texture_destroy = nv10_miptree_destroy;
 	pscreen->get_tex_surface = nv10_miptree_surface_get;
-	pscreen->tex_surface_release = nv10_miptree_surface_release;
+	pscreen->tex_surface_destroy = nv10_miptree_surface_destroy;
 }
 
diff --git a/src/gallium/drivers/nv10/nv10_prim_vbuf.c b/src/gallium/drivers/nv10/nv10_prim_vbuf.c
index 7435d873154..089c236302a 100644
--- a/src/gallium/drivers/nv10/nv10_prim_vbuf.c
+++ b/src/gallium/drivers/nv10/nv10_prim_vbuf.c
@@ -38,7 +38,7 @@
  */
 
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_inlines.h"
 #include "pipe/internal/p_winsys_screen.h"
 
@@ -99,27 +99,50 @@ nv10_vbuf_render_get_vertex_info( struct vbuf_render *render )
 	return &nv10->vertex_info;
 }
 
-
-static void *
+static boolean
 nv10_vbuf_render_allocate_vertices( struct vbuf_render *render,
 		ushort vertex_size,
 		ushort nr_vertices )
 {
 	struct nv10_vbuf_render *nv10_render = nv10_vbuf_render(render);
 	struct nv10_context *nv10 = nv10_render->nv10;
-	struct pipe_winsys *winsys = nv10->pipe.winsys;
+	struct pipe_screen *screen = nv10->pipe.screen;
 	size_t size = (size_t)vertex_size * (size_t)nr_vertices;
 
 	assert(!nv10_render->buffer);
-	nv10_render->buffer = winsys->buffer_create(winsys, 64, PIPE_BUFFER_USAGE_VERTEX, size);
+	nv10_render->buffer = screen->buffer_create(screen, 64, PIPE_BUFFER_USAGE_VERTEX, size);
 
 	nv10->dirty |= NV10_NEW_VTXARRAYS;
 
+	if (nv10_render->buffer)
+		return FALSE;
+	return TRUE;
+}
+
+static void *
+nv10_vbuf_render_map_vertices( struct vbuf_render *render )
+{
+	struct nv10_vbuf_render *nv10_render = nv10_vbuf_render(render);
+	struct nv10_context *nv10 = nv10_render->nv10;
+	struct pipe_winsys *winsys = nv10->pipe.winsys;
+
 	return winsys->buffer_map(winsys, 
 			nv10_render->buffer, 
 			PIPE_BUFFER_USAGE_CPU_WRITE);
 }
 
+static void
+nv10_vbuf_render_unmap_vertices( struct vbuf_render *render,
+		ushort min_index,
+		ushort max_index )
+{
+	struct nv10_vbuf_render *nv10_render = nv10_vbuf_render(render);
+	struct nv10_context *nv10 = nv10_render->nv10;
+	struct pipe_winsys *winsys = nv10->pipe.winsys;
+
+	assert(!nv10_render->buffer);
+	winsys->buffer_unmap(winsys, nv10_render->buffer);
+}
 
 static boolean
 nv10_vbuf_render_set_primitive( struct vbuf_render *render, 
@@ -176,19 +199,14 @@ nv10_vbuf_render_draw( struct vbuf_render *render,
 
 
 static void
-nv10_vbuf_render_release_vertices( struct vbuf_render *render,
-		void *vertices, 
-		unsigned vertex_size,
-		unsigned vertices_used )
+nv10_vbuf_render_release_vertices( struct vbuf_render *render )
 {
 	struct nv10_vbuf_render *nv10_render = nv10_vbuf_render(render);
 	struct nv10_context *nv10 = nv10_render->nv10;
-	struct pipe_winsys *winsys = nv10->pipe.winsys;
 	struct pipe_screen *pscreen = &nv10->screen->pipe;
 
 	assert(nv10_render->buffer);
-	winsys->buffer_unmap(winsys, nv10_render->buffer);
-	pipe_buffer_reference(pscreen, &nv10_render->buffer, NULL);
+	pipe_buffer_reference(&nv10_render->buffer, NULL);
 }
 
 
@@ -214,6 +232,8 @@ nv10_vbuf_render_create( struct nv10_context *nv10 )
 	nv10_render->base.max_indices = 1024;
 	nv10_render->base.get_vertex_info = nv10_vbuf_render_get_vertex_info;
 	nv10_render->base.allocate_vertices = nv10_vbuf_render_allocate_vertices;
+	nv10_render->base.map_vertices = nv10_vbuf_render_map_vertices;
+	nv10_render->base.unmap_vertices = nv10_vbuf_render_unmap_vertices;
 	nv10_render->base.set_primitive = nv10_vbuf_render_set_primitive;
 	nv10_render->base.draw = nv10_vbuf_render_draw;
 	nv10_render->base.release_vertices = nv10_vbuf_render_release_vertices;
diff --git a/src/gallium/drivers/nv10/nv10_screen.c b/src/gallium/drivers/nv10/nv10_screen.c
index f417b06c944..6532a93c7ba 100644
--- a/src/gallium/drivers/nv10/nv10_screen.c
+++ b/src/gallium/drivers/nv10/nv10_screen.c
@@ -116,30 +116,6 @@ nv10_screen_is_format_supported(struct pipe_screen *screen,
 	return FALSE;
 }
 
-static void *
-nv10_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
-		 unsigned flags )
-{
-	struct pipe_winsys *ws = screen->winsys;
-	void *map;
-        struct nv10_miptree *nv10mt = (struct nv10_miptree *)surface->texture;
-
-	map = ws->buffer_map(ws, nv10mt->buffer, flags);
-	if (!map)
-		return NULL;
-
-	return map + surface->offset;
-}
-
-static void
-nv10_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
-{
-	struct pipe_winsys *ws = screen->winsys;
-        struct nv10_miptree *nv10mt = (struct nv10_miptree *)surface->texture;
-
-	ws->buffer_unmap(ws, nv10mt->buffer);
-}
-
 static void
 nv10_screen_destroy(struct pipe_screen *pscreen)
 {
@@ -215,10 +191,8 @@ nv10_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 
 	screen->pipe.is_format_supported = nv10_screen_is_format_supported;
 
-	screen->pipe.surface_map = nv10_surface_map;
-	screen->pipe.surface_unmap = nv10_surface_unmap;
-
 	nv10_screen_init_miptree_functions(&screen->pipe);
+	nv10_screen_init_transfer_functions(&screen->pipe);
 	u_simple_screen_init(&screen->pipe);
 
 	return &screen->pipe;
diff --git a/src/gallium/drivers/nv10/nv10_screen.h b/src/gallium/drivers/nv10/nv10_screen.h
index 60102a369a9..ad829ee3fd4 100644
--- a/src/gallium/drivers/nv10/nv10_screen.h
+++ b/src/gallium/drivers/nv10/nv10_screen.h
@@ -21,4 +21,8 @@ nv10_screen(struct pipe_screen *screen)
 	return (struct nv10_screen *)screen;
 }
 
+
+void
+nv10_screen_init_transfer_functions(struct pipe_screen *pscreen);
+
 #endif
diff --git a/src/gallium/drivers/nv10/nv10_state_emit.c b/src/gallium/drivers/nv10/nv10_state_emit.c
index 5dec618b933..d8691ef9c67 100644
--- a/src/gallium/drivers/nv10/nv10_state_emit.c
+++ b/src/gallium/drivers/nv10/nv10_state_emit.c
@@ -103,7 +103,7 @@ static void nv10_state_emit_scissor(struct nv10_context* nv10)
 static void nv10_state_emit_framebuffer(struct nv10_context* nv10)
 {
 	struct pipe_framebuffer_state* fb = nv10->framebuffer;
-	struct pipe_surface *rt, *zeta = NULL;
+	struct nv04_surface *rt, *zeta = NULL;
 	uint32_t rt_format, w, h;
 	int colour_format = 0, zeta_format = 0;
         struct nv10_miptree *nv10mt = 0;
@@ -111,7 +111,7 @@ static void nv10_state_emit_framebuffer(struct nv10_context* nv10)
 	w = fb->cbufs[0]->width;
 	h = fb->cbufs[0]->height;
 	colour_format = fb->cbufs[0]->format;
-	rt = fb->cbufs[0];
+	rt = (struct nv04_surface *)fb->cbufs[0];
 
 	if (fb->zsbuf) {
 		if (colour_format) {
@@ -123,7 +123,7 @@ static void nv10_state_emit_framebuffer(struct nv10_context* nv10)
 		}
 
 		zeta_format = fb->zsbuf->format;
-		zeta = fb->zsbuf;
+		zeta = (struct nv04_surface *)fb->zsbuf;
 	}
 
 	rt_format = NV10TCL_RT_FORMAT_TYPE_LINEAR;
@@ -142,18 +142,18 @@ static void nv10_state_emit_framebuffer(struct nv10_context* nv10)
 
 	if (zeta) {
 		BEGIN_RING(celsius, NV10TCL_RT_PITCH, 1);
-		OUT_RING  (rt->stride | (zeta->stride << 16));
+		OUT_RING  (rt->pitch | (zeta->pitch << 16));
 	} else {
 		BEGIN_RING(celsius, NV10TCL_RT_PITCH, 1);
-		OUT_RING  (rt->stride | (rt->stride << 16));
+		OUT_RING  (rt->pitch | (rt->pitch << 16));
 	}
 
-	nv10mt = (struct nv10_miptree *)rt->texture;
+	nv10mt = (struct nv10_miptree *)rt->base.texture;
 	nv10->rt[0] = nv10mt->buffer;
 
 	if (zeta_format)
 	{
-		nv10mt = (struct nv10_miptree *)zeta->texture;
+		nv10mt = (struct nv10_miptree *)zeta->base.texture;
 		nv10->zeta = nv10mt->buffer;
 	}
 
diff --git a/src/gallium/drivers/nv10/nv10_surface.c b/src/gallium/drivers/nv10/nv10_surface.c
index 25381510638..5b52246a9ca 100644
--- a/src/gallium/drivers/nv10/nv10_surface.c
+++ b/src/gallium/drivers/nv10/nv10_surface.c
@@ -33,7 +33,7 @@
 #include "util/u_tile.h"
 
 static void
-nv10_surface_copy(struct pipe_context *pipe, boolean do_flip,
+nv10_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -41,15 +41,6 @@ nv10_surface_copy(struct pipe_context *pipe, boolean do_flip,
 	struct nv10_context *nv10 = nv10_context(pipe);
 	struct nv04_surface_2d *eng2d = nv10->screen->eng2d;
 
-	if (do_flip) {
-		desty += height;
-		while (height--) {
-			eng2d->copy(eng2d, dest, destx, desty--, src,
-				    srcx, srcy++, width, 1);
-		}
-		return;
-	}
-
 	eng2d->copy(eng2d, dest, destx, desty, src, srcx, srcy, width, height);
 }
 
diff --git a/src/gallium/drivers/nv10/nv10_transfer.c b/src/gallium/drivers/nv10/nv10_transfer.c
new file mode 100644
index 00000000000..5a99225409c
--- /dev/null
+++ b/src/gallium/drivers/nv10/nv10_transfer.c
@@ -0,0 +1,196 @@
+#include <pipe/p_state.h>
+#include <pipe/p_defines.h>
+#include <pipe/p_inlines.h>
+#include <util/u_memory.h>
+#include <nouveau/nouveau_winsys.h>
+#include "nv10_context.h"
+#include "nv10_screen.h"
+#include "nv10_state.h"
+
+struct nv10_transfer {
+	struct pipe_transfer base;
+	struct pipe_surface *surface;
+	bool direct;
+};
+
+static unsigned nv10_usage_tx_to_buf(unsigned tx_usage)
+{
+	switch (tx_usage) {
+		case PIPE_TRANSFER_READ:
+			return PIPE_BUFFER_USAGE_CPU_READ;
+		case PIPE_TRANSFER_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_WRITE;
+		case PIPE_TRANSFER_READ_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+		default:
+			assert(0);
+	}
+
+	return -1;
+}
+
+static void
+nv10_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
+                             struct pipe_texture *template)
+{
+	memset(template, 0, sizeof(struct pipe_texture));
+	template->target = pt->target;
+	template->format = pt->format;
+	template->width[0] = pt->width[level];
+	template->height[0] = pt->height[level];
+	template->depth[0] = 1;
+	template->block = pt->block;
+	template->nblocksx[0] = pt->nblocksx[level];
+	template->nblocksy[0] = pt->nblocksx[level];
+	template->last_level = 0;
+	template->compressed = pt->compressed;
+	template->nr_samples = pt->nr_samples;
+
+	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
+	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+}
+
+static struct pipe_transfer *
+nv10_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv10_miptree *mt = (struct nv10_miptree *)pt;
+	struct nv10_transfer *tx;
+	struct pipe_texture tx_tex_template, *tx_tex;
+
+	tx = CALLOC_STRUCT(nv10_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.x = x;
+	tx->base.y = y;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = mt->level[level].pitch;
+	tx->base.usage = usage;
+	tx->base.face = face;
+	tx->base.level = level;
+	tx->base.zslice = zslice;
+
+	/* Direct access to texture */
+	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
+	     debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
+	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	{
+		tx->direct = true;
+		tx->surface = pscreen->get_tex_surface(pscreen, pt,
+	                                               0, 0, 0,
+	                                               nv10_usage_tx_to_buf(usage));
+		return &tx->base;
+	}
+
+	tx->direct = false;
+
+	nv10_compatible_transfer_tex(pt, level, &tx_tex_template);
+
+	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	if (!tx_tex)
+	{
+		FREE(tx);
+		return NULL;
+	}
+
+	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
+	                                       face, level, zslice,
+	                                       nv10_usage_tx_to_buf(usage));
+
+	pipe_texture_reference(&tx_tex, NULL);
+
+	if (!tx->surface)
+	{
+		pipe_surface_reference(&tx->surface, NULL);
+		FREE(tx);
+		return NULL;
+	}
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		struct nv10_screen *nvscreen = nv10_screen(pscreen);
+		struct pipe_surface *src;
+
+		src = pscreen->get_tex_surface(pscreen, pt,
+	                                       face, level, zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_READ);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		/* TODO: Check if SIFM can un-swizzle */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      tx->surface, 0, 0,
+		                      src, 0, 0,
+		                      src->width, src->height);
+
+		pipe_surface_reference(&src, NULL);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv10_transfer_del(struct pipe_transfer *ptx)
+{
+	struct nv10_transfer *tx = (struct nv10_transfer *)ptx;
+
+	if (!tx->direct && ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		struct nv10_screen *nvscreen = nv10_screen(pscreen);
+		struct pipe_surface *dst;
+
+		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
+	                                       ptx->face, ptx->level, ptx->zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_WRITE);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      dst, 0, 0,
+		                      tx->surface, 0, 0,
+		                      dst->width, dst->height);
+
+		pipe_surface_reference(&dst, NULL);
+	}
+
+	pipe_surface_reference(&tx->surface, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv10_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv10_transfer *tx = (struct nv10_transfer *)ptx;
+	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
+	struct nv10_miptree *mt = (struct nv10_miptree *)tx->surface->texture;
+	void *map = pipe_buffer_map(pscreen, mt->buffer,
+	                            nv10_usage_tx_to_buf(ptx->usage));
+
+	return map + ns->base.offset +
+	       ptx->y * ns->pitch + ptx->x * ptx->block.size;
+}
+
+static void
+nv10_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv10_transfer *tx = (struct nv10_transfer *)ptx;
+	struct nv10_miptree *mt = (struct nv10_miptree *)tx->surface->texture;
+
+	pipe_buffer_unmap(pscreen, mt->buffer);
+}
+
+void
+nv10_screen_init_transfer_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv10_transfer_new;
+	pscreen->tex_transfer_destroy = nv10_transfer_del;
+	pscreen->transfer_map = nv10_transfer_map;
+	pscreen->transfer_unmap = nv10_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv20/Makefile b/src/gallium/drivers/nv20/Makefile
index d777fd3d8b4..1305f26c591 100644
--- a/src/gallium/drivers/nv20/Makefile
+++ b/src/gallium/drivers/nv20/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv20
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv20_clear.c \
 	nv20_context.c \
 	nv20_fragprog.c \
@@ -14,16 +14,8 @@ DRIVER_SOURCES = \
 	nv20_state.c \
 	nv20_state_emit.c \
 	nv20_surface.c \
+	nv20_transfer.c \
 	nv20_vbo.c
 #	nv20_vertprog.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv20/nv20_miptree.c b/src/gallium/drivers/nv20/nv20_miptree.c
index ef7e9c5428e..b2f29aff8d2 100644
--- a/src/gallium/drivers/nv20/nv20_miptree.c
+++ b/src/gallium/drivers/nv20/nv20_miptree.c
@@ -9,10 +9,14 @@ static void
 nv20_miptree_layout(struct nv20_miptree *nv20mt)
 {
 	struct pipe_texture *pt = &nv20mt->base;
-	boolean swizzled = FALSE;
 	uint width = pt->width[0], height = pt->height[0];
 	uint offset = 0;
 	int nr_faces, l, f;
+	uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
+		                           PIPE_TEXTURE_USAGE_DEPTH_STENCIL |
+		                           PIPE_TEXTURE_USAGE_RENDER_TARGET |
+		                           PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
+		                           PIPE_TEXTURE_USAGE_PRIMARY);
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
 		nr_faces = 6;
@@ -26,25 +30,31 @@ nv20_miptree_layout(struct nv20_miptree *nv20mt)
 		pt->nblocksx[l] = pf_get_nblocksx(&pt->block, width);
 		pt->nblocksy[l] = pf_get_nblocksy(&pt->block, height);
 
-		if (swizzled)
-			nv20mt->level[l].pitch = pt->nblocksx[l] * pt->block.size;
+		if (wide_pitch && (pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR))
+			nv20mt->level[l].pitch = align(pt->width[0] * pt->block.size, 64);
 		else
-			nv20mt->level[l].pitch = pt->nblocksx[0] * pt->block.size;
-		nv20mt->level[l].pitch = (nv20mt->level[l].pitch + 63) & ~63;
+			nv20mt->level[l].pitch = pt->width[l] * pt->block.size;
 
 		nv20mt->level[l].image_offset =
 			CALLOC(nr_faces, sizeof(unsigned));
 
 		width  = MAX2(1, width  >> 1);
 		height = MAX2(1, height >> 1);
-
 	}
 
 	for (f = 0; f < nr_faces; f++) {
-		for (l = 0; l <= pt->last_level; l++) {
+		for (l = 0; l < pt->last_level; l++) {
 			nv20mt->level[l].image_offset[f] = offset;
-			offset += nv20mt->level[l].pitch * pt->height[l];
+
+			if (!(pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR) &&
+			    pt->width[l + 1] > 1 && pt->height[l + 1] > 1)
+				offset += align(nv20mt->level[l].pitch * pt->height[l], 64);
+			else
+				offset += nv20mt->level[l].pitch * pt->height[l];
 		}
+
+		nv20mt->level[l].image_offset[f] = offset;
+		offset += nv20mt->level[l].pitch * pt->height[l];
 	}
 
 	nv20mt->total_size = offset;
@@ -66,19 +76,18 @@ nv20_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->level[0].pitch = stride[0];
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
 static struct pipe_texture *
 nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 {
-	struct pipe_winsys *ws = screen->winsys;
 	struct nv20_miptree *mt;
 	unsigned buf_usage = PIPE_BUFFER_USAGE_PIXEL |
 	                     NOUVEAU_BUFFER_USAGE_TEXTURE;
@@ -87,7 +96,7 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 	if (!mt)
 		return NULL;
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = screen;
 
 	/* Swizzled textures must be POT */
@@ -96,7 +105,8 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 	else
 	if (pt->tex_usage & (PIPE_TEXTURE_USAGE_PRIMARY |
-	                     PIPE_TEXTURE_USAGE_DISPLAY_TARGET))
+	                     PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
+	                     PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
 		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 	else
 	if (pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC)
@@ -107,7 +117,11 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 		case PIPE_FORMAT_A8R8G8B8_UNORM:
 		case PIPE_FORMAT_X8R8G8B8_UNORM:
 		case PIPE_FORMAT_R16_SNORM:
+		{
+			if (debug_get_bool_option("NOUVEAU_NO_SWIZZLE", FALSE))
+				mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 			break;
+		}
 		default:
 			mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 		}
@@ -118,7 +132,7 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 
 	nv20_miptree_layout(mt);
 
-	mt->buffer = ws->buffer_create(ws, 256, buf_usage, mt->total_size);
+	mt->buffer = screen->buffer_create(screen, 256, buf_usage, mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
 		return NULL;
@@ -128,22 +142,16 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 }
 
 static void
-nv20_miptree_release(struct pipe_screen *screen, struct pipe_texture **pt)
+nv20_miptree_destroy(struct pipe_texture *pt)
 {
-	struct pipe_texture *mt = *pt;
-
-	*pt = NULL;
-	if (--mt->refcount <= 0) {
-		struct nv20_miptree *nv20mt = (struct nv20_miptree *)mt;
-		int l;
+	struct nv20_miptree *nv20mt = (struct nv20_miptree *)pt;
+        int l;
 
-		pipe_buffer_reference(screen, &nv20mt->buffer, NULL);
-		for (l = 0; l <= mt->last_level; l++) {
-			if (nv20mt->level[l].image_offset)
-				FREE(nv20mt->level[l].image_offset);
-		}
-		FREE(nv20mt);
-	}
+        pipe_buffer_reference(&nv20mt->buffer, NULL);
+        for (l = 0; l <= pt->last_level; l++) {
+		if (nv20mt->level[l].image_offset)
+			FREE(nv20mt->level[l].image_offset);
+        }
 }
 
 static struct pipe_surface *
@@ -152,45 +160,38 @@ nv20_miptree_surface_get(struct pipe_screen *screen, struct pipe_texture *pt,
 			 unsigned flags)
 {
 	struct nv20_miptree *nv20mt = (struct nv20_miptree *)pt;
-	struct pipe_surface *ps;
+	struct nv04_surface *ns;
 
-	ps = CALLOC_STRUCT(pipe_surface);
-	if (!ps)
+	ns = CALLOC_STRUCT(nv04_surface);
+	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
-	ps->format = pt->format;
-	ps->width = pt->width[level];
-	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = nv20mt->level[level].pitch;
-	ps->usage = flags;
-	ps->status = PIPE_SURFACE_STATUS_DEFINED;
-	ps->refcount = 1;
+	pipe_texture_reference(&ns->base.texture, pt);
+	ns->base.format = pt->format;
+	ns->base.width = pt->width[level];
+	ns->base.height = pt->height[level];
+	ns->base.usage = flags;
+	ns->base.status = PIPE_SURFACE_STATUS_DEFINED;
+	pipe_reference_init(&ns->base.reference, 1);
+	ns->base.face = face;
+	ns->base.level = level;
+	ns->base.zslice = zslice;
+	ns->pitch = nv20mt->level[level].pitch;
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
-		ps->offset = nv20mt->level[level].image_offset[face];
+		ns->base.offset = nv20mt->level[level].image_offset[face];
 	} else
 	if (pt->target == PIPE_TEXTURE_3D) {
-		ps->offset = nv20mt->level[level].image_offset[zslice];
+		ns->base.offset = nv20mt->level[level].image_offset[zslice];
 	} else {
-		ps->offset = nv20mt->level[level].image_offset[0];
+		ns->base.offset = nv20mt->level[level].image_offset[0];
 	}
 
-	return ps;
+	return &ns->base;
 }
 
 static void
-nv20_miptree_surface_release(struct pipe_screen *pscreen,
-			     struct pipe_surface **psurface)
+nv20_miptree_surface_destroy(struct pipe_surface *ps)
 {
-	struct pipe_surface *ps = *psurface;
-
-	*psurface = NULL;
-	if (--ps->refcount > 0)
-		return;
-
 	pipe_texture_reference(&ps->texture, NULL);
 	FREE(ps);
 }
@@ -199,8 +200,8 @@ void nv20_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv20_miptree_create;
 	pscreen->texture_blanket = nv20_miptree_blanket;
-	pscreen->texture_release = nv20_miptree_release;
+	pscreen->texture_destroy = nv20_miptree_destroy;
 	pscreen->get_tex_surface = nv20_miptree_surface_get;
-	pscreen->tex_surface_release = nv20_miptree_surface_release;
+	pscreen->tex_surface_destroy = nv20_miptree_surface_destroy;
 }
 
diff --git a/src/gallium/drivers/nv20/nv20_prim_vbuf.c b/src/gallium/drivers/nv20/nv20_prim_vbuf.c
index 4dd7052814e..8aa342cd2db 100644
--- a/src/gallium/drivers/nv20/nv20_prim_vbuf.c
+++ b/src/gallium/drivers/nv20/nv20_prim_vbuf.c
@@ -38,7 +38,7 @@
  */
 
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_inlines.h"
 #include "pipe/internal/p_winsys_screen.h"
 
@@ -109,18 +109,15 @@ nv20__allocate_mbuffer(struct nv20_vbuf_render *nv20_render, size_t size)
 	return nv20_render->mbuffer;
 }
 
-static void *
+static void
 nv20__allocate_pbuffer(struct nv20_vbuf_render *nv20_render, size_t size)
 {
-	struct pipe_winsys *winsys = nv20_render->nv20->pipe.winsys;
-	nv20_render->pbuffer = winsys->buffer_create(winsys, 64,
+	struct pipe_screen *screen = nv20_render->nv20->pipe.screen;
+	nv20_render->pbuffer = screen->buffer_create(screen, 64,
 					PIPE_BUFFER_USAGE_VERTEX, size);
-	return winsys->buffer_map(winsys,
-			nv20_render->pbuffer,
-			PIPE_BUFFER_USAGE_CPU_WRITE);
 }
 
-static void *
+static boolean
 nv20_vbuf_render_allocate_vertices( struct vbuf_render *render,
 		ushort vertex_size,
 		ushort nr_vertices )
@@ -137,15 +134,49 @@ nv20_vbuf_render_allocate_vertices( struct vbuf_render *render,
 	 * buffer, the data will be passed directly via the fifo.
 	 */
 	/* XXX: Pipe vertex buffers don't work. */
-	if (0 && size > 16 * 1024)
-		buf = nv20__allocate_pbuffer(nv20_render, size);
-	else
+	if (0 && size > 16 * 1024) {
+		nv20__allocate_pbuffer(nv20_render, size);
+		/* umm yeah so this is ugly */
+		buf = nv20_render->pbuffer;
+	} else {
 		buf = nv20__allocate_mbuffer(nv20_render, size);
+	}
 
 	if (buf)
 		nv20_render->nv20->dirty |= NV20_NEW_VTXARRAYS;
 
-	return buf;
+	return buf ? TRUE : FALSE;
+}
+
+static void *
+nv20_vbuf_render_map_vertices( struct vbuf_render *render )
+{
+	struct nv20_vbuf_render *nv20_render = nv20_vbuf_render(render);
+	struct pipe_winsys *winsys = nv20_render->nv20->pipe.winsys;
+
+	if (nv20_render->pbuffer) {
+		return winsys->buffer_map(winsys,
+				nv20_render->pbuffer,
+				PIPE_BUFFER_USAGE_CPU_WRITE);
+	} else if (nv20_render->mbuffer) {
+		return nv20_render->mbuffer;
+	} else
+		assert(0);
+
+	/* warnings be gone */
+	return NULL;
+}
+
+static void
+nv20_vbuf_render_unmap_vertices( struct vbuf_render *render,
+		ushort min_index,
+		ushort max_index )
+{
+	struct nv20_vbuf_render *nv20_render = nv20_vbuf_render(render);
+	struct pipe_winsys *winsys = nv20_render->nv20->pipe.winsys;
+
+	if (nv20_render->pbuffer)
+		winsys->buffer_unmap(winsys, nv20_render->pbuffer);
 }
 
 static boolean
@@ -323,19 +354,14 @@ nv20_vbuf_render_draw( struct vbuf_render *render,
 
 
 static void
-nv20_vbuf_render_release_vertices( struct vbuf_render *render,
-		void *vertices, 
-		unsigned vertex_size,
-		unsigned vertices_used )
+nv20_vbuf_render_release_vertices( struct vbuf_render *render )
 {
 	struct nv20_vbuf_render *nv20_render = nv20_vbuf_render(render);
 	struct nv20_context *nv20 = nv20_render->nv20;
-	struct pipe_winsys *winsys = nv20->pipe.winsys;
 	struct pipe_screen *pscreen = &nv20->screen->pipe;
 
 	if (nv20_render->pbuffer) {
-		winsys->buffer_unmap(winsys, nv20_render->pbuffer);
-		pipe_buffer_reference(pscreen, &nv20_render->pbuffer, NULL);
+		pipe_buffer_reference(&nv20_render->pbuffer, NULL);
 	} else if (nv20_render->mbuffer) {
 		FREE(nv20_render->mbuffer);
 		nv20_render->mbuffer = NULL;
@@ -371,6 +397,8 @@ nv20_vbuf_render_create( struct nv20_context *nv20 )
 	nv20_render->base.get_vertex_info = nv20_vbuf_render_get_vertex_info;
 	nv20_render->base.allocate_vertices =
 					nv20_vbuf_render_allocate_vertices;
+	nv20_render->base.map_vertices = nv20_vbuf_render_map_vertices;
+	nv20_render->base.unmap_vertices = nv20_vbuf_render_unmap_vertices;
 	nv20_render->base.set_primitive = nv20_vbuf_render_set_primitive;
 	nv20_render->base.draw = nv20_vbuf_render_draw;
 	nv20_render->base.release_vertices = nv20_vbuf_render_release_vertices;
diff --git a/src/gallium/drivers/nv20/nv20_screen.c b/src/gallium/drivers/nv20/nv20_screen.c
index 5f2b7b4f71f..7760ae27c0e 100644
--- a/src/gallium/drivers/nv20/nv20_screen.c
+++ b/src/gallium/drivers/nv20/nv20_screen.c
@@ -116,30 +116,6 @@ nv20_screen_is_format_supported(struct pipe_screen *screen,
 	return FALSE;
 }
 
-static void *
-nv20_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
-		 unsigned flags )
-{
-	struct pipe_winsys *ws = screen->winsys;
-	void *map;
-	struct nv20_miptree *nv20mt = (struct nv20_miptree *)surface->texture;
-
-	map = ws->buffer_map(ws, nv20mt->buffer, flags);
-	if (!map)
-		return NULL;
-
-	return map + surface->offset;
-}
-
-static void
-nv20_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
-{
-	struct pipe_winsys *ws = screen->winsys;
-	struct nv20_miptree *nv20mt = (struct nv20_miptree *)surface->texture;
-
-	ws->buffer_unmap(ws, nv20mt->buffer);
-}
-
 static void
 nv20_screen_destroy(struct pipe_screen *pscreen)
 {
@@ -211,10 +187,8 @@ nv20_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 
 	screen->pipe.is_format_supported = nv20_screen_is_format_supported;
 
-	screen->pipe.surface_map = nv20_surface_map;
-	screen->pipe.surface_unmap = nv20_surface_unmap;
-
 	nv20_screen_init_miptree_functions(&screen->pipe);
+	nv20_screen_init_transfer_functions(&screen->pipe);
 	u_simple_screen_init(&screen->pipe);
 
 	return &screen->pipe;
diff --git a/src/gallium/drivers/nv20/nv20_screen.h b/src/gallium/drivers/nv20/nv20_screen.h
index bf2f2c0d9fb..d9fce2bced8 100644
--- a/src/gallium/drivers/nv20/nv20_screen.h
+++ b/src/gallium/drivers/nv20/nv20_screen.h
@@ -21,4 +21,8 @@ nv20_screen(struct pipe_screen *screen)
 	return (struct nv20_screen *)screen;
 }
 
+
+void
+nv20_screen_init_transfer_functions(struct pipe_screen *pscreen);
+
 #endif
diff --git a/src/gallium/drivers/nv20/nv20_state_emit.c b/src/gallium/drivers/nv20/nv20_state_emit.c
index 0f4df9ca317..4042f46d053 100644
--- a/src/gallium/drivers/nv20/nv20_state_emit.c
+++ b/src/gallium/drivers/nv20/nv20_state_emit.c
@@ -109,7 +109,7 @@ static void nv20_state_emit_scissor(struct nv20_context* nv20)
 static void nv20_state_emit_framebuffer(struct nv20_context* nv20)
 {
 	struct pipe_framebuffer_state* fb = nv20->framebuffer;
-	struct pipe_surface *rt, *zeta = NULL;
+	struct nv04_surface *rt, *zeta = NULL;
 	uint32_t rt_format, w, h;
 	int colour_format = 0, zeta_format = 0;
 	struct nv20_miptree *nv20mt = 0;
@@ -117,7 +117,7 @@ static void nv20_state_emit_framebuffer(struct nv20_context* nv20)
 	w = fb->cbufs[0]->width;
 	h = fb->cbufs[0]->height;
 	colour_format = fb->cbufs[0]->format;
-	rt = fb->cbufs[0];
+	rt = (struct nv04_surface *)fb->cbufs[0];
 
 	if (fb->zsbuf) {
 		if (colour_format) {
@@ -129,7 +129,7 @@ static void nv20_state_emit_framebuffer(struct nv20_context* nv20)
 		}
 
 		zeta_format = fb->zsbuf->format;
-		zeta = fb->zsbuf;
+		zeta = (struct nv04_surface *)fb->zsbuf;
 	}
 
 	rt_format = NV20TCL_RT_FORMAT_TYPE_LINEAR | 0x20;
@@ -148,18 +148,18 @@ static void nv20_state_emit_framebuffer(struct nv20_context* nv20)
 
 	if (zeta) {
 		BEGIN_RING(kelvin, NV20TCL_RT_PITCH, 1);
-		OUT_RING  (rt->stride | (zeta->stride << 16));
+		OUT_RING  (rt->pitch | (zeta->pitch << 16));
 	} else {
 		BEGIN_RING(kelvin, NV20TCL_RT_PITCH, 1);
-		OUT_RING  (rt->stride | (rt->stride << 16));
+		OUT_RING  (rt->pitch | (rt->pitch << 16));
 	}
 
-	nv20mt = (struct nv20_miptree *)rt->texture;
+	nv20mt = (struct nv20_miptree *)rt->base.texture;
 	nv20->rt[0] = nv20mt->buffer;
 
 	if (zeta_format)
 	{
-		nv20mt = (struct nv20_miptree *)zeta->texture;
+		nv20mt = (struct nv20_miptree *)zeta->base.texture;
 		nv20->zeta = nv20mt->buffer;
 	}
 
diff --git a/src/gallium/drivers/nv20/nv20_surface.c b/src/gallium/drivers/nv20/nv20_surface.c
index 6cd607583cf..4224bdd6afa 100644
--- a/src/gallium/drivers/nv20/nv20_surface.c
+++ b/src/gallium/drivers/nv20/nv20_surface.c
@@ -33,7 +33,7 @@
 #include "util/u_tile.h"
 
 static void
-nv20_surface_copy(struct pipe_context *pipe, boolean do_flip,
+nv20_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -41,15 +41,6 @@ nv20_surface_copy(struct pipe_context *pipe, boolean do_flip,
 	struct nv20_context *nv20 = nv20_context(pipe);
 	struct nv04_surface_2d *eng2d = nv20->screen->eng2d;
 
-	if (do_flip) {
-		desty += height;
-		while (height--) {
-			eng2d->copy(eng2d, dest, destx, desty--, src,
-				    srcx, srcy++, width, 1);
-		}
-		return;
-	}
-
 	eng2d->copy(eng2d, dest, destx, desty, src, srcx, srcy, width, height);
 }
 
diff --git a/src/gallium/drivers/nv20/nv20_transfer.c b/src/gallium/drivers/nv20/nv20_transfer.c
new file mode 100644
index 00000000000..e5255296aae
--- /dev/null
+++ b/src/gallium/drivers/nv20/nv20_transfer.c
@@ -0,0 +1,196 @@
+#include <pipe/p_state.h>
+#include <pipe/p_defines.h>
+#include <pipe/p_inlines.h>
+#include <util/u_memory.h>
+#include <nouveau/nouveau_winsys.h>
+#include "nv20_context.h"
+#include "nv20_screen.h"
+#include "nv20_state.h"
+
+struct nv20_transfer {
+	struct pipe_transfer base;
+	struct pipe_surface *surface;
+	bool direct;
+};
+
+static unsigned nv20_usage_tx_to_buf(unsigned tx_usage)
+{
+	switch (tx_usage) {
+		case PIPE_TRANSFER_READ:
+			return PIPE_BUFFER_USAGE_CPU_READ;
+		case PIPE_TRANSFER_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_WRITE;
+		case PIPE_TRANSFER_READ_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+		default:
+			assert(0);
+	}
+
+	return -1;
+}
+
+static void
+nv20_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
+                             struct pipe_texture *template)
+{
+	memset(template, 0, sizeof(struct pipe_texture));
+	template->target = pt->target;
+	template->format = pt->format;
+	template->width[0] = pt->width[level];
+	template->height[0] = pt->height[level];
+	template->depth[0] = 1;
+	template->block = pt->block;
+	template->nblocksx[0] = pt->nblocksx[level];
+	template->nblocksy[0] = pt->nblocksx[level];
+	template->last_level = 0;
+	template->compressed = pt->compressed;
+	template->nr_samples = pt->nr_samples;
+
+	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
+	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+}
+
+static struct pipe_transfer *
+nv20_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv20_miptree *mt = (struct nv20_miptree *)pt;
+	struct nv20_transfer *tx;
+	struct pipe_texture tx_tex_template, *tx_tex;
+
+	tx = CALLOC_STRUCT(nv20_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.x = x;
+	tx->base.y = y;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = mt->level[level].pitch;
+	tx->base.usage = usage;
+	tx->base.face = face;
+	tx->base.level = level;
+	tx->base.zslice = zslice;
+
+	/* Direct access to texture */
+	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
+	     debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
+	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	{
+		tx->direct = true;
+		tx->surface = pscreen->get_tex_surface(pscreen, pt,
+	                                               0, 0, 0,
+	                                               nv20_usage_tx_to_buf(usage));
+		return &tx->base;
+	}
+
+	tx->direct = false;
+
+	nv20_compatible_transfer_tex(pt, level, &tx_tex_template);
+
+	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	if (!tx_tex)
+	{
+		FREE(tx);
+		return NULL;
+	}
+
+	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
+	                                       face, level, zslice,
+	                                       nv20_usage_tx_to_buf(usage));
+
+	pipe_texture_reference(&tx_tex, NULL);
+
+	if (!tx->surface)
+	{
+		pipe_surface_reference(&tx->surface, NULL);
+		FREE(tx);
+		return NULL;
+	}
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		struct nv20_screen *nvscreen = nv20_screen(pscreen);
+		struct pipe_surface *src;
+
+		src = pscreen->get_tex_surface(pscreen, pt,
+	                                       face, level, zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_READ);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		/* TODO: Check if SIFM can un-swizzle */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      tx->surface, 0, 0,
+		                      src, 0, 0,
+		                      src->width, src->height);
+
+		pipe_surface_reference(&src, NULL);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv20_transfer_del(struct pipe_transfer *ptx)
+{
+	struct nv20_transfer *tx = (struct nv20_transfer *)ptx;
+
+	if (!tx->direct && ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		struct nv20_screen *nvscreen = nv20_screen(pscreen);
+		struct pipe_surface *dst;
+
+		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
+	                                       ptx->face, ptx->level, ptx->zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_WRITE);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      dst, 0, 0,
+		                      tx->surface, 0, 0,
+		                      dst->width, dst->height);
+
+		pipe_surface_reference(&dst, NULL);
+	}
+
+	pipe_surface_reference(&tx->surface, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv20_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv20_transfer *tx = (struct nv20_transfer *)ptx;
+	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
+	struct nv20_miptree *mt = (struct nv20_miptree *)tx->surface->texture;
+	void *map = pipe_buffer_map(pscreen, mt->buffer,
+	                            nv20_usage_tx_to_buf(ptx->usage));
+
+	return map + ns->base.offset +
+	       ptx->y * ns->pitch + ptx->x * ptx->block.size;
+}
+
+static void
+nv20_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv20_transfer *tx = (struct nv20_transfer *)ptx;
+	struct nv20_miptree *mt = (struct nv20_miptree *)tx->surface->texture;
+
+	pipe_buffer_unmap(pscreen, mt->buffer);
+}
+
+void
+nv20_screen_init_transfer_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv20_transfer_new;
+	pscreen->tex_transfer_destroy = nv20_transfer_del;
+	pscreen->transfer_map = nv20_transfer_map;
+	pscreen->transfer_unmap = nv20_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv30/Makefile b/src/gallium/drivers/nv30/Makefile
index 69f2790dfe2..364c80d8f3e 100644
--- a/src/gallium/drivers/nv30/Makefile
+++ b/src/gallium/drivers/nv30/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv30
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv30_clear.c \
 	nv30_context.c \
 	nv30_draw.c \
@@ -22,16 +22,8 @@ DRIVER_SOURCES = \
 	nv30_state_viewport.c \
 	nv30_state_zsa.c \
 	nv30_surface.c \
+	nv30_transfer.c \
 	nv30_vbo.c \
 	nv30_vertprog.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv30/nv30_fragprog.c b/src/gallium/drivers/nv30/nv30_fragprog.c
index 320ba3f4bf4..bdfe1425d24 100644
--- a/src/gallium/drivers/nv30/nv30_fragprog.c
+++ b/src/gallium/drivers/nv30/nv30_fragprog.c
@@ -834,6 +834,7 @@ nv30_fragprog_validate(struct nv30_context *nv30)
 	struct nv30_fragment_program *fp = nv30->fragprog;
 	struct pipe_buffer *constbuf =
 		nv30->constbuf[PIPE_SHADER_FRAGMENT];
+	struct pipe_screen *screen = nv30->pipe.screen;
 	struct pipe_winsys *ws = nv30->pipe.winsys;
 	struct nouveau_stateobj *so;
 	boolean new_consts = FALSE;
@@ -849,7 +850,7 @@ nv30_fragprog_validate(struct nv30_context *nv30)
 		return FALSE;
 	}
 
-	fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+	fp->buffer = screen->buffer_create(screen, 0x100, 0, fp->insn_len * 4);
 	nv30_fragprog_upload(nv30, fp);
 
 	so = so_new(8, 1);
@@ -864,6 +865,7 @@ nv30_fragprog_validate(struct nv30_context *nv30)
 	so_method(so, nv30->screen->rankine, NV34TCL_TX_UNITS_ENABLE, 1);
 	so_data  (so, fp->samplers);
 	so_ref(so, &fp->so);
+	so_ref(NULL, &so);
 
 update_constants:
 	if (fp->nr_consts) {
diff --git a/src/gallium/drivers/nv30/nv30_fragtex.c b/src/gallium/drivers/nv30/nv30_fragtex.c
index b1d2663af38..8b6ab992d16 100644
--- a/src/gallium/drivers/nv30/nv30_fragtex.c
+++ b/src/gallium/drivers/nv30/nv30_fragtex.c
@@ -137,6 +137,7 @@ nv30_fragtex_validate(struct nv30_context *nv30)
 		so_method(so, nv30->screen->rankine, NV34TCL_TX_ENABLE(unit), 1);
 		so_data  (so, 0);
 		so_ref(so, &nv30->state.hw[NV30_STATE_FRAGTEX0 + unit]);
+		so_ref(NULL, &so);
 		state->dirty |= (1ULL << (NV30_STATE_FRAGTEX0 + unit));
 	}
 
@@ -147,6 +148,7 @@ nv30_fragtex_validate(struct nv30_context *nv30)
 
 		so = nv30_fragtex_build(nv30, unit);
 		so_ref(so, &nv30->state.hw[NV30_STATE_FRAGTEX0 + unit]);
+		so_ref(NULL, &so);
 		state->dirty |= (1ULL << (NV30_STATE_FRAGTEX0 + unit));
 	}
 
diff --git a/src/gallium/drivers/nv30/nv30_miptree.c b/src/gallium/drivers/nv30/nv30_miptree.c
index 510c94d4e64..d6dc621c9ee 100644
--- a/src/gallium/drivers/nv30/nv30_miptree.c
+++ b/src/gallium/drivers/nv30/nv30_miptree.c
@@ -67,17 +67,16 @@ nv30_miptree_layout(struct nv30_miptree *nv30mt)
 static struct pipe_texture *
 nv30_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 {
-	struct pipe_winsys *ws = pscreen->winsys;
 	struct nv30_miptree *mt;
+	unsigned buf_usage = PIPE_BUFFER_USAGE_PIXEL |
+	                     NOUVEAU_BUFFER_USAGE_TEXTURE;
 
 	mt = MALLOC(sizeof(struct nv30_miptree));
 	if (!mt)
 		return NULL;
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
-	mt->shadow_tex = NULL;
-	mt->shadow_surface = NULL;
 
 	/* Swizzled textures must be POT */
 	if (pt->width[0] & (pt->width[0] - 1) ||
@@ -85,8 +84,8 @@ nv30_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 	else
 	if (pt->tex_usage & (PIPE_TEXTURE_USAGE_PRIMARY |
-+	                     PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-+	                     PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
+	                     PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
+	                     PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
 		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
 	else
 	if (pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC)
@@ -107,11 +106,12 @@ nv30_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 		}
 	}
 
+	if (pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC)
+		buf_usage |= PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+
 	nv30_miptree_layout(mt);
 
-	mt->buffer = ws->buffer_create(ws, 256,
-				       PIPE_BUFFER_USAGE_PIXEL |
-				       NOUVEAU_BUFFER_USAGE_TEXTURE,
+	mt->buffer = pscreen->buffer_create(pscreen, 256, buf_usage,
 				       mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
@@ -137,38 +137,27 @@ nv30_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->level[0].pitch = stride[0];
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
 static void
-nv30_miptree_release(struct pipe_screen *pscreen, struct pipe_texture **ppt)
+nv30_miptree_destroy(struct pipe_texture *pt)
 {
-	struct pipe_texture *pt = *ppt;
 	struct nv30_miptree *mt = (struct nv30_miptree *)pt;
 	int l;
 
-	*ppt = NULL;
-	if (--pt->refcount)
-		return;
-
-	pipe_buffer_reference(pscreen, &mt->buffer, NULL);
+	pipe_buffer_reference(&mt->buffer, NULL);
 	for (l = 0; l <= pt->last_level; l++) {
 		if (mt->level[l].image_offset)
 			FREE(mt->level[l].image_offset);
 	}
 
-	if (mt->shadow_tex) {
-		if (mt->shadow_surface)
-			pscreen->tex_surface_release(pscreen, &mt->shadow_surface);
-		nv30_miptree_release(pscreen, &mt->shadow_tex);
-	}
-
 	FREE(mt);
 }
 
@@ -178,48 +167,38 @@ nv30_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 			 unsigned flags)
 {
 	struct nv30_miptree *nv30mt = (struct nv30_miptree *)pt;
-	struct pipe_surface *ps;
+	struct nv04_surface *ns;
 
-	ps = CALLOC_STRUCT(pipe_surface);
-	if (!ps)
+	ns = CALLOC_STRUCT(nv04_surface);
+	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
-	ps->format = pt->format;
-	ps->width = pt->width[level];
-	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = nv30mt->level[level].pitch;
-	ps->usage = flags;
-	ps->status = PIPE_SURFACE_STATUS_DEFINED;
-	ps->refcount = 1;
-	ps->face = face;
-	ps->level = level;
-	ps->zslice = zslice;
+	pipe_texture_reference(&ns->base.texture, pt);
+	ns->base.format = pt->format;
+	ns->base.width = pt->width[level];
+	ns->base.height = pt->height[level];
+	ns->base.usage = flags;
+	ns->base.status = PIPE_SURFACE_STATUS_DEFINED;
+	pipe_reference_init(&ns->base.reference, 1);
+	ns->base.face = face;
+	ns->base.level = level;
+	ns->base.zslice = zslice;
+	ns->pitch = nv30mt->level[level].pitch;
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
-		ps->offset = nv30mt->level[level].image_offset[face];
+		ns->base.offset = nv30mt->level[level].image_offset[face];
 	} else
 	if (pt->target == PIPE_TEXTURE_3D) {
-		ps->offset = nv30mt->level[level].image_offset[zslice];
+		ns->base.offset = nv30mt->level[level].image_offset[zslice];
 	} else {
-		ps->offset = nv30mt->level[level].image_offset[0];
+		ns->base.offset = nv30mt->level[level].image_offset[0];
 	}
 
-	return ps;
+	return &ns->base;
 }
 
 static void
-nv30_miptree_surface_del(struct pipe_screen *pscreen,
-			 struct pipe_surface **psurface)
+nv30_miptree_surface_del(struct pipe_surface *ps)
 {
-	struct pipe_surface *ps = *psurface;
-
-	*psurface = NULL;
-	if (--ps->refcount > 0)
-		return;
-
 	pipe_texture_reference(&ps->texture, NULL);
 	FREE(ps);
 }
@@ -229,7 +208,7 @@ nv30_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv30_miptree_create;
 	pscreen->texture_blanket = nv30_miptree_blanket;
-	pscreen->texture_release = nv30_miptree_release;
+	pscreen->texture_destroy = nv30_miptree_destroy;
 	pscreen->get_tex_surface = nv30_miptree_surface_new;
-	pscreen->tex_surface_release = nv30_miptree_surface_del;
+	pscreen->tex_surface_destroy = nv30_miptree_surface_del;
 }
diff --git a/src/gallium/drivers/nv30/nv30_screen.c b/src/gallium/drivers/nv30/nv30_screen.c
index c97a73f0b1a..d395c5e1b7f 100644
--- a/src/gallium/drivers/nv30/nv30_screen.c
+++ b/src/gallium/drivers/nv30/nv30_screen.c
@@ -135,82 +135,6 @@ nv30_surface_buffer(struct pipe_surface *surf)
 	return mt->buffer;
 }
 
-static void *
-nv30_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
-		 unsigned flags )
-{
-	struct pipe_winsys	*ws = screen->winsys;
-	struct pipe_surface	*surface_to_map;
-	void			*map;
-
-	if (!(surface->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
-		struct nv30_miptree *mt = (struct nv30_miptree *)surface->texture;
-
-		if (!mt->shadow_tex) {
-			unsigned old_tex_usage = surface->texture->tex_usage;
-			surface->texture->tex_usage = NOUVEAU_TEXTURE_USAGE_LINEAR |
-			                              PIPE_TEXTURE_USAGE_DYNAMIC;
-			mt->shadow_tex = screen->texture_create(screen, surface->texture);
-			surface->texture->tex_usage = old_tex_usage;
-
-			assert(mt->shadow_tex->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR);
-		}
-
-		mt->shadow_surface = screen->get_tex_surface
-		(
-			screen, mt->shadow_tex,
-			surface->face, surface->level, surface->zslice,
-			surface->usage
-		);
-
-		surface_to_map = mt->shadow_surface;
-	}
-	else
-		surface_to_map = surface;
-
-	assert(surface_to_map);
-
-	map = ws->buffer_map(ws, nv30_surface_buffer(surface_to_map), flags);
-	if (!map)
-		return NULL;
-
-	return map + surface_to_map->offset;
-}
-
-static void
-nv30_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
-{
-	struct pipe_winsys	*ws = screen->winsys;
-	struct pipe_surface	*surface_to_unmap;
-
-	/* TODO: Copy from shadow just before push buffer is flushed instead.
-	         There are probably some programs that map/unmap excessively
-	         before rendering. */
-	if (!(surface->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
-		struct nv30_miptree *mt = (struct nv30_miptree *)surface->texture;
-
-		assert(mt->shadow_tex);
-
-		surface_to_unmap = mt->shadow_surface;
-	}
-	else
-		surface_to_unmap = surface;
-
-	assert(surface_to_unmap);
-
-	ws->buffer_unmap(ws, nv30_surface_buffer(surface_to_unmap));
-
-	if (surface_to_unmap != surface) {
-		struct nv30_screen *nvscreen = nv30_screen(screen);
-
-		nvscreen->eng2d->copy(nvscreen->eng2d, surface, 0, 0,
-		                      surface_to_unmap, 0, 0,
-		                      surface->width, surface->height);
-
-		screen->tex_surface_release(screen, &surface_to_unmap);
-	}
-}
-
 static void
 nv30_screen_destroy(struct pipe_screen *pscreen)
 {
@@ -391,10 +315,8 @@ nv30_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 
 	screen->pipe.is_format_supported = nv30_screen_surface_format_supported;
 
-	screen->pipe.surface_map = nv30_surface_map;
-	screen->pipe.surface_unmap = nv30_surface_unmap;
-
 	nv30_screen_init_miptree_functions(&screen->pipe);
+	nv30_screen_init_transfer_functions(&screen->pipe);
 	u_simple_screen_init(&screen->pipe);
 
 	return &screen->pipe;
diff --git a/src/gallium/drivers/nv30/nv30_screen.h b/src/gallium/drivers/nv30/nv30_screen.h
index b11e470f949..8e368839759 100644
--- a/src/gallium/drivers/nv30/nv30_screen.h
+++ b/src/gallium/drivers/nv30/nv30_screen.h
@@ -34,4 +34,7 @@ nv30_screen(struct pipe_screen *screen)
 	return (struct nv30_screen *)screen;
 }
 
+void
+nv30_screen_init_transfer_functions(struct pipe_screen *pscreen);
+
 #endif
diff --git a/src/gallium/drivers/nv30/nv30_state.c b/src/gallium/drivers/nv30/nv30_state.c
index 26147565a53..b91e972c123 100644
--- a/src/gallium/drivers/nv30/nv30_state.c
+++ b/src/gallium/drivers/nv30/nv30_state.c
@@ -51,6 +51,7 @@ nv30_blend_state_create(struct pipe_context *pipe,
 	so_data  (so, cso->dither ? 1 : 0);
 
 	so_ref(so, &bso->so);
+	so_ref(NULL, &so);
 	bso->pipe = *cso;
 	return (void *)bso;
 }
@@ -404,6 +405,7 @@ nv30_rasterizer_state_create(struct pipe_context *pipe,
 	}
 
 	so_ref(so, &rsso->so);
+	so_ref(NULL, &so);
 	rsso->pipe = *cso;
 	return (void *)rsso;
 }
@@ -477,6 +479,7 @@ nv30_depth_stencil_alpha_state_create(struct pipe_context *pipe,
 	}
 
 	so_ref(so, &zsaso->so);
+	so_ref(NULL, &so);
 	zsaso->pipe = *cso;
 	return (void *)zsaso;
 }
diff --git a/src/gallium/drivers/nv30/nv30_state.h b/src/gallium/drivers/nv30/nv30_state.h
index 2023278e377..e6f23bf1667 100644
--- a/src/gallium/drivers/nv30/nv30_state.h
+++ b/src/gallium/drivers/nv30/nv30_state.h
@@ -76,9 +76,6 @@ struct nv30_miptree {
 	struct pipe_buffer *buffer;
 	uint total_size;
 
-	struct pipe_texture *shadow_tex;
-	struct pipe_surface *shadow_surface;
-
 	struct {
 		uint pitch;
 		uint *image_offset;
diff --git a/src/gallium/drivers/nv30/nv30_state_blend.c b/src/gallium/drivers/nv30/nv30_state_blend.c
index 44d43e132a5..64cf9ae93a0 100644
--- a/src/gallium/drivers/nv30/nv30_state_blend.c
+++ b/src/gallium/drivers/nv30/nv30_state_blend.c
@@ -28,6 +28,7 @@ nv30_state_blend_colour_validate(struct nv30_context *nv30)
 		       (float_to_ubyte(bcol->color[2]) <<  0)));
 
 	so_ref(so, &nv30->state.hw[NV30_STATE_BCOL]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_state_fb.c b/src/gallium/drivers/nv30/nv30_state_fb.c
index 77368cb2055..fdc1cade905 100644
--- a/src/gallium/drivers/nv30/nv30_state_fb.c
+++ b/src/gallium/drivers/nv30/nv30_state_fb.c
@@ -5,7 +5,7 @@ static boolean
 nv30_state_framebuffer_validate(struct nv30_context *nv30)
 {
 	struct pipe_framebuffer_state *fb = &nv30->framebuffer;
-	struct pipe_surface *rt[2], *zeta = NULL;
+	struct nv04_surface *rt[2], *zeta = NULL;
 	uint32_t rt_enable, rt_format;
 	int i, colour_format = 0, zeta_format = 0;
 	struct nouveau_stateobj *so = so_new(64, 10);
@@ -21,7 +21,7 @@ nv30_state_framebuffer_validate(struct nv30_context *nv30)
 		} else {
 			colour_format = fb->cbufs[i]->format;
 			rt_enable |= (NV34TCL_RT_ENABLE_COLOR0 << i);
-			rt[i] = fb->cbufs[i];
+			rt[i] = (struct nv04_surface *)fb->cbufs[i];
 		}
 	}
 
@@ -30,13 +30,13 @@ nv30_state_framebuffer_validate(struct nv30_context *nv30)
 
 	if (fb->zsbuf) {
 		zeta_format = fb->zsbuf->format;
-		zeta = fb->zsbuf;
+		zeta = (struct nv04_surface *)fb->zsbuf;
 	}
 
-	if (!(rt[0]->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
+	if (!(rt[0]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
 		assert(!(fb->width & (fb->width - 1)) && !(fb->height & (fb->height - 1)));
 		for (i = 1; i < fb->nr_cbufs; i++)
-			assert(!(rt[i]->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR));
+			assert(!(rt[i]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR));
 
 		/* FIXME: NV34TCL_RT_FORMAT_LOG2_[WIDTH/HEIGHT] */
 		rt_format = NV34TCL_RT_FORMAT_TYPE_SWIZZLED |
@@ -71,44 +71,44 @@ nv30_state_framebuffer_validate(struct nv30_context *nv30)
 	}
 
 	if (rt_enable & NV34TCL_RT_ENABLE_COLOR0) {
-		uint32_t pitch = rt[0]->stride;
+		uint32_t pitch = rt[0]->pitch;
 		if (zeta) {
-			pitch |= (zeta->stride << 16);
+			pitch |= (zeta->pitch << 16);
 		} else {
 			pitch |= (pitch << 16);
 		}
 
-		nv30mt = (struct nv30_miptree *)rt[0]->texture;
+		nv30mt = (struct nv30_miptree *)rt[0]->base.texture;
 		so_method(so, nv30->screen->rankine, NV34TCL_DMA_COLOR0, 1);
 		so_reloc (so, nv30mt->buffer, 0, rt_flags | NOUVEAU_BO_OR,
 			  nv30->nvws->channel->vram->handle,
 			  nv30->nvws->channel->gart->handle);
 		so_method(so, nv30->screen->rankine, NV34TCL_COLOR0_PITCH, 2);
 		so_data  (so, pitch);
-		so_reloc (so, nv30mt->buffer, rt[0]->offset, rt_flags |
+		so_reloc (so, nv30mt->buffer, rt[0]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 	}
 
 	if (rt_enable & NV34TCL_RT_ENABLE_COLOR1) {
-		nv30mt = (struct nv30_miptree *)rt[1]->texture;
+		nv30mt = (struct nv30_miptree *)rt[1]->base.texture;
 		so_method(so, nv30->screen->rankine, NV34TCL_DMA_COLOR1, 1);
 		so_reloc (so, nv30mt->buffer, 0, rt_flags | NOUVEAU_BO_OR,
 			  nv30->nvws->channel->vram->handle,
 			  nv30->nvws->channel->gart->handle);
 		so_method(so, nv30->screen->rankine, NV34TCL_COLOR1_OFFSET, 2);
-		so_reloc (so, nv30mt->buffer, rt[1]->offset, rt_flags |
+		so_reloc (so, nv30mt->buffer, rt[1]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
-		so_data  (so, rt[1]->stride);
+		so_data  (so, rt[1]->pitch);
 	}
 
 	if (zeta_format) {
-		nv30mt = (struct nv30_miptree *)zeta->texture;
+		nv30mt = (struct nv30_miptree *)zeta->base.texture;
 		so_method(so, nv30->screen->rankine, NV34TCL_DMA_ZETA, 1);
 		so_reloc (so, nv30mt->buffer, 0, rt_flags | NOUVEAU_BO_OR,
 			  nv30->nvws->channel->vram->handle,
 			  nv30->nvws->channel->gart->handle);
 		so_method(so, nv30->screen->rankine, NV34TCL_ZETA_OFFSET, 1);
-		so_reloc (so, nv30mt->buffer, zeta->offset, rt_flags |
+		so_reloc (so, nv30mt->buffer, zeta->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 		/* TODO: allocate LMA depth buffer */
 	}
@@ -132,6 +132,7 @@ nv30_state_framebuffer_validate(struct nv30_context *nv30)
 	so_data  (so, 0);
 
 	so_ref(so, &nv30->state.hw[NV30_STATE_FB]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_state_scissor.c b/src/gallium/drivers/nv30/nv30_state_scissor.c
index 1db9bc17955..3ac7a8471ea 100644
--- a/src/gallium/drivers/nv30/nv30_state_scissor.c
+++ b/src/gallium/drivers/nv30/nv30_state_scissor.c
@@ -23,6 +23,7 @@ nv30_state_scissor_validate(struct nv30_context *nv30)
 	}
 
 	so_ref(so, &nv30->state.hw[NV30_STATE_SCISSOR]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_state_stipple.c b/src/gallium/drivers/nv30/nv30_state_stipple.c
index 41b42813b49..d0c791ac082 100644
--- a/src/gallium/drivers/nv30/nv30_state_stipple.c
+++ b/src/gallium/drivers/nv30/nv30_state_stipple.c
@@ -27,6 +27,7 @@ nv30_state_stipple_validate(struct nv30_context *nv30)
 	}
 
 	so_ref(so, &nv30->state.hw[NV30_STATE_STIPPLE]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_state_viewport.c b/src/gallium/drivers/nv30/nv30_state_viewport.c
index 951d40ebfdd..c3eb413dac6 100644
--- a/src/gallium/drivers/nv30/nv30_state_viewport.c
+++ b/src/gallium/drivers/nv30/nv30_state_viewport.c
@@ -7,7 +7,8 @@ nv30_state_viewport_validate(struct nv30_context *nv30)
 	struct nouveau_stateobj *so;
 	unsigned bypass;
 
-	if (/*nv30->render_mode == HW &&*/ !nv30->rasterizer->pipe.bypass_clipping)
+	if (/*nv30->render_mode == HW &&*/
+	    !nv30->rasterizer->pipe.bypass_vs_clip_and_viewport)
 		bypass = 0;
 	else
 		bypass = 1;
@@ -58,6 +59,7 @@ nv30_state_viewport_validate(struct nv30_context *nv30)
 	so_data  (so, 1);
 
 	so_ref(so, &nv30->state.hw[NV30_STATE_VIEWPORT]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_surface.c b/src/gallium/drivers/nv30/nv30_surface.c
index 0f8dc12045a..5e237e13eb5 100644
--- a/src/gallium/drivers/nv30/nv30_surface.c
+++ b/src/gallium/drivers/nv30/nv30_surface.c
@@ -33,7 +33,7 @@
 #include "util/u_tile.h"
 
 static void
-nv30_surface_copy(struct pipe_context *pipe, boolean do_flip,
+nv30_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -41,15 +41,6 @@ nv30_surface_copy(struct pipe_context *pipe, boolean do_flip,
 	struct nv30_context *nv30 = nv30_context(pipe);
 	struct nv04_surface_2d *eng2d = nv30->screen->eng2d;
 
-	if (do_flip) {
-		desty += height;
-		while (height--) {
-			eng2d->copy(eng2d, dest, destx, desty--, src,
-				    srcx, srcy++, width, 1);
-		}
-		return;
-	}
-
 	eng2d->copy(eng2d, dest, destx, desty, src, srcx, srcy, width, height);
 }
 
diff --git a/src/gallium/drivers/nv30/nv30_transfer.c b/src/gallium/drivers/nv30/nv30_transfer.c
new file mode 100644
index 00000000000..8b915b35bd4
--- /dev/null
+++ b/src/gallium/drivers/nv30/nv30_transfer.c
@@ -0,0 +1,196 @@
+#include <pipe/p_state.h>
+#include <pipe/p_defines.h>
+#include <pipe/p_inlines.h>
+#include <util/u_memory.h>
+#include <nouveau/nouveau_winsys.h>
+#include "nv30_context.h"
+#include "nv30_screen.h"
+#include "nv30_state.h"
+
+struct nv30_transfer {
+	struct pipe_transfer base;
+	struct pipe_surface *surface;
+	bool direct;
+};
+
+static unsigned nv30_usage_tx_to_buf(unsigned tx_usage)
+{
+	switch (tx_usage) {
+		case PIPE_TRANSFER_READ:
+			return PIPE_BUFFER_USAGE_CPU_READ;
+		case PIPE_TRANSFER_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_WRITE;
+		case PIPE_TRANSFER_READ_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+		default:
+			assert(0);
+	}
+
+	return -1;
+}
+
+static void
+nv30_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
+                             struct pipe_texture *template)
+{
+	memset(template, 0, sizeof(struct pipe_texture));
+	template->target = pt->target;
+	template->format = pt->format;
+	template->width[0] = pt->width[level];
+	template->height[0] = pt->height[level];
+	template->depth[0] = 1;
+	template->block = pt->block;
+	template->nblocksx[0] = pt->nblocksx[level];
+	template->nblocksy[0] = pt->nblocksx[level];
+	template->last_level = 0;
+	template->compressed = pt->compressed;
+	template->nr_samples = pt->nr_samples;
+
+	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
+	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+}
+
+static struct pipe_transfer *
+nv30_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv30_miptree *mt = (struct nv30_miptree *)pt;
+	struct nv30_transfer *tx;
+	struct pipe_texture tx_tex_template, *tx_tex;
+
+	tx = CALLOC_STRUCT(nv30_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.x = x;
+	tx->base.y = y;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = mt->level[level].pitch;
+	tx->base.usage = usage;
+	tx->base.face = face;
+	tx->base.level = level;
+	tx->base.zslice = zslice;
+
+	/* Direct access to texture */
+	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
+	     debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
+	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	{
+		tx->direct = true;
+		tx->surface = pscreen->get_tex_surface(pscreen, pt,
+	                                               face, level, zslice,
+	                                               nv30_usage_tx_to_buf(usage));
+		return &tx->base;
+	}
+
+	tx->direct = false;
+
+	nv30_compatible_transfer_tex(pt, level, &tx_tex_template);
+
+	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	if (!tx_tex)
+	{
+		FREE(tx);
+		return NULL;
+	}
+
+	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
+	                                       0, 0, 0,
+	                                       nv30_usage_tx_to_buf(usage));
+
+	pipe_texture_reference(&tx_tex, NULL);
+
+	if (!tx->surface)
+	{
+		pipe_surface_reference(&tx->surface, NULL);
+		FREE(tx);
+		return NULL;
+	}
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		struct nv30_screen *nvscreen = nv30_screen(pscreen);
+		struct pipe_surface *src;
+
+		src = pscreen->get_tex_surface(pscreen, pt,
+	                                       face, level, zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_READ);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		/* TODO: Check if SIFM can un-swizzle */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      tx->surface, 0, 0,
+		                      src, 0, 0,
+		                      src->width, src->height);
+
+		pipe_surface_reference(&src, NULL);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv30_transfer_del(struct pipe_transfer *ptx)
+{
+	struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
+
+	if (!tx->direct && ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		struct nv30_screen *nvscreen = nv30_screen(pscreen);
+		struct pipe_surface *dst;
+
+		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
+	                                       ptx->face, ptx->level, ptx->zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_WRITE);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      dst, 0, 0,
+		                      tx->surface, 0, 0,
+		                      dst->width, dst->height);
+
+		pipe_surface_reference(&dst, NULL);
+	}
+
+	pipe_surface_reference(&tx->surface, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv30_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
+	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
+	struct nv30_miptree *mt = (struct nv30_miptree *)tx->surface->texture;
+	void *map = pipe_buffer_map(pscreen, mt->buffer,
+	                            nv30_usage_tx_to_buf(ptx->usage));
+
+	return map + ns->base.offset +
+	       ptx->y * ns->pitch + ptx->x * ptx->block.size;
+}
+
+static void
+nv30_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
+	struct nv30_miptree *mt = (struct nv30_miptree *)tx->surface->texture;
+
+	pipe_buffer_unmap(pscreen, mt->buffer);
+}
+
+void
+nv30_screen_init_transfer_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv30_transfer_new;
+	pscreen->tex_transfer_destroy = nv30_transfer_del;
+	pscreen->transfer_map = nv30_transfer_map;
+	pscreen->transfer_unmap = nv30_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv30/nv30_vbo.c b/src/gallium/drivers/nv30/nv30_vbo.c
index 2d6d48ac161..990a8763824 100644
--- a/src/gallium/drivers/nv30/nv30_vbo.c
+++ b/src/gallium/drivers/nv30/nv30_vbo.c
@@ -539,10 +539,13 @@ nv30_vbo_validate(struct nv30_context *nv30)
 	so_data  (vtxbuf, 0);
 
 	so_ref(vtxbuf, &nv30->state.hw[NV30_STATE_VTXBUF]);
+	so_ref(NULL, &vtxbuf);
 	nv30->state.dirty |= (1ULL << NV30_STATE_VTXBUF);
 	so_ref(vtxfmt, &nv30->state.hw[NV30_STATE_VTXFMT]);
+	so_ref(NULL, &vtxfmt);
 	nv30->state.dirty |= (1ULL << NV30_STATE_VTXFMT);
 	so_ref(sattr, &nv30->state.hw[NV30_STATE_VTXATTR]);
+	so_ref(NULL, &sattr);
 	nv30->state.dirty |= (1ULL << NV30_STATE_VTXATTR);
 	return FALSE;
 }
diff --git a/src/gallium/drivers/nv30/nv30_vertprog.c b/src/gallium/drivers/nv30/nv30_vertprog.c
index d2627250570..eaf543b8f79 100644
--- a/src/gallium/drivers/nv30/nv30_vertprog.c
+++ b/src/gallium/drivers/nv30/nv30_vertprog.c
@@ -685,6 +685,7 @@ nv30_vertprog_validate(struct nv30_context *nv30)
 		so_method(so, rankine, NV34TCL_VP_START_FROM_ID, 1);
 		so_data  (so, vp->exec->start);
 		so_ref(so, &vp->so);
+		so_ref(NULL, &so);
 
 		upload_code = TRUE;
 	}
diff --git a/src/gallium/drivers/nv40/Makefile b/src/gallium/drivers/nv40/Makefile
index 9c8eadf7e44..0ecae2b4913 100644
--- a/src/gallium/drivers/nv40/Makefile
+++ b/src/gallium/drivers/nv40/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv40
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv40_clear.c \
 	nv40_context.c \
 	nv40_draw.c \
@@ -22,16 +22,8 @@ DRIVER_SOURCES = \
 	nv40_state_viewport.c \
 	nv40_state_zsa.c \
 	nv40_surface.c \
+	nv40_transfer.c \
 	nv40_vbo.c \
 	nv40_vertprog.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv40/nv40_fragprog.c b/src/gallium/drivers/nv40/nv40_fragprog.c
index 91dcbebda0d..16e40889ec3 100644
--- a/src/gallium/drivers/nv40/nv40_fragprog.c
+++ b/src/gallium/drivers/nv40/nv40_fragprog.c
@@ -917,6 +917,7 @@ nv40_fragprog_validate(struct nv40_context *nv40)
 	struct nv40_fragment_program *fp = nv40->fragprog;
 	struct pipe_buffer *constbuf =
 		nv40->constbuf[PIPE_SHADER_FRAGMENT];
+	struct pipe_screen *screen = nv40->pipe.screen;
 	struct pipe_winsys *ws = nv40->pipe.winsys;
 	struct nouveau_stateobj *so;
 	boolean new_consts = FALSE;
@@ -932,7 +933,7 @@ nv40_fragprog_validate(struct nv40_context *nv40)
 		return FALSE;
 	}
 
-	fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+	fp->buffer = screen->buffer_create(screen, 0x100, 0, fp->insn_len * 4);
 	nv40_fragprog_upload(nv40, fp);
 
 	so = so_new(4, 1);
@@ -943,6 +944,7 @@ nv40_fragprog_validate(struct nv40_context *nv40)
 	so_method(so, nv40->screen->curie, NV40TCL_FP_CONTROL, 1);
 	so_data  (so, fp->fp_control);
 	so_ref(so, &fp->so);
+	so_ref(NULL, &so);
 
 update_constants:
 	if (fp->nr_consts) {
diff --git a/src/gallium/drivers/nv40/nv40_fragtex.c b/src/gallium/drivers/nv40/nv40_fragtex.c
index 0227d22620d..eb3002dc053 100644
--- a/src/gallium/drivers/nv40/nv40_fragtex.c
+++ b/src/gallium/drivers/nv40/nv40_fragtex.c
@@ -151,6 +151,7 @@ nv40_fragtex_validate(struct nv40_context *nv40)
 
 		so = nv40_fragtex_build(nv40, unit);
 		so_ref(so, &nv40->state.hw[NV40_STATE_FRAGTEX0 + unit]);
+		so_ref(NULL, &so);
 		state->dirty |= (1ULL << (NV40_STATE_FRAGTEX0 + unit));
 	}
 
diff --git a/src/gallium/drivers/nv40/nv40_miptree.c b/src/gallium/drivers/nv40/nv40_miptree.c
index e38b1e7f5ca..abadca8c933 100644
--- a/src/gallium/drivers/nv40/nv40_miptree.c
+++ b/src/gallium/drivers/nv40/nv40_miptree.c
@@ -67,7 +67,6 @@ nv40_miptree_layout(struct nv40_miptree *mt)
 static struct pipe_texture *
 nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 {
-	struct pipe_winsys *ws = pscreen->winsys;
 	struct nv40_miptree *mt;
 	unsigned buf_usage = PIPE_BUFFER_USAGE_PIXEL |
 	                     NOUVEAU_BUFFER_USAGE_TEXTURE;
@@ -76,10 +75,8 @@ nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 	if (!mt)
 		return NULL;
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
-	mt->shadow_tex = NULL;
-	mt->shadow_surface = NULL;
 
 	/* Swizzled textures must be POT */
 	if (pt->width[0] & (pt->width[0] - 1) ||
@@ -114,7 +111,7 @@ nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 
 	nv40_miptree_layout(mt);
 
-	mt->buffer = ws->buffer_create(ws, 256, buf_usage, mt->total_size);
+	mt->buffer = pscreen->buffer_create(pscreen, 256, buf_usage, mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
 		return NULL;
@@ -139,38 +136,27 @@ nv40_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->level[0].pitch = stride[0];
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
 static void
-nv40_miptree_release(struct pipe_screen *pscreen, struct pipe_texture **ppt)
+nv40_miptree_destroy(struct pipe_texture *pt)
 {
-	struct pipe_texture *pt = *ppt;
 	struct nv40_miptree *mt = (struct nv40_miptree *)pt;
 	int l;
 
-	*ppt = NULL;
-	if (--pt->refcount)
-		return;
-
-	pipe_buffer_reference(pscreen, &mt->buffer, NULL);
+	pipe_buffer_reference(&mt->buffer, NULL);
 	for (l = 0; l <= pt->last_level; l++) {
 		if (mt->level[l].image_offset)
 			FREE(mt->level[l].image_offset);
 	}
 
-	if (mt->shadow_tex) {
-		if (mt->shadow_surface)
-			pscreen->tex_surface_release(pscreen, &mt->shadow_surface);
-		nv40_miptree_release(pscreen, &mt->shadow_tex);
-	}
-
 	FREE(mt);
 }
 
@@ -180,48 +166,38 @@ nv40_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 			 unsigned flags)
 {
 	struct nv40_miptree *mt = (struct nv40_miptree *)pt;
-	struct pipe_surface *ps;
+	struct nv04_surface *ns;
 
-	ps = CALLOC_STRUCT(pipe_surface);
-	if (!ps)
+	ns = CALLOC_STRUCT(nv04_surface);
+	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
-	ps->format = pt->format;
-	ps->width = pt->width[level];
-	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = mt->level[level].pitch;
-	ps->usage = flags;
-	ps->status = PIPE_SURFACE_STATUS_DEFINED;
-	ps->refcount = 1;
-	ps->face = face;
-	ps->level = level;
-	ps->zslice = zslice;
+	pipe_texture_reference(&ns->base.texture, pt);
+	ns->base.format = pt->format;
+	ns->base.width = pt->width[level];
+	ns->base.height = pt->height[level];
+	ns->base.usage = flags;
+	ns->base.status = PIPE_SURFACE_STATUS_DEFINED;
+	pipe_reference_init(&ns->base.reference, 1);
+	ns->base.face = face;
+	ns->base.level = level;
+	ns->base.zslice = zslice;
+	ns->pitch = mt->level[level].pitch;
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
-		ps->offset = mt->level[level].image_offset[face];
+		ns->base.offset = mt->level[level].image_offset[face];
 	} else
 	if (pt->target == PIPE_TEXTURE_3D) {
-		ps->offset = mt->level[level].image_offset[zslice];
+		ns->base.offset = mt->level[level].image_offset[zslice];
 	} else {
-		ps->offset = mt->level[level].image_offset[0];
+		ns->base.offset = mt->level[level].image_offset[0];
 	}
 
-	return ps;
+	return &ns->base;
 }
 
 static void
-nv40_miptree_surface_del(struct pipe_screen *pscreen,
-			 struct pipe_surface **psurface)
+nv40_miptree_surface_del(struct pipe_surface *ps)
 {
-	struct pipe_surface *ps = *psurface;
-
-	*psurface = NULL;
-	if (--ps->refcount > 0)
-		return;
-
 	pipe_texture_reference(&ps->texture, NULL);
 	FREE(ps);
 }
@@ -231,8 +207,8 @@ nv40_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv40_miptree_create;
 	pscreen->texture_blanket = nv40_miptree_blanket;
-	pscreen->texture_release = nv40_miptree_release;
+	pscreen->texture_destroy = nv40_miptree_destroy;
 	pscreen->get_tex_surface = nv40_miptree_surface_new;
-	pscreen->tex_surface_release = nv40_miptree_surface_del;
+	pscreen->tex_surface_destroy = nv40_miptree_surface_del;
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_screen.c b/src/gallium/drivers/nv40/nv40_screen.c
index 2372bc84410..0d4baefaea3 100644
--- a/src/gallium/drivers/nv40/nv40_screen.c
+++ b/src/gallium/drivers/nv40/nv40_screen.c
@@ -144,81 +144,6 @@ nv40_surface_buffer(struct pipe_surface *surf)
 	return mt->buffer;
 }
 
-static void *
-nv40_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
-		 unsigned flags )
-{
-	struct pipe_winsys	*ws = screen->winsys;
-	struct pipe_surface	*surface_to_map;
-	void			*map;
-
-	if (!(surface->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
-		struct nv40_miptree *mt = (struct nv40_miptree *)surface->texture;
-
-		if (!mt->shadow_tex) {
-			unsigned old_tex_usage = surface->texture->tex_usage;
-			surface->texture->tex_usage = NOUVEAU_TEXTURE_USAGE_LINEAR |
-			                              PIPE_TEXTURE_USAGE_DYNAMIC;
-			mt->shadow_tex = screen->texture_create(screen, surface->texture);
-			surface->texture->tex_usage = old_tex_usage;
-
-			assert(mt->shadow_tex->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR);
-		}
-
-		mt->shadow_surface = screen->get_tex_surface
-		(
-			screen, mt->shadow_tex,
-			surface->face, surface->level, surface->zslice,
-			surface->usage
-		);
-
-		surface_to_map = mt->shadow_surface;
-	}
-	else
-		surface_to_map = surface;
-
-	assert(surface_to_map);
-	map = ws->buffer_map(ws, nv40_surface_buffer(surface_to_map), flags);
-	if (!map)
-		return NULL;
-
-	return map + surface_to_map->offset;
-}
-
-static void
-nv40_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
-{
-	struct pipe_winsys	*ws = screen->winsys;
-	struct pipe_surface	*surface_to_unmap;
-
-	/* TODO: Copy from shadow just before push buffer is flushed instead.
-	         There are probably some programs that map/unmap excessively
-	         before rendering. */
-	if (!(surface->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
-		struct nv40_miptree *mt = (struct nv40_miptree *)surface->texture;
-
-		assert(mt->shadow_tex);
-
-		surface_to_unmap = mt->shadow_surface;
-	}
-	else
-		surface_to_unmap = surface;
-
-	assert(surface_to_unmap);
-
-	ws->buffer_unmap(ws, nv40_surface_buffer(surface_to_unmap));
-
-	if (surface_to_unmap != surface) {
-		struct nv40_screen *nvscreen = nv40_screen(screen);
-
-		nvscreen->eng2d->copy(nvscreen->eng2d, surface, 0, 0,
-		                      surface_to_unmap, 0, 0,
-		                      surface->width, surface->height);
-
-		screen->tex_surface_release(screen, &surface_to_unmap);
-	}
-}
-
 static void
 nv40_screen_destroy(struct pipe_screen *pscreen)
 {
@@ -240,7 +165,7 @@ nv40_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 {
 	struct nv40_screen *screen = CALLOC_STRUCT(nv40_screen);
 	struct nouveau_stateobj *so;
-	unsigned curie_class;
+	unsigned curie_class = 0;
 	unsigned chipset = nvws->channel->device->chipset;
 	int ret;
 
@@ -265,8 +190,6 @@ nv40_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 		if (NV6X_GRCLASS4497_CHIPSETS & (1 << (chipset & 0x0f)))
 			curie_class = NV44TCL;
 		break;
-	default:
-		break;
 	}
 
 	if (!curie_class) {
@@ -372,10 +295,8 @@ nv40_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 
 	screen->pipe.is_format_supported = nv40_screen_surface_format_supported;
 
-	screen->pipe.surface_map = nv40_surface_map;
-	screen->pipe.surface_unmap = nv40_surface_unmap;
-
 	nv40_screen_init_miptree_functions(&screen->pipe);
+	nv40_screen_init_transfer_functions(&screen->pipe);
 	u_simple_screen_init(&screen->pipe);
 
 	return &screen->pipe;
diff --git a/src/gallium/drivers/nv40/nv40_screen.h b/src/gallium/drivers/nv40/nv40_screen.h
index 4500aa0e5cc..7b503bd207d 100644
--- a/src/gallium/drivers/nv40/nv40_screen.h
+++ b/src/gallium/drivers/nv40/nv40_screen.h
@@ -34,4 +34,7 @@ nv40_screen(struct pipe_screen *screen)
 	return (struct nv40_screen *)screen;
 }
 
+void
+nv40_screen_init_transfer_functions(struct pipe_screen *pscreen);
+
 #endif
diff --git a/src/gallium/drivers/nv40/nv40_state.c b/src/gallium/drivers/nv40/nv40_state.c
index 2eff25aa836..c3ee4d23453 100644
--- a/src/gallium/drivers/nv40/nv40_state.c
+++ b/src/gallium/drivers/nv40/nv40_state.c
@@ -52,6 +52,7 @@ nv40_blend_state_create(struct pipe_context *pipe,
 	so_data  (so, cso->dither ? 1 : 0);
 
 	so_ref(so, &bso->so);
+	so_ref(NULL, &so);
 	bso->pipe = *cso;
 	return (void *)bso;
 }
@@ -414,6 +415,7 @@ nv40_rasterizer_state_create(struct pipe_context *pipe,
 	}
 
 	so_ref(so, &rsso->so);
+	so_ref(NULL, &so);
 	rsso->pipe = *cso;
 	return (void *)rsso;
 }
@@ -487,6 +489,7 @@ nv40_depth_stencil_alpha_state_create(struct pipe_context *pipe,
 	}
 
 	so_ref(so, &zsaso->so);
+	so_ref(NULL, &so);
 	zsaso->pipe = *cso;
 	return (void *)zsaso;
 }
diff --git a/src/gallium/drivers/nv40/nv40_state.h b/src/gallium/drivers/nv40/nv40_state.h
index 9c55903ae30..8a9d8c8fdf6 100644
--- a/src/gallium/drivers/nv40/nv40_state.h
+++ b/src/gallium/drivers/nv40/nv40_state.h
@@ -79,9 +79,6 @@ struct nv40_miptree {
 	struct pipe_buffer *buffer;
 	uint total_size;
 
-	struct pipe_texture *shadow_tex;
-	struct pipe_surface *shadow_surface;
-
 	struct {
 		uint pitch;
 		uint *image_offset;
diff --git a/src/gallium/drivers/nv40/nv40_state_blend.c b/src/gallium/drivers/nv40/nv40_state_blend.c
index 95e6d7394f4..8cd05ce66ef 100644
--- a/src/gallium/drivers/nv40/nv40_state_blend.c
+++ b/src/gallium/drivers/nv40/nv40_state_blend.c
@@ -28,6 +28,7 @@ nv40_state_blend_colour_validate(struct nv40_context *nv40)
 		       (float_to_ubyte(bcol->color[2]) <<  0)));
 
 	so_ref(so, &nv40->state.hw[NV40_STATE_BCOL]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_state_fb.c b/src/gallium/drivers/nv40/nv40_state_fb.c
index 454abad31f4..be618a306bf 100644
--- a/src/gallium/drivers/nv40/nv40_state_fb.c
+++ b/src/gallium/drivers/nv40/nv40_state_fb.c
@@ -12,7 +12,7 @@ static boolean
 nv40_state_framebuffer_validate(struct nv40_context *nv40)
 {
 	struct pipe_framebuffer_state *fb = &nv40->framebuffer;
-	struct pipe_surface *rt[4], *zeta;
+	struct nv04_surface *rt[4], *zeta;
 	uint32_t rt_enable, rt_format;
 	int i, colour_format = 0, zeta_format = 0;
 	struct nouveau_stateobj *so = so_new(64, 10);
@@ -27,7 +27,7 @@ nv40_state_framebuffer_validate(struct nv40_context *nv40)
 		} else {
 			colour_format = fb->cbufs[i]->format;
 			rt_enable |= (NV40TCL_RT_ENABLE_COLOR0 << i);
-			rt[i] = fb->cbufs[i];
+			rt[i] = (struct nv04_surface *)fb->cbufs[i];
 		}
 	}
 
@@ -37,13 +37,13 @@ nv40_state_framebuffer_validate(struct nv40_context *nv40)
 
 	if (fb->zsbuf) {
 		zeta_format = fb->zsbuf->format;
-		zeta = fb->zsbuf;
+		zeta = (struct nv04_surface *)fb->zsbuf;
 	}
 
-	if (!(rt[0]->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
+	if (!(rt[0]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
 		assert(!(fb->width & (fb->width - 1)) && !(fb->height & (fb->height - 1)));
 		for (i = 1; i < fb->nr_cbufs; i++)
-			assert(!(rt[i]->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR));
+			assert(!(rt[i]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR));
 
 		rt_format = NV40TCL_RT_FORMAT_TYPE_SWIZZLED |
 		            log2i(fb->width) << NV40TCL_RT_FORMAT_LOG2_WIDTH_SHIFT |
@@ -78,60 +78,60 @@ nv40_state_framebuffer_validate(struct nv40_context *nv40)
 
 	if (rt_enable & NV40TCL_RT_ENABLE_COLOR0) {
 		so_method(so, nv40->screen->curie, NV40TCL_DMA_COLOR0, 1);
-		so_reloc (so, nv40_surface_buffer(rt[0]), 0, rt_flags | NOUVEAU_BO_OR,
+		so_reloc (so, nv40_surface_buffer(&rt[0]->base), 0, rt_flags | NOUVEAU_BO_OR,
 			  nv40->nvws->channel->vram->handle,
 			  nv40->nvws->channel->gart->handle);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR0_PITCH, 2);
-		so_data  (so, rt[0]->stride);
-		so_reloc (so, nv40_surface_buffer(rt[0]), rt[0]->offset, rt_flags |
+		so_data  (so, rt[0]->pitch);
+		so_reloc (so, nv40_surface_buffer(&rt[0]->base), rt[0]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 	}
 
 	if (rt_enable & NV40TCL_RT_ENABLE_COLOR1) {
 		so_method(so, nv40->screen->curie, NV40TCL_DMA_COLOR1, 1);
-		so_reloc (so, nv40_surface_buffer(rt[1]), 0, rt_flags | NOUVEAU_BO_OR,
+		so_reloc (so, nv40_surface_buffer(&rt[1]->base), 0, rt_flags | NOUVEAU_BO_OR,
 			  nv40->nvws->channel->vram->handle,
 			  nv40->nvws->channel->gart->handle);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR1_OFFSET, 2);
-		so_reloc (so, nv40_surface_buffer(rt[1]), rt[1]->offset, rt_flags |
+		so_reloc (so, nv40_surface_buffer(&rt[1]->base), rt[1]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
-		so_data  (so, rt[1]->stride);
+		so_data  (so, rt[1]->pitch);
 	}
 
 	if (rt_enable & NV40TCL_RT_ENABLE_COLOR2) {
 		so_method(so, nv40->screen->curie, NV40TCL_DMA_COLOR2, 1);
-		so_reloc (so, nv40_surface_buffer(rt[2]), 0, rt_flags | NOUVEAU_BO_OR,
+		so_reloc (so, nv40_surface_buffer(&rt[2]->base), 0, rt_flags | NOUVEAU_BO_OR,
 			  nv40->nvws->channel->vram->handle,
 			  nv40->nvws->channel->gart->handle);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR2_OFFSET, 1);
-		so_reloc (so, nv40_surface_buffer(rt[2]), rt[2]->offset, rt_flags |
+		so_reloc (so, nv40_surface_buffer(&rt[2]->base), rt[2]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR2_PITCH, 1);
-		so_data  (so, rt[2]->stride);
+		so_data  (so, rt[2]->pitch);
 	}
 
 	if (rt_enable & NV40TCL_RT_ENABLE_COLOR3) {
 		so_method(so, nv40->screen->curie, NV40TCL_DMA_COLOR3, 1);
-		so_reloc (so, nv40_surface_buffer(rt[3]), 0, rt_flags | NOUVEAU_BO_OR,
+		so_reloc (so, nv40_surface_buffer(&rt[3]->base), 0, rt_flags | NOUVEAU_BO_OR,
 			  nv40->nvws->channel->vram->handle,
 			  nv40->nvws->channel->gart->handle);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR3_OFFSET, 1);
-		so_reloc (so, nv40_surface_buffer(rt[3]), rt[3]->offset, rt_flags |
+		so_reloc (so, nv40_surface_buffer(&rt[3]->base), rt[3]->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 		so_method(so, nv40->screen->curie, NV40TCL_COLOR3_PITCH, 1);
-		so_data  (so, rt[3]->stride);
+		so_data  (so, rt[3]->pitch);
 	}
 
 	if (zeta_format) {
 		so_method(so, nv40->screen->curie, NV40TCL_DMA_ZETA, 1);
-		so_reloc (so, nv40_surface_buffer(zeta), 0, rt_flags | NOUVEAU_BO_OR,
+		so_reloc (so, nv40_surface_buffer(&zeta->base), 0, rt_flags | NOUVEAU_BO_OR,
 			  nv40->nvws->channel->vram->handle,
 			  nv40->nvws->channel->gart->handle);
 		so_method(so, nv40->screen->curie, NV40TCL_ZETA_OFFSET, 1);
-		so_reloc (so, nv40_surface_buffer(zeta), zeta->offset, rt_flags |
+		so_reloc (so, nv40_surface_buffer(&zeta->base), zeta->base.offset, rt_flags |
 			  NOUVEAU_BO_LOW, 0, 0);
 		so_method(so, nv40->screen->curie, NV40TCL_ZETA_PITCH, 1);
-		so_data  (so, zeta->stride);
+		so_data  (so, zeta->pitch);
 	}
 
 	so_method(so, nv40->screen->curie, NV40TCL_RT_ENABLE, 1);
@@ -150,6 +150,7 @@ nv40_state_framebuffer_validate(struct nv40_context *nv40)
 	so_data  (so, (1 << 12) | h);
 
 	so_ref(so, &nv40->state.hw[NV40_STATE_FB]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_state_scissor.c b/src/gallium/drivers/nv40/nv40_state_scissor.c
index 285239ef419..cf58d33906a 100644
--- a/src/gallium/drivers/nv40/nv40_state_scissor.c
+++ b/src/gallium/drivers/nv40/nv40_state_scissor.c
@@ -23,6 +23,7 @@ nv40_state_scissor_validate(struct nv40_context *nv40)
 	}
 
 	so_ref(so, &nv40->state.hw[NV40_STATE_SCISSOR]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_state_viewport.c b/src/gallium/drivers/nv40/nv40_state_viewport.c
index 869a55b4053..665d2d5fcac 100644
--- a/src/gallium/drivers/nv40/nv40_state_viewport.c
+++ b/src/gallium/drivers/nv40/nv40_state_viewport.c
@@ -7,7 +7,8 @@ nv40_state_viewport_validate(struct nv40_context *nv40)
 	struct nouveau_stateobj *so;
 	unsigned bypass;
 
-	if (nv40->render_mode == HW && !nv40->rasterizer->pipe.bypass_clipping)
+	if (nv40->render_mode == HW &&
+	    !nv40->rasterizer->pipe.bypass_vs_clip_and_viewport)
 		bypass = 0;
 	else
 		bypass = 1;
@@ -55,6 +56,7 @@ nv40_state_viewport_validate(struct nv40_context *nv40)
 	}
 
 	so_ref(so, &nv40->state.hw[NV40_STATE_VIEWPORT]);
+	so_ref(NULL, &so);
 	return TRUE;
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_surface.c b/src/gallium/drivers/nv40/nv40_surface.c
index c4a5fb20d97..1a849da32d7 100644
--- a/src/gallium/drivers/nv40/nv40_surface.c
+++ b/src/gallium/drivers/nv40/nv40_surface.c
@@ -33,7 +33,7 @@
 #include "util/u_tile.h"
 
 static void
-nv40_surface_copy(struct pipe_context *pipe, boolean do_flip,
+nv40_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -41,15 +41,6 @@ nv40_surface_copy(struct pipe_context *pipe, boolean do_flip,
 	struct nv40_context *nv40 = nv40_context(pipe);
 	struct nv04_surface_2d *eng2d = nv40->screen->eng2d;
 
-	if (do_flip) {
-		desty += height;
-		while (height--) {
-			eng2d->copy(eng2d, dest, destx, desty--, src,
-				    srcx, srcy++, width, 1);
-		}
-		return;
-	}
-
 	eng2d->copy(eng2d, dest, destx, desty, src, srcx, srcy, width, height);
 }
 
diff --git a/src/gallium/drivers/nv40/nv40_transfer.c b/src/gallium/drivers/nv40/nv40_transfer.c
new file mode 100644
index 00000000000..728e8b56745
--- /dev/null
+++ b/src/gallium/drivers/nv40/nv40_transfer.c
@@ -0,0 +1,196 @@
+#include <pipe/p_state.h>
+#include <pipe/p_defines.h>
+#include <pipe/p_inlines.h>
+#include <util/u_memory.h>
+#include <nouveau/nouveau_winsys.h>
+#include "nv40_context.h"
+#include "nv40_screen.h"
+#include "nv40_state.h"
+
+struct nv40_transfer {
+	struct pipe_transfer base;
+	struct pipe_surface *surface;
+	bool direct;
+};
+
+static unsigned nv40_usage_tx_to_buf(unsigned tx_usage)
+{
+	switch (tx_usage) {
+		case PIPE_TRANSFER_READ:
+			return PIPE_BUFFER_USAGE_CPU_READ;
+		case PIPE_TRANSFER_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_WRITE;
+		case PIPE_TRANSFER_READ_WRITE:
+			return PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+		default:
+			assert(0);
+	}
+
+	return -1;
+}
+
+static void
+nv40_compatible_transfer_tex(struct pipe_texture *pt, unsigned level,
+                             struct pipe_texture *template)
+{
+	memset(template, 0, sizeof(struct pipe_texture));
+	template->target = pt->target;
+	template->format = pt->format;
+	template->width[0] = pt->width[level];
+	template->height[0] = pt->height[level];
+	template->depth[0] = 1;
+	template->block = pt->block;
+	template->nblocksx[0] = pt->nblocksx[level];
+	template->nblocksy[0] = pt->nblocksx[level];
+	template->last_level = 0;
+	template->compressed = pt->compressed;
+	template->nr_samples = pt->nr_samples;
+
+	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
+	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+}
+
+static struct pipe_transfer *
+nv40_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv40_miptree *mt = (struct nv40_miptree *)pt;
+	struct nv40_transfer *tx;
+	struct pipe_texture tx_tex_template, *tx_tex;
+
+	tx = CALLOC_STRUCT(nv40_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.x = x;
+	tx->base.y = y;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = mt->level[level].pitch;
+	tx->base.usage = usage;
+	tx->base.face = face;
+	tx->base.level = level;
+	tx->base.zslice = zslice;
+
+	/* Direct access to texture */
+	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
+	     debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
+	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	{
+		tx->direct = true;
+		tx->surface = pscreen->get_tex_surface(pscreen, pt,
+	                                               face, level, zslice,
+	                                               nv40_usage_tx_to_buf(usage));
+		return &tx->base;
+	}
+
+	tx->direct = false;
+
+	nv40_compatible_transfer_tex(pt, level, &tx_tex_template);
+
+	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	if (!tx_tex)
+	{
+		FREE(tx);
+		return NULL;
+	}
+
+	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
+	                                       0, 0, 0,
+	                                       nv40_usage_tx_to_buf(usage));
+
+	pipe_texture_reference(&tx_tex, NULL);
+
+	if (!tx->surface)
+	{
+		pipe_surface_reference(&tx->surface, NULL);
+		FREE(tx);
+		return NULL;
+	}
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		struct nv40_screen *nvscreen = nv40_screen(pscreen);
+		struct pipe_surface *src;
+
+		src = pscreen->get_tex_surface(pscreen, pt,
+	                                       face, level, zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_READ);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		/* TODO: Check if SIFM can un-swizzle */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      tx->surface, 0, 0,
+		                      src, 0, 0,
+		                      src->width, src->height);
+
+		pipe_surface_reference(&src, NULL);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv40_transfer_del(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv40_transfer *tx = (struct nv40_transfer *)ptx;
+
+	if (!tx->direct && ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		struct nv40_screen *nvscreen = nv40_screen(pscreen);
+		struct pipe_surface *dst;
+
+		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
+	                                       ptx->face, ptx->level, ptx->zslice,
+	                                       PIPE_BUFFER_USAGE_GPU_WRITE);
+
+		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
+		nvscreen->eng2d->copy(nvscreen->eng2d,
+		                      dst, 0, 0,
+		                      tx->surface, 0, 0,
+		                      dst->width, dst->height);
+
+		pipe_surface_reference(&dst, NULL);
+	}
+
+	pipe_surface_reference(&tx->surface, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv40_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv40_transfer *tx = (struct nv40_transfer *)ptx;
+	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
+	struct nv40_miptree *mt = (struct nv40_miptree *)tx->surface->texture;
+	void *map = pipe_buffer_map(pscreen, mt->buffer,
+	                            nv40_usage_tx_to_buf(ptx->usage));
+
+	return map + ns->base.offset +
+	       ptx->y * ns->pitch + ptx->x * ptx->block.size;
+}
+
+static void
+nv40_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv40_transfer *tx = (struct nv40_transfer *)ptx;
+	struct nv40_miptree *mt = (struct nv40_miptree *)tx->surface->texture;
+
+	pipe_buffer_unmap(pscreen, mt->buffer);
+}
+
+void
+nv40_screen_init_transfer_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv40_transfer_new;
+	pscreen->tex_transfer_destroy = nv40_transfer_del;
+	pscreen->transfer_map = nv40_transfer_map;
+	pscreen->transfer_unmap = nv40_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv40/nv40_vbo.c b/src/gallium/drivers/nv40/nv40_vbo.c
index 8f1834628f7..f3518b2e4fe 100644
--- a/src/gallium/drivers/nv40/nv40_vbo.c
+++ b/src/gallium/drivers/nv40/nv40_vbo.c
@@ -537,10 +537,13 @@ nv40_vbo_validate(struct nv40_context *nv40)
 	so_data  (vtxbuf, 0);
 
 	so_ref(vtxbuf, &nv40->state.hw[NV40_STATE_VTXBUF]);
+	so_ref(NULL, &vtxbuf);
 	nv40->state.dirty |= (1ULL << NV40_STATE_VTXBUF);
 	so_ref(vtxfmt, &nv40->state.hw[NV40_STATE_VTXFMT]);
+	so_ref(NULL, &vtxfmt);
 	nv40->state.dirty |= (1ULL << NV40_STATE_VTXFMT);
 	so_ref(sattr, &nv40->state.hw[NV40_STATE_VTXATTR]);
+	so_ref(NULL, &sattr);
 	nv40->state.dirty |= (1ULL << NV40_STATE_VTXATTR);
 	return FALSE;
 }
diff --git a/src/gallium/drivers/nv40/nv40_vertprog.c b/src/gallium/drivers/nv40/nv40_vertprog.c
index 0862386638c..7df9a4d3264 100644
--- a/src/gallium/drivers/nv40/nv40_vertprog.c
+++ b/src/gallium/drivers/nv40/nv40_vertprog.c
@@ -916,6 +916,7 @@ check_gpu_resources:
 		so_method(so, curie,  NV40TCL_CLIP_PLANE_ENABLE, 1);
 		so_data  (so, vp->clip_ctrl);
 		so_ref(so, &vp->so);
+		so_ref(NULL, &so);
 
 		upload_code = TRUE;
 	}
diff --git a/src/gallium/drivers/nv50/Makefile b/src/gallium/drivers/nv50/Makefile
index be30400c039..612aea28a34 100644
--- a/src/gallium/drivers/nv50/Makefile
+++ b/src/gallium/drivers/nv50/Makefile
@@ -3,7 +3,7 @@ include $(TOP)/configs/current
 
 LIBNAME = nv50
 
-DRIVER_SOURCES = \
+C_SOURCES = \
 	nv50_clear.c \
 	nv50_context.c \
 	nv50_draw.c \
@@ -15,15 +15,7 @@ DRIVER_SOURCES = \
 	nv50_state_validate.c \
 	nv50_surface.c \
 	nv50_tex.c \
+	nv50_transfer.c \
 	nv50_vbo.c
 
-C_SOURCES = \
-	$(COMMON_SOURCES) \
-	$(DRIVER_SOURCES)
-
-ASM_SOURCES = 
-
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/nv50/nv50_context.h b/src/gallium/drivers/nv50/nv50_context.h
index 1e9d45cb340..313e435e7a5 100644
--- a/src/gallium/drivers/nv50/nv50_context.h
+++ b/src/gallium/drivers/nv50/nv50_context.h
@@ -64,10 +64,8 @@ struct nv50_rasterizer_stateobj {
 };
 
 struct nv50_miptree_level {
-	struct pipe_buffer **image;
 	int *image_offset;
-	unsigned image_dirty_cpu[512/32];
-	unsigned image_dirty_gpu[512/32];
+	unsigned pitch;
 };
 
 struct nv50_miptree {
@@ -200,8 +198,4 @@ extern boolean nv50_state_validate(struct nv50_context *nv50);
 /* nv50_tex.c */
 extern void nv50_tex_validate(struct nv50_context *);
 
-/* nv50_miptree.c */
-extern void nv50_miptree_sync(struct pipe_screen *, struct nv50_miptree *,
-			      unsigned level, unsigned image);
-
 #endif
diff --git a/src/gallium/drivers/nv50/nv50_miptree.c b/src/gallium/drivers/nv50/nv50_miptree.c
index 91091d53f57..dc4688ccdc4 100644
--- a/src/gallium/drivers/nv50/nv50_miptree.c
+++ b/src/gallium/drivers/nv50/nv50_miptree.c
@@ -29,7 +29,6 @@
 static struct pipe_texture *
 nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 {
-	struct pipe_winsys *ws = pscreen->winsys;
 	struct nv50_miptree *mt = CALLOC_STRUCT(nv50_miptree);
 	struct pipe_texture *pt = &mt->base;
 	unsigned usage, width = tmp->width[0], height = tmp->height[0];
@@ -37,7 +36,7 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 	int i, l;
 
 	mt->base = *tmp;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 
 	usage = PIPE_BUFFER_USAGE_PIXEL;
@@ -72,7 +71,7 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 		pt->nblocksy[l] = pf_get_nblocksy(&pt->block, height);
 
 		lvl->image_offset = CALLOC(mt->image_nr, sizeof(int));
-		lvl->image = CALLOC(mt->image_nr, sizeof(struct pipe_buffer *));
+		lvl->pitch = align(pt->width[l] * pt->block.size, 64);
 
 		width = MAX2(1, width >> 1);
 		height = MAX2(1, height >> 1);
@@ -88,14 +87,13 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 			size  = align(size, 64);
 			size *= align(pt->height[l], 8) * pt->block.size;
 
-			lvl->image[i] = ws->buffer_create(ws, 256, 0, size);
 			lvl->image_offset[i] = mt->total_size;
 
 			mt->total_size += size;
 		}
 	}
 
-	mt->buffer = ws->buffer_create(ws, 256, usage, mt->total_size);
+	mt->buffer = pscreen->buffer_create(pscreen, 256, usage, mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
 		return NULL;
@@ -120,119 +118,23 @@ nv50_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
 		return NULL;
 
 	mt->base = *pt;
-	mt->base.refcount = 1;
+	pipe_reference_init(&mt->base.reference, 1);
 	mt->base.screen = pscreen;
 	mt->image_nr = 1;
+	mt->level[0].pitch = *stride;
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
-	pipe_buffer_reference(pscreen, &mt->buffer, pb);
+	pipe_buffer_reference(&mt->buffer, pb);
 	return &mt->base;
 }
 
-static INLINE void
-mark_dirty(uint32_t *flags, unsigned image)
-{
-	flags[image / 32] |= (1 << (image % 32));
-}
-
-static INLINE void
-mark_clean(uint32_t *flags, unsigned image)
-{
-	flags[image / 32] &= ~(1 << (image % 32));
-}
-
-static INLINE int
-is_dirty(uint32_t *flags, unsigned image)
-{
-	return !!(flags[image / 32] & (1 << (image % 32)));
-}
-
 static void
-nv50_miptree_release(struct pipe_screen *pscreen, struct pipe_texture **ppt)
-{
-	struct pipe_texture *pt = *ppt;
-
-	*ppt = NULL;
-
-	if (--pt->refcount <= 0) {
-		struct nv50_miptree *mt = nv50_miptree(pt);
-
-		pipe_buffer_reference(pscreen, &mt->buffer, NULL);
-		FREE(mt);
-	}
-}
-
-void
-nv50_miptree_sync(struct pipe_screen *pscreen, struct nv50_miptree *mt,
-		  unsigned level, unsigned image)
+nv50_miptree_destroy(struct pipe_texture *pt)
 {
-	struct nv50_screen *nvscreen = nv50_screen(pscreen);
-	struct nv50_miptree_level *lvl = &mt->level[level];
-	struct pipe_surface *dst, *src;
-	unsigned face = 0, zslice = 0;
-
-	if (!is_dirty(lvl->image_dirty_cpu, image))
-		return;
-
-	if (mt->base.target == PIPE_TEXTURE_CUBE)
-		face = image;
-	else
-	if (mt->base.target == PIPE_TEXTURE_3D)
-		zslice = image;
-
-	/* Mark as clean already - so we don't continually call this function
-	 * trying to get a GPU_WRITE pipe_surface!
-	 */
-	mark_clean(lvl->image_dirty_cpu, image);
-
-	/* Pretend we're doing CPU access so we get the backing pipe_surface
-	 * and not a view into the larger miptree.
-	 */
-	src = pscreen->get_tex_surface(pscreen, &mt->base, face, level, zslice,
-				       PIPE_BUFFER_USAGE_CPU_READ);
-
-	/* Pretend we're only reading with the GPU so surface doesn't get marked
-	 * as dirtied by the GPU.
-	 */
-	dst = pscreen->get_tex_surface(pscreen, &mt->base, face, level, zslice,
-				       PIPE_BUFFER_USAGE_GPU_READ);
-
-	nv50_surface_do_copy(nvscreen, dst, 0, 0, src, 0, 0, dst->width, dst->height);
-
-	pscreen->tex_surface_release(pscreen, &dst);
-	pscreen->tex_surface_release(pscreen, &src);
-}
-
-/* The reverse of the above */
-static void
-nv50_miptree_sync_cpu(struct pipe_screen *pscreen, struct nv50_miptree *mt,
-		      unsigned level, unsigned image)
-{
-	struct nv50_screen *nvscreen = nv50_screen(pscreen);
-	struct nv50_miptree_level *lvl = &mt->level[level];
-	struct pipe_surface *dst, *src;
-	unsigned face = 0, zslice = 0;
-
-	if (!is_dirty(lvl->image_dirty_gpu, image))
-		return;
-
-	if (mt->base.target == PIPE_TEXTURE_CUBE)
-		face = image;
-	else
-	if (mt->base.target == PIPE_TEXTURE_3D)
-		zslice = image;
-
-	mark_clean(lvl->image_dirty_gpu, image);
-
-	src = pscreen->get_tex_surface(pscreen, &mt->base, face, level, zslice,
-				       PIPE_BUFFER_USAGE_GPU_READ);
-	dst = pscreen->get_tex_surface(pscreen, &mt->base, face, level, zslice,
-				       PIPE_BUFFER_USAGE_CPU_READ);
-
-	nv50_surface_do_copy(nvscreen, dst, 0, 0, src, 0, 0, dst->width, dst->height);
+	struct nv50_miptree *mt = nv50_miptree(pt);
 
-	pscreen->tex_surface_release(pscreen, &dst);
-	pscreen->tex_surface_release(pscreen, &src);
+        pipe_buffer_reference(&mt->buffer, NULL);
+        FREE(mt);
 }
 
 static struct pipe_surface *
@@ -260,52 +162,24 @@ nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 	ps->format = pt->format;
 	ps->width = pt->width[level];
 	ps->height = pt->height[level];
-	ps->block = pt->block;
-	ps->nblocksx = pt->nblocksx[level];
-	ps->nblocksy = pt->nblocksy[level];
-	ps->stride = ps->width * ps->block.size;
 	ps->usage = flags;
 	ps->status = PIPE_SURFACE_STATUS_DEFINED;
-	ps->refcount = 1;
+	pipe_reference_init(&ps->reference, 1);
 	ps->face = face;
 	ps->level = level;
 	ps->zslice = zslice;
-
-	if (flags & PIPE_BUFFER_USAGE_CPU_READ_WRITE) {
-		assert(!(flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE));
-		nv50_miptree_sync_cpu(pscreen, mt, level, img);
-
-		ps->offset = 0;
-		pipe_texture_reference(&ps->texture, pt);
-
-		if (flags & PIPE_BUFFER_USAGE_CPU_WRITE)
-			mark_dirty(lvl->image_dirty_cpu, img);
-	} else {
-		nv50_miptree_sync(pscreen, mt, level, img);
-
-		ps->offset = lvl->image_offset[img];
-		pipe_texture_reference(&ps->texture, pt);
-
-		if (flags & PIPE_BUFFER_USAGE_GPU_WRITE)
-			mark_dirty(lvl->image_dirty_gpu, img);
-	}
+	ps->offset = lvl->image_offset[img];
 
 	return ps;
 }
 
 static void
-nv50_miptree_surface_del(struct pipe_screen *pscreen,
-			 struct pipe_surface **psurface)
+nv50_miptree_surface_del(struct pipe_surface *ps)
 {
-	struct pipe_surface *ps = *psurface;
 	struct nv50_surface *s = nv50_surface(ps);
 
-	*psurface = NULL;
-
-	if (--ps->refcount <= 0) {
-		pipe_texture_reference(&ps->texture, NULL);
-		FREE(s);
-	}
+        pipe_texture_reference(&ps->texture, NULL);
+        FREE(s);
 }
 
 void
@@ -313,8 +187,8 @@ nv50_screen_init_miptree_functions(struct pipe_screen *pscreen)
 {
 	pscreen->texture_create = nv50_miptree_create;
 	pscreen->texture_blanket = nv50_miptree_blanket;
-	pscreen->texture_release = nv50_miptree_release;
+	pscreen->texture_destroy = nv50_miptree_destroy;
 	pscreen->get_tex_surface = nv50_miptree_surface_new;
-	pscreen->tex_surface_release = nv50_miptree_surface_del;
+	pscreen->tex_surface_destroy = nv50_miptree_surface_del;
 }
 
diff --git a/src/gallium/drivers/nv50/nv50_program.c b/src/gallium/drivers/nv50/nv50_program.c
index 14c5d47e790..2d15868ae84 100644
--- a/src/gallium/drivers/nv50/nv50_program.c
+++ b/src/gallium/drivers/nv50/nv50_program.c
@@ -1603,7 +1603,7 @@ nv50_program_validate_code(struct nv50_context *nv50, struct nv50_program *p)
 {
 	struct nouveau_channel *chan = nv50->screen->nvws->channel;
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
-	struct pipe_winsys *ws = nv50->pipe.winsys;
+	struct pipe_screen *screen = nv50->pipe.screen;
 	struct nv50_program_exec *e;
 	struct nouveau_stateobj *so;
 	const unsigned flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_WR;
@@ -1611,7 +1611,7 @@ nv50_program_validate_code(struct nv50_context *nv50, struct nv50_program *p)
 	boolean upload = FALSE;
 
 	if (!p->buffer) {
-		p->buffer = ws->buffer_create(ws, 0x100, 0, p->exec_size * 4);
+		p->buffer = screen->buffer_create(screen, 0x100, 0, p->exec_size * 4);
 		upload = TRUE;
 	}
 
@@ -1719,6 +1719,7 @@ nv50_vertprog_validate(struct nv50_context *nv50)
 	so_method(so, tesla, 0x140c, 1);
 	so_data  (so, 0); /* program start offset */
 	so_ref(so, &nv50->state.vertprog);
+	so_ref(NULL, &so);
 }
 
 void
@@ -1758,6 +1759,7 @@ nv50_fragprog_validate(struct nv50_context *nv50)
 	so_method(so, tesla, 0x1414, 1);
 	so_data  (so, 0); /* program start offset */
 	so_ref(so, &nv50->state.fragprog);
+	so_ref(NULL, &so);
 }
 
 void
@@ -1775,7 +1777,7 @@ nv50_program_destroy(struct nv50_context *nv50, struct nv50_program *p)
 	p->exec_size = 0;
 
 	if (p->buffer)
-		pipe_buffer_reference(pscreen, &p->buffer, NULL);
+		pipe_buffer_reference(&p->buffer, NULL);
 
 	nv50->screen->nvws->res_free(&p->data);
 
diff --git a/src/gallium/drivers/nv50/nv50_query.c b/src/gallium/drivers/nv50/nv50_query.c
index 20745ceab8b..a2c56f99a89 100644
--- a/src/gallium/drivers/nv50/nv50_query.c
+++ b/src/gallium/drivers/nv50/nv50_query.c
@@ -41,13 +41,13 @@ nv50_query(struct pipe_query *pipe)
 static struct pipe_query *
 nv50_query_create(struct pipe_context *pipe, unsigned type)
 {
-	struct pipe_winsys *ws = pipe->winsys;
+	struct pipe_screen *screen = pipe->winsys;
 	struct nv50_query *q = CALLOC_STRUCT(nv50_query);
 
 	assert (q->type == PIPE_QUERY_OCCLUSION_COUNTER);
 	q->type = type;
 
-	q->buffer = ws->buffer_create(ws, 256, 0, 16);
+	q->buffer = screen->buffer_create(screen, 256, 0, 16);
 	if (!q->buffer) {
 		FREE(q);
 		return NULL;
@@ -62,7 +62,7 @@ nv50_query_destroy(struct pipe_context *pipe, struct pipe_query *pq)
 	struct nv50_query *q = nv50_query(pq);
 
 	if (q) {
-		pipe_buffer_reference(pipe->screen, &q->buffer, NULL);
+		pipe_buffer_reference(&q->buffer, NULL);
 		FREE(q);
 	}
 }
@@ -90,11 +90,12 @@ nv50_query_end(struct pipe_context *pipe, struct pipe_query *pq)
 	struct nouveau_channel *chan = nv50->screen->nvws->channel;
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
 	struct nv50_query *q = nv50_query(pq);
+	struct nouveau_bo *bo = nv50->screen->nvws->get_bo(q->buffer);
 
 	WAIT_RING (chan, 5);
 	BEGIN_RING(chan, tesla, 0x1b00, 4);
-	OUT_RELOCh(chan, q->buffer, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
-	OUT_RELOCl(chan, q->buffer, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
+	OUT_RELOCh(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
+	OUT_RELOCl(chan, bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 	OUT_RING  (chan, 0x00000000);
 	OUT_RING  (chan, 0x0100f002);
 	FIRE_RING (chan);
diff --git a/src/gallium/drivers/nv50/nv50_screen.c b/src/gallium/drivers/nv50/nv50_screen.c
index 58d7a621a80..29805645948 100644
--- a/src/gallium/drivers/nv50/nv50_screen.c
+++ b/src/gallium/drivers/nv50/nv50_screen.c
@@ -29,10 +29,6 @@
 
 #include "nouveau/nouveau_stateobj.h"
 
-#define NV5X_GRCLASS5097_CHIPSETS 0x00000001
-#define NV8X_GRCLASS8297_CHIPSETS 0x00000050
-#define NV9X_GRCLASS8297_CHIPSETS 0x00000014
-
 static boolean
 nv50_screen_is_format_supported(struct pipe_screen *pscreen,
 				enum pipe_format format,
@@ -124,9 +120,9 @@ nv50_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 1;
 	case PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS:
 		return 0;
-	case NOUVEAU_CAP_HW_VTXBUF:	
+	case NOUVEAU_CAP_HW_VTXBUF:
 		return 1;
-	case NOUVEAU_CAP_HW_IDXBUF:	
+	case NOUVEAU_CAP_HW_IDXBUF:
 		return 0;
 	default:
 		NOUVEAU_ERR("Unknown PIPE_CAP %d\n", param);
@@ -173,36 +169,38 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 		return NULL;
 	screen->nvws = nvws;
 
-	/* 2D object */
-	ret = nvws->grobj_alloc(nvws, NV50_2D, &screen->eng2d);
+	/* DMA engine object */
+	ret = nvws->grobj_alloc(nvws, 0x5039, &screen->m2mf);
 	if (ret) {
-		NOUVEAU_ERR("Error creating 2D object: %d\n", ret);
+		NOUVEAU_ERR("Error creating M2MF object: %d\n", ret);
 		nv50_screen_destroy(&screen->pipe);
 		return NULL;
 	}
 
-	/* 3D object */
-	if ((chipset & 0xf0) != 0x50 && (chipset & 0xf0) != 0x80) {
-		NOUVEAU_ERR("Not a G8x chipset\n");
+	/* 2D object */
+	ret = nvws->grobj_alloc(nvws, NV50_2D, &screen->eng2d);
+	if (ret) {
+		NOUVEAU_ERR("Error creating 2D object: %d\n", ret);
 		nv50_screen_destroy(&screen->pipe);
 		return NULL;
 	}
 
+	/* 3D object */
 	switch (chipset & 0xf0) {
 	case 0x50:
-		if (NV5X_GRCLASS5097_CHIPSETS & (1 << (chipset & 0x0f)))
-			tesla_class = 0x5097;
+		tesla_class = 0x5097;
 		break;
 	case 0x80:
-		if (NV8X_GRCLASS8297_CHIPSETS & (1 << (chipset & 0x0f)))
-			tesla_class = 0x8297;
-		break;
 	case 0x90:
-		if (NV9X_GRCLASS8297_CHIPSETS & (1 << (chipset & 0x0f)))
-			tesla_class = 0x8297;
+		tesla_class = 0x8297;
 		break;
-	default:
+	case 0xa0:
+		tesla_class = 0x8397;
 		break;
+	default:
+		NOUVEAU_ERR("Not a known NV50 chipset: NV%02x\n", chipset);
+		nv50_screen_destroy(&screen->pipe);
+		return NULL;
 	}
 
 	if (tesla_class == 0) {
@@ -226,6 +224,31 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 		return NULL;
 	}
 
+        /* Setup the pipe */
+	screen->pipe.winsys = ws;
+
+	screen->pipe.destroy = nv50_screen_destroy;
+
+	screen->pipe.get_name = nv50_screen_get_name;
+	screen->pipe.get_vendor = nv50_screen_get_vendor;
+	screen->pipe.get_param = nv50_screen_get_param;
+	screen->pipe.get_paramf = nv50_screen_get_paramf;
+
+	screen->pipe.is_format_supported = nv50_screen_is_format_supported;
+
+	nv50_screen_init_miptree_functions(&screen->pipe);
+	nv50_transfer_init_screen_functions(&screen->pipe);
+	u_simple_screen_init(&screen->pipe);
+
+	/* Static M2MF init */
+	so = so_new(32, 0);
+	so_method(so, screen->m2mf, 0x0180, 3);
+	so_data  (so, screen->sync->handle);
+	so_data  (so, screen->nvws->channel->vram->handle);
+	so_data  (so, screen->nvws->channel->vram->handle);
+	so_emit(nvws, so);
+	so_ref (NULL, &so);
+
 	/* Static 2D init */
 	so = so_new(64, 0);
 	so_method(so, screen->eng2d, NV50_2D_DMA_NOTIFY, 4);
@@ -268,7 +291,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 	so_data  (so, 8);
 
 	/* Shared constant buffer */
-	screen->constbuf = ws->buffer_create(ws, 0, 0, 128 * 4 * 4);
+	screen->constbuf = screen->pipe.buffer_create(&screen->pipe, 0, 0, 128 * 4 * 4);
 	if (nvws->res_init(&screen->vp_data_heap, 0, 128)) {
 		NOUVEAU_ERR("Error initialising constant buffer\n");
 		nv50_screen_destroy(&screen->pipe);
@@ -287,7 +310,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 	 * blocks.  At some point we *may* want to go the NVIDIA way of doing
 	 * things?
 	 */
-	screen->tic = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
+	screen->tic = screen->pipe.buffer_create(&screen->pipe, 0, 0, 32 * 8 * 4);
 	so_method(so, screen->tesla, 0x1280, 3);
 	so_reloc (so, screen->tic, 0, NOUVEAU_BO_VRAM |
 		  NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);
@@ -301,7 +324,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 		  NOUVEAU_BO_RD | NOUVEAU_BO_LOW, 0, 0);
 	so_data  (so, 0x00000800);
 
-	screen->tsc = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
+	screen->tsc = screen->pipe.buffer_create(&screen->pipe, 0, 0, 32 * 8 * 4);
 	so_method(so, screen->tesla, 0x1280, 3);
 	so_reloc (so, screen->tsc, 0, NOUVEAU_BO_VRAM |
 		  NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);
@@ -333,24 +356,10 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 	so_data  (so, 1);
 
 	so_emit(nvws, so);
-	so_ref(so, &screen->static_init);
+	so_ref (so, &screen->static_init);
+	so_ref (NULL, &so);
 	nvws->push_flush(nvws, 0, NULL);
 
-	screen->pipe.winsys = ws;
-
-	screen->pipe.destroy = nv50_screen_destroy;
-
-	screen->pipe.get_name = nv50_screen_get_name;
-	screen->pipe.get_vendor = nv50_screen_get_vendor;
-	screen->pipe.get_param = nv50_screen_get_param;
-	screen->pipe.get_paramf = nv50_screen_get_paramf;
-
-	screen->pipe.is_format_supported = nv50_screen_is_format_supported;
-
-	nv50_screen_init_miptree_functions(&screen->pipe);
-	nv50_surface_init_screen_functions(&screen->pipe);
-	u_simple_screen_init(&screen->pipe);
-
 	return &screen->pipe;
 }
 
diff --git a/src/gallium/drivers/nv50/nv50_screen.h b/src/gallium/drivers/nv50/nv50_screen.h
index c888ca071c8..db567aaac89 100644
--- a/src/gallium/drivers/nv50/nv50_screen.h
+++ b/src/gallium/drivers/nv50/nv50_screen.h
@@ -12,6 +12,7 @@ struct nv50_screen {
 
 	struct nouveau_grobj *tesla;
 	struct nouveau_grobj *eng2d;
+	struct nouveau_grobj *m2mf;
 	struct nouveau_notifier *sync;
 
 	struct pipe_buffer *constbuf;
@@ -29,6 +30,6 @@ nv50_screen(struct pipe_screen *screen)
 	return (struct nv50_screen *)screen;
 }
 
-void nv50_surface_init_screen_functions(struct pipe_screen *);
+void nv50_transfer_init_screen_functions(struct pipe_screen *);
 
 #endif
diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c
index 787ff958ec7..ba852194cdd 100644
--- a/src/gallium/drivers/nv50/nv50_state.c
+++ b/src/gallium/drivers/nv50/nv50_state.c
@@ -85,6 +85,7 @@ nv50_blend_state_create(struct pipe_context *pipe,
 
 	bso->pipe = *cso;
 	so_ref(so, &bso->so);
+	so_ref(NULL, &so);
 	return (void *)bso;
 }
 
@@ -352,6 +353,7 @@ nv50_rasterizer_state_create(struct pipe_context *pipe,
 
 	rso->pipe = *cso;
 	so_ref(so, &rso->so);
+	so_ref(NULL, &so);
 	return (void *)rso;
 }
 
@@ -438,6 +440,7 @@ nv50_depth_stencil_alpha_state_create(struct pipe_context *pipe,
 
 	zsa->pipe = *cso;
 	so_ref(so, &zsa->so);
+	so_ref(NULL, &so);
 	return (void *)zsa;
 }
 
diff --git a/src/gallium/drivers/nv50/nv50_state_validate.c b/src/gallium/drivers/nv50/nv50_state_validate.c
index 948112ffa9f..85098a78a25 100644
--- a/src/gallium/drivers/nv50/nv50_state_validate.c
+++ b/src/gallium/drivers/nv50/nv50_state_validate.c
@@ -124,6 +124,7 @@ nv50_state_validate_fb(struct nv50_context *nv50)
 	so_data  (so, h);
 
 	so_ref(so, &nv50->state.fb);
+	so_ref(NULL, &so);
 }
 
 static void
@@ -214,6 +215,7 @@ nv50_state_validate(struct nv50_context *nv50)
 		so_data  (so, fui(nv50->blend_colour.color[2]));
 		so_data  (so, fui(nv50->blend_colour.color[3]));
 		so_ref(so, &nv50->state.blend_colour);
+		so_ref(NULL, &so);
 	}
 
 	if (nv50->dirty & NV50_NEW_STIPPLE) {
@@ -222,6 +224,7 @@ nv50_state_validate(struct nv50_context *nv50)
 		for (i = 0; i < 32; i++)
 			so_data(so, nv50->stipple.stipple[i]);
 		so_ref(so, &nv50->state.stipple);
+		so_ref(NULL, &so);
 	}
 
 	if (nv50->dirty & (NV50_NEW_SCISSOR | NV50_NEW_RASTERIZER)) {
@@ -243,6 +246,7 @@ nv50_state_validate(struct nv50_context *nv50)
 			so_data(so, (8192 << 16));
 		}
 		so_ref(so, &nv50->state.scissor);
+		so_ref(NULL, &so);
 		nv50->state.dirty |= NV50_NEW_SCISSOR;
 	}
 scissor_uptodate:
@@ -250,7 +254,7 @@ scissor_uptodate:
 	if (nv50->dirty & NV50_NEW_VIEWPORT) {
 		unsigned bypass;
 
-		if (!nv50->rasterizer->pipe.bypass_clipping)
+		if (!nv50->rasterizer->pipe.bypass_vs_clip_and_viewport)
 			bypass = 0;
 		else
 			bypass = 1;
@@ -283,6 +287,7 @@ scissor_uptodate:
 		}
 
 		so_ref(so, &nv50->state.viewport);
+		so_ref(NULL, &so);
 	}
 viewport_uptodate:
 
@@ -296,6 +301,7 @@ viewport_uptodate:
 		for (i = 0; i < nv50->sampler_nr; i++)
 			so_datap (so, nv50->sampler[i], 8);
 		so_ref(so, &nv50->state.tsc_upload);
+		so_ref(NULL, &so);
 	}
 
 	if (nv50->dirty & NV50_NEW_TEXTURE)
diff --git a/src/gallium/drivers/nv50/nv50_surface.c b/src/gallium/drivers/nv50/nv50_surface.c
index f2dd2eb30be..0cc5168144d 100644
--- a/src/gallium/drivers/nv50/nv50_surface.c
+++ b/src/gallium/drivers/nv50/nv50_surface.c
@@ -51,6 +51,7 @@ nv50_format(enum pipe_format format)
 static int
 nv50_surface_set(struct nv50_screen *screen, struct pipe_surface *ps, int dst)
 {
+	struct nv50_miptree *mt = nv50_miptree(ps->texture);
 	struct nouveau_channel *chan = screen->nvws->channel;
 	struct nouveau_grobj *eng2d = screen->eng2d;
 	struct nouveau_bo *bo;
@@ -70,7 +71,7 @@ nv50_surface_set(struct nv50_screen *screen, struct pipe_surface *ps, int dst)
  		OUT_RING  (chan, format);
  		OUT_RING  (chan, 1);
  		BEGIN_RING(chan, eng2d, mthd + 0x14, 5);
- 		OUT_RING  (chan, ps->stride);
+ 		OUT_RING  (chan, mt->level[0].pitch);
  		OUT_RING  (chan, ps->width);
  		OUT_RING  (chan, ps->height);
  		OUT_RELOCh(chan, bo, ps->offset, flags);
@@ -143,7 +144,7 @@ nv50_surface_do_copy(struct nv50_screen *screen, struct pipe_surface *dst,
 }
 
 static void
-nv50_surface_copy(struct pipe_context *pipe, boolean flip,
+nv50_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dest, unsigned destx, unsigned desty,
 		  struct pipe_surface *src, unsigned srcx, unsigned srcy,
 		  unsigned width, unsigned height)
@@ -153,16 +154,8 @@ nv50_surface_copy(struct pipe_context *pipe, boolean flip,
 
 	assert(src->format == dest->format);
 
-	if (flip) {
-		desty += height;
-		while (height--) {
-			nv50_surface_do_copy(screen, dest, destx, desty--, src,
-					     srcx, srcy++, width, 1);
-		}
-	} else {
-		nv50_surface_do_copy(screen, dest, destx, desty, src, srcx,
+	nv50_surface_do_copy(screen, dest, destx, desty, src, srcx,
 				     srcy, width, height);
-	}
 }
 
 static void
@@ -197,23 +190,6 @@ nv50_surface_fill(struct pipe_context *pipe, struct pipe_surface *dest,
 	OUT_RING  (chan, height);
 }
 
-static void *
-nv50_surface_map(struct pipe_screen *screen, struct pipe_surface *ps,
-		 unsigned flags )
-{
-	struct pipe_winsys *ws = screen->winsys;
-
-	return ws->buffer_map(ws, nv50_surface_buffer(ps), flags);
-}
-
-static void
-nv50_surface_unmap(struct pipe_screen *pscreen, struct pipe_surface *ps)
-{
-	struct pipe_winsys *ws = pscreen->winsys;
-
-	ws->buffer_unmap(ws, nv50_surface_buffer(ps));
-}
-
 void
 nv50_init_surface_functions(struct nv50_context *nv50)
 {
@@ -221,10 +197,4 @@ nv50_init_surface_functions(struct nv50_context *nv50)
 	nv50->pipe.surface_fill = nv50_surface_fill;
 }
 
-void
-nv50_surface_init_screen_functions(struct pipe_screen *pscreen)
-{
-	pscreen->surface_map = nv50_surface_map;
-	pscreen->surface_unmap = nv50_surface_unmap;
-}
 
diff --git a/src/gallium/drivers/nv50/nv50_tex.c b/src/gallium/drivers/nv50/nv50_tex.c
index 675f9b20cbc..223c8a3a456 100644
--- a/src/gallium/drivers/nv50/nv50_tex.c
+++ b/src/gallium/drivers/nv50/nv50_tex.c
@@ -135,7 +135,7 @@ nv50_tex_validate(struct nv50_context *nv50)
 {
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
 	struct nouveau_stateobj *so;
-	int unit, level, image;
+	int unit;
 
 	so = so_new(nv50->miptree_nr * 8 + 3, nv50->miptree_nr * 2);
 	so_method(so, tesla, 0x0f00, 1);
@@ -144,13 +144,6 @@ nv50_tex_validate(struct nv50_context *nv50)
 	for (unit = 0; unit < nv50->miptree_nr; unit++) {
 		struct nv50_miptree *mt = nv50->miptree[unit];
 
-		for (level = 0; level <= mt->base.last_level; level++) {
-			for (image = 0; image < mt->image_nr; image++) {
-				nv50_miptree_sync(&nv50->screen->pipe, mt,
-						  level, image);
-			}
-		}
-
 		if (nv50_tex_construct(so, mt)) {
 			NOUVEAU_ERR("failed tex validate\n");
 			so_ref(NULL, &so);
@@ -159,5 +152,6 @@ nv50_tex_validate(struct nv50_context *nv50)
 	}
 
 	so_ref(so, &nv50->state.tic_upload);
+	so_ref(NULL, &so);
 }
 
diff --git a/src/gallium/drivers/nv50/nv50_transfer.c b/src/gallium/drivers/nv50/nv50_transfer.c
new file mode 100644
index 00000000000..747195b4f63
--- /dev/null
+++ b/src/gallium/drivers/nv50/nv50_transfer.c
@@ -0,0 +1,211 @@
+
+#include "pipe/p_context.h"
+#include "pipe/p_inlines.h"
+
+#include "nv50_context.h"
+
+struct nv50_transfer {
+	struct pipe_transfer base;
+	struct pipe_buffer *buffer;
+	struct nv50_miptree_level *level;
+	int level_pitch;
+	int level_width;
+	int level_height;
+	int level_x;
+	int level_y;
+};
+
+static void
+nv50_transfer_rect_m2mf(struct pipe_screen *pscreen, struct pipe_buffer *src,
+			int src_pitch, int sx, int sy, int sw, int sh,
+			struct pipe_buffer *dst, int dst_pitch, int dx, int dy,
+			int dw, int dh, int cpp, int width, int height,
+			unsigned src_reloc, unsigned dst_reloc)
+{
+	struct nv50_screen *screen = nv50_screen(pscreen);
+	struct nouveau_winsys *nvws = screen->nvws;
+	struct nouveau_channel *chan = nvws->channel;
+	struct nouveau_grobj *m2mf = screen->m2mf;
+	struct nouveau_bo *src_bo = nvws->get_bo(src);
+	struct nouveau_bo *dst_bo = nvws->get_bo(dst);
+	unsigned src_offset = 0, dst_offset = 0;
+
+	src_reloc |= NOUVEAU_BO_RD;
+	dst_reloc |= NOUVEAU_BO_WR;
+
+	WAIT_RING (chan, 14);
+
+	if (!src_bo->tiled) {
+		BEGIN_RING(chan, m2mf, 0x0200, 1);
+		OUT_RING  (chan, 1);
+		BEGIN_RING(chan, m2mf, 0x0314, 1);
+		OUT_RING  (chan, src_pitch);
+		src_offset = (sy * src_pitch) + (sx * cpp);
+	} else {
+		BEGIN_RING(chan, m2mf, 0x0200, 6);
+		OUT_RING  (chan, 0);
+		OUT_RING  (chan, 0);
+		OUT_RING  (chan, sw * cpp);
+		OUT_RING  (chan, sh);
+		OUT_RING  (chan, 1);
+		OUT_RING  (chan, 0);
+	}
+
+	if (!dst_bo->tiled) {
+		BEGIN_RING(chan, m2mf, 0x021c, 1);
+		OUT_RING  (chan, 1);
+		BEGIN_RING(chan, m2mf, 0x0318, 1);
+		OUT_RING  (chan, dst_pitch);
+		dst_offset = (dy * dst_pitch) + (dx * cpp);
+	} else {
+		BEGIN_RING(chan, m2mf, 0x021c, 6);
+		OUT_RING  (chan, 0);
+		OUT_RING  (chan, 0);
+		OUT_RING  (chan, dw * cpp);
+		OUT_RING  (chan, dh);
+		OUT_RING  (chan, 1);
+		OUT_RING  (chan, 0);
+	}
+
+	while (height) {
+		int line_count = height > 2047 ? 2047 : height;
+
+		WAIT_RING (chan, 15);
+		BEGIN_RING(chan, m2mf, 0x0238, 2);
+		OUT_RELOCh(chan, src_bo, src_offset, src_reloc);
+		OUT_RELOCh(chan, dst_bo, dst_offset, dst_reloc);
+		BEGIN_RING(chan, m2mf, 0x030c, 2);
+		OUT_RELOCl(chan, src_bo, src_offset, src_reloc);
+		OUT_RELOCl(chan, dst_bo, dst_offset, dst_reloc);
+		if (src_bo->tiled) {
+			BEGIN_RING(chan, m2mf, 0x0218, 1);
+			OUT_RING  (chan, (dy << 16) | sx);
+		} else {
+			src_offset += (line_count * src_pitch);
+		}
+		if (dst_bo->tiled) {
+			BEGIN_RING(chan, m2mf, 0x0234, 1);
+			OUT_RING  (chan, (sy << 16) | dx);
+		} else {
+			dst_offset += (line_count * dst_pitch);
+		}
+		BEGIN_RING(chan, m2mf, 0x031c, 4);
+		OUT_RING  (chan, width * cpp);
+		OUT_RING  (chan, line_count);
+		OUT_RING  (chan, 0x00000101);
+		OUT_RING  (chan, 0);
+		FIRE_RING (chan);
+
+		height -= line_count;
+		sy += line_count;
+		dy += line_count;
+	}
+}
+
+static struct pipe_transfer *
+nv50_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+		  unsigned face, unsigned level, unsigned zslice,
+		  enum pipe_transfer_usage usage,
+		  unsigned x, unsigned y, unsigned w, unsigned h)
+{
+	struct nv50_miptree *mt = nv50_miptree(pt);
+	struct nv50_miptree_level *lvl = &mt->level[level];
+	struct nv50_transfer *tx;
+	unsigned image = 0;
+
+	if (pt->target == PIPE_TEXTURE_CUBE)
+		image = face;
+	else
+	if (pt->target == PIPE_TEXTURE_3D)
+		image = zslice;
+
+	tx = CALLOC_STRUCT(nv50_transfer);
+	if (!tx)
+		return NULL;
+
+	pipe_texture_reference(&tx->base.texture, pt);
+	tx->base.format = pt->format;
+	tx->base.width = w;
+	tx->base.height = h;
+	tx->base.block = pt->block;
+	tx->base.nblocksx = pt->nblocksx[level];
+	tx->base.nblocksy = pt->nblocksy[level];
+	tx->base.stride = (w * pt->block.size);
+	tx->base.usage = usage;
+
+	tx->level = lvl;
+	tx->level_pitch = lvl->pitch;
+	tx->level_width = mt->base.width[level];
+	tx->level_height = mt->base.height[level];
+	tx->level_x = x;
+	tx->level_y = y;
+	tx->buffer =
+		pipe_buffer_create(pscreen, 0, NOUVEAU_BUFFER_USAGE_TRANSFER,
+				   w * tx->base.block.size * h);
+
+	if (usage != PIPE_TRANSFER_WRITE) {
+		nv50_transfer_rect_m2mf(pscreen, mt->buffer, tx->level_pitch,
+					x, y, tx->level_width, tx->level_height,
+					tx->buffer, tx->base.stride, 0, 0,
+					tx->base.width, tx->base.height,
+					tx->base.block.size, w, h,
+					NOUVEAU_BO_VRAM | NOUVEAU_BO_GART,
+					NOUVEAU_BO_GART);
+	}
+
+	return &tx->base;
+}
+
+static void
+nv50_transfer_del(struct pipe_transfer *ptx)
+{
+	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
+	struct nv50_miptree *mt = nv50_miptree(ptx->texture);
+
+	if (ptx->usage != PIPE_TRANSFER_READ) {
+		struct pipe_screen *pscreen = ptx->texture->screen;
+		nv50_transfer_rect_m2mf(pscreen, tx->buffer, tx->base.stride,
+					0, 0, tx->base.width, tx->base.height,
+					mt->buffer, tx->level_pitch,
+					tx->level_x, tx->level_y,
+					tx->level_width, tx->level_height,
+					tx->base.block.size, tx->base.width,
+					tx->base.height, NOUVEAU_BO_GART,
+					NOUVEAU_BO_VRAM | NOUVEAU_BO_GART);
+	}
+
+	pipe_buffer_reference(&tx->buffer, NULL);
+	pipe_texture_reference(&ptx->texture, NULL);
+	FREE(ptx);
+}
+
+static void *
+nv50_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
+	unsigned flags = 0;
+
+	if (ptx->usage & PIPE_TRANSFER_WRITE)
+		flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+	if (ptx->usage & PIPE_TRANSFER_READ)
+		flags |= PIPE_BUFFER_USAGE_CPU_READ;
+
+	return pipe_buffer_map(pscreen, tx->buffer, flags);
+}
+
+static void
+nv50_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
+{
+	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
+
+	pipe_buffer_unmap(pscreen, tx->buffer);
+}
+
+void
+nv50_transfer_init_screen_functions(struct pipe_screen *pscreen)
+{
+	pscreen->get_tex_transfer = nv50_transfer_new;
+	pscreen->tex_transfer_destroy = nv50_transfer_del;
+	pscreen->transfer_map = nv50_transfer_map;
+	pscreen->transfer_unmap = nv50_transfer_unmap;
+}
diff --git a/src/gallium/drivers/nv50/nv50_vbo.c b/src/gallium/drivers/nv50/nv50_vbo.c
index 0c970adb03a..0749c906914 100644
--- a/src/gallium/drivers/nv50/nv50_vbo.c
+++ b/src/gallium/drivers/nv50/nv50_vbo.c
@@ -202,7 +202,7 @@ nv50_vbo_validate(struct nv50_context *nv50)
 {
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
 	struct nouveau_stateobj *vtxbuf, *vtxfmt;
-	int i, vpi = 0;
+	int i;
 
 	vtxbuf = so_new(nv50->vtxelt_nr * 4, nv50->vtxelt_nr * 2);
 	vtxfmt = so_new(nv50->vtxelt_nr + 1, 0);
@@ -250,5 +250,7 @@ nv50_vbo_validate(struct nv50_context *nv50)
 
 	so_ref (vtxfmt, &nv50->state.vtxfmt);
 	so_ref (vtxbuf, &nv50->state.vtxbuf);
+	so_ref (NULL, &vtxbuf);
+	so_ref (NULL, &vtxfmt);
 }
 
diff --git a/src/gallium/drivers/r300/Makefile b/src/gallium/drivers/r300/Makefile
index e83d943cd84..0e4e1155325 100644
--- a/src/gallium/drivers/r300/Makefile
+++ b/src/gallium/drivers/r300/Makefile
@@ -7,15 +7,17 @@ C_SOURCES = \
 	r300_chipset.c \
 	r300_clear.c \
 	r300_context.c \
+	r300_debug.c \
 	r300_emit.c \
 	r300_flush.c \
+	r300_query.c \
 	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 \
 	r300_texture.c
 
 include ../../Makefile.template
-
-symlinks:
diff --git a/src/gallium/drivers/r300/r300_chipset.c b/src/gallium/drivers/r300/r300_chipset.c
index 7def62422a0..e01a0546b22 100644
--- a/src/gallium/drivers/r300/r300_chipset.c
+++ b/src/gallium/drivers/r300/r300_chipset.c
@@ -21,7 +21,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
 #include "r300_chipset.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 /* r300_chipset: A file all to itself for deducing the various properties of
  * Radeons. */
@@ -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:
@@ -343,6 +350,6 @@ void r300_parse_chipset(struct r300_capabilities* caps)
             break;
     }
 
-    /* Force off TCL for now */
-    caps->has_tcl = FALSE;
+    /* XXX SW TCL is broken so no forcing it off right now
+    caps->has_tcl = FALSE; */
 }
diff --git a/src/gallium/drivers/r300/r300_chipset.h b/src/gallium/drivers/r300/r300_chipset.h
index a9cd372ec55..21eebeae600 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 7b605ae87ac..b8584702aad 100644
--- a/src/gallium/drivers/r300/r300_context.c
+++ b/src/gallium/drivers/r300/r300_context.c
@@ -22,18 +22,87 @@
 
 #include "r300_context.h"
 
+static boolean r300_draw_range_elements(struct pipe_context* pipe,
+                                        struct pipe_buffer* indexBuffer,
+                                        unsigned indexSize,
+                                        unsigned minIndex,
+                                        unsigned maxIndex,
+                                        unsigned mode,
+                                        unsigned start,
+                                        unsigned count)
+{
+    struct r300_context* r300 = r300_context(pipe);
+    int i;
+
+    if (r300->dirty_state) {
+        r300_emit_dirty_state(r300);
+    }
+
+    for (i = 0; i < r300->vertex_buffer_count; i++) {
+        void* buf = pipe_buffer_map(pipe->screen,
+                                    r300->vertex_buffers[i].buffer,
+                                    PIPE_BUFFER_USAGE_CPU_READ);
+        draw_set_mapped_vertex_buffer(r300->draw, i, buf);
+    }
+
+    if (indexBuffer) {
+        void* indices = pipe_buffer_map(pipe->screen, indexBuffer,
+                                        PIPE_BUFFER_USAGE_CPU_READ);
+        draw_set_mapped_element_buffer_range(r300->draw, indexSize,
+                                             minIndex, maxIndex, indices);
+    } else {
+        draw_set_mapped_element_buffer(r300->draw, 0, NULL);
+    }
+
+    draw_set_mapped_constant_buffer(r300->draw,
+            r300->shader_constants[PIPE_SHADER_VERTEX].constants,
+            r300->shader_constants[PIPE_SHADER_VERTEX].user_count *
+                (sizeof(float) * 4));
+
+    draw_arrays(r300->draw, mode, start, count);
+
+    for (i = 0; i < r300->vertex_buffer_count; i++) {
+        pipe_buffer_unmap(pipe->screen, r300->vertex_buffers[i].buffer);
+        draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
+    }
+
+    if (indexBuffer) {
+        pipe_buffer_unmap(pipe->screen, indexBuffer);
+        draw_set_mapped_element_buffer_range(r300->draw, 0, start,
+                                             start + count - 1, NULL);
+    }
+
+    return TRUE;
+}
+
+static boolean r300_draw_elements(struct pipe_context* pipe,
+                                  struct pipe_buffer* indexBuffer,
+                                  unsigned indexSize, unsigned mode,
+                                  unsigned start, unsigned count)
+{
+    return r300_draw_range_elements(pipe, indexBuffer, indexSize, 0, ~0,
+                                    mode, start, count);
+}
+
+static boolean r300_draw_arrays(struct pipe_context* pipe, unsigned mode,
+                                unsigned start, unsigned count)
+{
+    return r300_draw_elements(pipe, NULL, 0, mode, start, count);
+}
+
 static void r300_destroy_context(struct pipe_context* context) {
     struct r300_context* r300 = r300_context(context);
 
     draw_destroy(r300->draw);
 
     FREE(r300->blend_color_state);
+    FREE(r300->rs_block);
     FREE(r300->scissor_state);
+    FREE(r300->viewport_state);
     FREE(r300);
 }
 
 struct pipe_context* r300_create_context(struct pipe_screen* screen,
-                                         struct pipe_winsys* winsys,
                                          struct r300_winsys* r300_winsys)
 {
     struct r300_context* r300 = CALLOC_STRUCT(r300_context);
@@ -41,26 +110,37 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
     if (!r300)
         return NULL;
 
+    /* XXX this could be refactored now? */
     r300->winsys = r300_winsys;
-    r300->context.winsys = winsys;
-    r300->context.screen = r300_create_screen(winsys, r300_winsys);
+
+    r300->context.winsys = (struct pipe_winsys*)r300_winsys;
+    r300->context.screen = r300_screen(screen);
 
     r300->context.destroy = r300_destroy_context;
 
     r300->context.clear = r300_clear;
 
+    r300->context.draw_arrays = r300_draw_arrays;
+    r300->context.draw_elements = r300_draw_elements;
+    r300->context.draw_range_elements = r300_draw_range_elements;
+
     r300->draw = draw_create();
-    /*XXX draw_set_rasterize_stage(r300->draw, r300_draw_swtcl_stage(r300));*/
+    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->viewport_state = CALLOC_STRUCT(r300_viewport_state);
 
     r300_init_flush_functions(r300);
 
+    r300_init_query_functions(r300);
+
     r300_init_surface_functions(r300);
 
     r300_init_state_functions(r300);
 
+    r300_emit_invariant_state(r300);
     r300->dirty_state = R300_NEW_KITCHEN_SINK;
     r300->dirty_hw++;
 
diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h
index 376c57639d8..0e5e471d116 100644
--- a/src/gallium/drivers/r300/r300_context.h
+++ b/src/gallium/drivers/r300/r300_context.h
@@ -24,11 +24,13 @@
 #define R300_CONTEXT_H
 
 #include "draw/draw_context.h"
+#include "draw/draw_vertex.h"
 #include "pipe/p_context.h"
 #include "tgsi/tgsi_scan.h"
 #include "util/u_memory.h"
 
 #include "r300_clear.h"
+#include "r300_query.h"
 #include "r300_screen.h"
 #include "r300_winsys.h"
 
@@ -58,8 +60,12 @@ struct r300_dsa_state {
 };
 
 struct r300_rs_state {
+    /* XXX icky as fucking hell */
+    struct pipe_rasterizer_state rs;
+
     uint32_t vap_control_status;    /* R300_VAP_CNTL_STATUS: 0x2140 */
     uint32_t point_size;            /* R300_GA_POINT_SIZE: 0x421c */
+    uint32_t point_minmax;          /* R300_GA_POINT_MINMAX: 0x4230 */
     uint32_t line_control;          /* R300_GA_LINE_CNTL: 0x4234 */
     uint32_t depth_scale_front;  /* R300_SU_POLY_OFFSET_FRONT_SCALE: 0x42a4 */
     uint32_t depth_offset_front;/* R300_SU_POLY_OFFSET_FRONT_OFFSET: 0x42a8 */
@@ -69,6 +75,14 @@ struct r300_rs_state {
     uint32_t cull_mode;             /* R300_SU_CULL_MODE: 0x42b8 */
     uint32_t line_stipple_config;   /* R300_GA_LINE_STIPPLE_CONFIG: 0x4328 */
     uint32_t line_stipple_value;    /* R300_GA_LINE_STIPPLE_VALUE: 0x4260 */
+    uint32_t color_control;         /* R300_GA_COLOR_CONTROL: 0x4278 */
+};
+
+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 {
@@ -83,23 +97,52 @@ struct r300_scissor_state {
 };
 
 struct r300_texture_state {
+    uint32_t format0; /* R300_TX_FORMAT0: 0x4480 */
+    uint32_t format1; /* R300_TX_FORMAT1: 0x44c0 */
+    uint32_t format2; /* R300_TX_FORMAT2: 0x4500 */
+};
+
+struct r300_viewport_state {
+    float xscale;         /* R300_VAP_VPORT_XSCALE:  0x2098 */
+    float xoffset;        /* R300_VAP_VPORT_XOFFSET: 0x209c */
+    float yscale;         /* R300_VAP_VPORT_YSCALE:  0x20a0 */
+    float yoffset;        /* R300_VAP_VPORT_YOFFSET: 0x20a4 */
+    float zscale;         /* R300_VAP_VPORT_ZSCALE:  0x20a8 */
+    float zoffset;        /* R300_VAP_VPORT_ZOFFSET: 0x20ac */
+    uint32_t vte_control; /* R300_VAP_VTE_CNTL:      0x20b0 */
 };
 
-#define R300_NEW_BLEND           0x000001
-#define R300_NEW_BLEND_COLOR     0x000002
-#define R300_NEW_DSA             0x000004
-#define R300_NEW_FRAMEBUFFERS    0x000008
-#define R300_NEW_FRAGMENT_SHADER 0x000010
-#define R300_NEW_RASTERIZER      0x000020
-#define R300_NEW_SAMPLER         0x000040
-#define R300_NEW_SCISSOR         0x004000
-#define R300_NEW_TEXTURE         0x008000
-#define R300_NEW_VERTEX_SHADER   0x800000
-#define R300_NEW_KITCHEN_SINK    0xffffff
+#define R300_NEW_BLEND           0x0000001
+#define R300_NEW_BLEND_COLOR     0x0000002
+#define R300_NEW_CONSTANTS       0x0000004
+#define R300_NEW_DSA             0x0000008
+#define R300_NEW_FRAMEBUFFERS    0x0000010
+#define R300_NEW_FRAGMENT_SHADER 0x0000020
+#define R300_NEW_RASTERIZER      0x0000040
+#define R300_NEW_RS_BLOCK        0x0000080
+#define R300_NEW_SAMPLER         0x0000100
+#define R300_ANY_NEW_SAMPLERS    0x000ff00
+#define R300_NEW_SCISSOR         0x0010000
+#define R300_NEW_TEXTURE         0x0020000
+#define R300_ANY_NEW_TEXTURES    0x1fe0000
+#define R300_NEW_VERTEX_FORMAT   0x2000000
+#define R300_NEW_VERTEX_SHADER   0x4000000
+#define R300_NEW_VIEWPORT        0x8000000
+#define R300_NEW_KITCHEN_SINK    0xfffffff
 
 /* The next several objects are not pure Radeon state; they inherit from
  * various Gallium classes. */
 
+struct r300_constant_buffer {
+    /* Buffer of constants */
+    /* XXX first number should be raised */
+    float constants[8][4];
+    /* Number of user-defined constants */
+    int user_count;
+    /* Total number of constants */
+    int count;
+};
+
 struct r3xx_fragment_shader {
     /* Parent class */
     struct pipe_shader_state state;
@@ -107,16 +150,55 @@ struct r3xx_fragment_shader {
 
     /* Has this shader been translated yet? */
     boolean translated;
+
+    /* Pixel stack size */
+    int stack_size;
 };
 
 struct r300_fragment_shader {
     /* Parent class */
     struct r3xx_fragment_shader shader;
+
+    /* Number of ALU instructions */
+    int alu_instruction_count;
+
+    /* Number of texture instructions */
+    int tex_instruction_count;
+
+    /* Number of texture indirections */
+    int indirections;
+
+    /* Indirection node offsets */
+    int offset0;
+    int offset1;
+    int offset2;
+    int offset3;
+
+    /* Machine instructions */
+    struct {
+        uint32_t alu_rgb_inst;
+        uint32_t alu_rgb_addr;
+        uint32_t alu_alpha_inst;
+        uint32_t alu_alpha_addr;
+    } instructions[64]; /* XXX magic num */
 };
 
 struct r500_fragment_shader {
     /* Parent class */
     struct r3xx_fragment_shader shader;
+
+    /* Number of used instructions */
+    int instruction_count;
+
+    /* Machine instructions */
+    struct {
+        uint32_t inst0;
+        uint32_t inst1;
+        uint32_t inst2;
+        uint32_t inst3;
+        uint32_t inst4;
+        uint32_t inst5;
+    } instructions[256]; /*< XXX magic number */
 };
 
 struct r300_texture {
@@ -126,11 +208,30 @@ struct r300_texture {
     /* Offsets into the buffer. */
     unsigned offset[PIPE_MAX_TEXTURE_LEVELS];
 
+    /* Stride (pitch?) of this texture in bytes */
+    unsigned stride;
+    
     /* Total size of this texture, in bytes. */
     unsigned size;
 
     /* Pipe buffer backing this texture. */
     struct pipe_buffer* buffer;
+
+    /* Registers carrying texture format data. */
+    struct r300_texture_state state;
+};
+
+struct r300_vertex_format {
+    /* Parent class */
+    struct vertex_info vinfo;
+    /* R300_VAP_PROG_STREAK_CNTL_[0-7] */
+    uint32_t vap_prog_stream_cntl[8];
+    /* R300_VAP_PROG_STREAK_CNTL_EXT_[0-7] */
+    uint32_t vap_prog_stream_cntl_ext[8];
+    /* This is a map of VAP/SW TCL outputs into the GA/RS.
+     * tab[i] is the location of input i in GA/RS input memory.
+     * Named tab for historical reasons. */
+    int tab[16];
 };
 
 struct r300_context {
@@ -147,6 +248,8 @@ struct r300_context {
     struct r300_blend_state* blend_state;
     /* Blend color state. */
     struct r300_blend_color_state* blend_color_state;
+    /* Shader constants. */
+    struct r300_constant_buffer shader_constants[PIPE_SHADER_TYPES];
     /* Depth, stencil, and alpha state. */
     struct r300_dsa_state* dsa_state;
     /* Fragment shader. */
@@ -155,6 +258,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;
@@ -162,8 +267,14 @@ struct r300_context {
     struct r300_scissor_state* scissor_state;
     /* Texture states. */
     struct r300_texture* textures[8];
-    struct r300_texture_state* texture_states[8];
     int texture_count;
+    /* Vertex buffers. */
+    struct pipe_vertex_buffer vertex_buffers[PIPE_MAX_ATTRIBS];
+    int vertex_buffer_count;
+    /* Vertex information. */
+    struct r300_vertex_format vertex_info;
+    /* Viewport state. */
+    struct r300_viewport_state* viewport_state;
     /* Bitmask of dirty state objects. */
     uint32_t dirty_state;
     /* Flag indicating whether or not the HW is dirty. */
@@ -176,6 +287,7 @@ static struct r300_context* r300_context(struct pipe_context* context) {
 }
 
 /* Context initialization. */
+struct draw_stage* r300_draw_swtcl_stage(struct r300_context* r300);
 void r300_init_state_functions(struct r300_context* r300);
 void r300_init_surface_functions(struct r300_context* r300);
 
@@ -183,7 +295,6 @@ void r300_init_surface_functions(struct r300_context* r300);
  * We'll just step out in that case... */
 #ifndef R300_WINSYS_H
 struct pipe_context* r300_create_context(struct pipe_screen* screen,
-                                         struct pipe_winsys* winsys,
                                          struct r300_winsys* r300_winsys);
 #endif
 
diff --git a/src/gallium/drivers/r300/r300_cs.h b/src/gallium/drivers/r300/r300_cs.h
index 385b61a096c..d8038ff1e19 100644
--- a/src/gallium/drivers/r300/r300_cs.h
+++ b/src/gallium/drivers/r300/r300_cs.h
@@ -23,27 +23,19 @@
 #ifndef R300_CS_H
 #define R300_CS_H
 
+#include "util/u_math.h"
+
 #include "r300_reg.h"
 #include "r300_winsys.h"
 
-/* Pack a 32-bit 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;
-}
-
 /* Yes, I know macros are ugly. However, they are much prettier than the code
  * that they neatly hide away, and don't have the cost of function setup,so
  * we're going to use them. */
 
 #define MAX_CS_SIZE 64 * 1024 / 4
 
+#define VERY_VERBOSE_REGISTERS 0
+
 /* XXX stolen from radeon_drm.h */
 #define RADEON_GEM_DOMAIN_CPU  0x1
 #define RADEON_GEM_DOMAIN_GTT  0x2
@@ -80,13 +72,14 @@ static uint32_t pack_float_32(float f)
 } while (0)
 
 #define OUT_CS_32F(value) do { \
-    cs_winsys->write_cs_dword(cs, pack_float_32(value)); \
+    cs_winsys->write_cs_dword(cs, fui(value)); \
     cs_count--; \
 } while (0)
 
 #define OUT_CS_REG(register, value) do { \
-    debug_printf("r300: writing 0x%08X to register 0x%04X\n", \
-        value, register); \
+    if (VERY_VERBOSE_REGISTERS) \
+        debug_printf("r300: writing 0x%08X to register 0x%04X\n", \
+            value, register); \
     assert(register); \
     OUT_CS(CP_PACKET0(register, 0)); \
     OUT_CS(value); \
@@ -95,8 +88,9 @@ static uint32_t pack_float_32(float f)
 /* Note: This expects count to be the number of registers,
  * not the actual packet0 count! */
 #define OUT_CS_REG_SEQ(register, count) do { \
-    debug_printf("r300: writing register sequence of %d to 0x%04X\n", \
-        count, register); \
+    if (VERY_VERBOSE_REGISTERS) \
+        debug_printf("r300: writing register sequence of %d to 0x%04X\n", \
+            count, register); \
     assert(register); \
     OUT_CS(CP_PACKET0(register, ((count) - 1))); \
 } while (0)
@@ -119,7 +113,7 @@ static uint32_t pack_float_32(float f)
 } while (0)
 
 #define FLUSH_CS do { \
-    debug_printf("r300: FLUSH_CS in %s (%s:%d)\n", __FUNCTION__, __FILE__, \
+    debug_printf("r300: FLUSH_CS in %s (%s:%d)\n\n", __FUNCTION__, __FILE__, \
         __LINE__); \
     cs_winsys->flush_cs(cs); \
 } while (0)
diff --git a/src/gallium/drivers/r300/r300_cs_inlines.h b/src/gallium/drivers/r300/r300_cs_inlines.h
index 71e66236991..03bb608eb9a 100644
--- a/src/gallium/drivers/r300/r300_cs_inlines.h
+++ b/src/gallium/drivers/r300/r300_cs_inlines.h
@@ -26,12 +26,25 @@
 
 #ifdef R300_CS_H
 
+#define RADEON_ONE_REG_WR        (1 << 15)
+
+#define OUT_CS_ONE_REG(register, count) do { \
+    if (VERY_VERBOSE_REGISTERS) \
+        debug_printf("r300: writing data sequence of %d to 0x%04X\n", \
+            count, register); \
+    assert(register); \
+    OUT_CS(CP_PACKET0(register, ((count) - 1)) | RADEON_ONE_REG_WR); \
+} while (0)
+
 #define R300_PACIFY do { \
+    OUT_CS_REG(RADEON_WAIT_UNTIL, (1 << 14) | (1 << 15) | (1 << 16) | (1 << 17) | \
+        (1 << 18)); \
+} while (0)
+
+#define R300_SCREENDOOR do { \
     OUT_CS_REG(R300_SC_SCREENDOOR, 0x0); \
-    OUT_CS_REG(RADEON_WAIT_UNTIL, (1 << 15) | (1 << 17) | \
-        (1 << 18) | (1 << 31)); \
+    R300_PACIFY; \
     OUT_CS_REG(R300_SC_SCREENDOOR, 0xffffff); \
 } while (0)
 
-
 #endif /* R300_CS_H */
diff --git a/src/gallium/drivers/r300/r300_debug.c b/src/gallium/drivers/r300/r300_debug.c
new file mode 100644
index 00000000000..f657588c720
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_debug.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2009 Corbin Simpson <[email protected]>
+ *
+ * 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_debug.h"
+
+static char* r500_fs_swiz[] = {
+    " R",
+    " G",
+    " B",
+    " A",
+    " 0",
+    ".5",
+    " 1",
+    " U",
+};
+
+static char* r500_fs_op_rgb[] = {
+    "MAD",
+    "DP3",
+    "DP4",
+    "D2A",
+    "MIN",
+    "MAX",
+    "---",
+    "CND",
+    "CMP",
+    "FRC",
+    "SOP",
+    "MDH",
+    "MDV",
+};
+
+static char* r500_fs_op_alpha[] = {
+    "MAD",
+    " DP",
+    "MIN",
+    "MAX",
+    "---",
+    "CND",
+    "CMP",
+    "FRC",
+    "EX2",
+    "LN2",
+    "RCP",
+    "RSQ",
+    "SIN",
+    "COS",
+    "MDH",
+    "MDV",
+};
+
+static char* r500_fs_mask[] = {
+    "NONE",
+    "R   ",
+    " G  ",
+    "RG  ",
+    "  B ",
+    "R B ",
+    " GB ",
+    "RGB ",
+    "   A",
+    "R  A",
+    " G A",
+    "RG A",
+    "  BA",
+    "R BA",
+    " GBA",
+    "RGBA",
+};
+
+static char* r500_fs_tex[] = {
+    "    NOP",
+    "     LD",
+    "TEXKILL",
+    "   PROJ",
+    "LODBIAS",
+    "    LOD",
+    "   DXDY",
+};
+
+void r500_fs_dump(struct r500_fragment_shader* fs)
+{
+    int i;
+    uint32_t inst;
+
+    for (i = 0; i < fs->instruction_count; i++) {
+        inst = fs->instructions[i].inst0;
+        debug_printf("%d:  0: CMN_INST   0x%08x:", i, inst);
+        switch (inst & 0x3) {
+            case R500_INST_TYPE_ALU:
+                debug_printf("ALU ");
+                break;
+            case R500_INST_TYPE_OUT:
+                debug_printf("OUT ");
+                break;
+            case R500_INST_TYPE_FC:
+                debug_printf("FC  ");
+                break;
+            case R500_INST_TYPE_TEX:
+                debug_printf("TEX ");
+                break;
+        }
+        debug_printf("%s %s %s %s ",
+                inst & R500_INST_TEX_SEM_WAIT ? "TEX_WAIT" : "",
+                inst & R500_INST_LAST ? "LAST" : "",
+                inst & R500_INST_NOP ? "NOP" : "",
+                inst & R500_INST_ALU_WAIT ? "ALU_WAIT" : "");
+        debug_printf("wmask: %s omask: %s\n",
+                r500_fs_mask[(inst >> 11) & 0xf],
+                r500_fs_mask[(inst >> 15) & 0xf]);
+        switch (inst & 0x3) {
+            case R500_INST_TYPE_ALU:
+            case R500_INST_TYPE_OUT:
+                inst = fs->instructions[i].inst1;
+                debug_printf("    1: RGB_ADDR   0x%08x:", inst);
+                debug_printf("Addr0: %d%c, Addr1: %d%c, "
+                        "Addr2: %d%c, srcp:%d\n",
+                        inst & 0xff, (inst & (1 << 8)) ? 'c' : 't',
+                        (inst >> 10) & 0xff, (inst & (1 << 18)) ? 'c' : 't',
+                        (inst >> 20) & 0xff, (inst & (1 << 28)) ? 'c' : 't',
+                        (inst >> 30));
+
+                inst = fs->instructions[i].inst2;
+                debug_printf("    2: ALPHA_ADDR 0x%08x:", inst);
+                debug_printf("Addr0: %d%c, Addr1: %d%c, "
+                        "Addr2: %d%c, srcp:%d\n",
+                        inst & 0xff, (inst & (1 << 8)) ? 'c' : 't',
+                        (inst >> 10) & 0xff, (inst & (1 << 18)) ? 'c' : 't',
+                        (inst >> 20) & 0xff, (inst & (1 << 28)) ? 'c' : 't',
+                        (inst >> 30));
+
+                inst = fs->instructions[i].inst3;
+                debug_printf("    3: RGB_INST   0x%08x:", inst);
+                debug_printf("rgb_A_src:%d %s/%s/%s %d "
+                        "rgb_B_src:%d %s/%s/%s %d\n",
+                        inst & 0x3, r500_fs_swiz[(inst >> 2) & 0x7],
+                        r500_fs_swiz[(inst >> 5) & 0x7],
+                        r500_fs_swiz[(inst >> 8) & 0x7],
+                        (inst >> 11) & 0x3, (inst >> 13) & 0x3,
+                        r500_fs_swiz[(inst >> 15) & 0x7],
+                        r500_fs_swiz[(inst >> 18) & 0x7],
+                        r500_fs_swiz[(inst >> 21) & 0x7],
+                        (inst >> 24) & 0x3);
+
+                inst = fs->instructions[i].inst4;
+                debug_printf("    4: ALPHA_INST 0x%08x:", inst);
+                debug_printf("%s dest:%d%s alp_A_src:%d %s %d "
+                        "alp_B_src:%d %s %d w:%d\n",
+                        r500_fs_op_alpha[inst & 0xf], (inst >> 4) & 0x7f,
+                        inst & (1<<11) ? "(rel)":"", (inst >> 12) & 0x3,
+                        r500_fs_swiz[(inst >> 14) & 0x7], (inst >> 17) & 0x3,
+                        (inst >> 19) & 0x3, r500_fs_swiz[(inst >> 21) & 0x7],
+                        (inst >> 24) & 0x3, (inst >> 31) & 0x1);
+
+                inst = fs->instructions[i].inst5;
+                debug_printf("    5: RGBA_INST  0x%08x:", inst);
+                debug_printf("%s dest:%d%s rgb_C_src:%d %s/%s/%s %d "
+                        "alp_C_src:%d %s %d\n",
+                        r500_fs_op_rgb[inst & 0xf], (inst >> 4) & 0x7f,
+                        inst & (1 << 11) ? "(rel)":"", (inst >> 12) & 0x3,
+                        r500_fs_swiz[(inst >> 14) & 0x7],
+                        r500_fs_swiz[(inst >> 17) & 0x7],
+                        r500_fs_swiz[(inst >> 20) & 0x7],
+                        (inst >> 23) & 0x3, (inst >> 25) & 0x3,
+                        r500_fs_swiz[(inst >> 27) & 0x7], (inst >> 30) & 0x3);
+                break;
+            case R500_INST_TYPE_FC:
+                /* XXX don't even bother yet */
+                break;
+            case R500_INST_TYPE_TEX:
+                inst = fs->instructions[i].inst1;
+                debug_printf("    1: TEX_INST   0x%08x: id: %d "
+                        "op:%s, %s, %s %s\n",
+                        inst, (inst >> 16) & 0xf,
+                        r500_fs_tex[(inst >> 22) & 0x7],
+                        (inst & (1 << 25)) ? "ACQ" : "",
+                        (inst & (1 << 26)) ? "IGNUNC" : "",
+                        (inst & (1 << 27)) ? "UNSCALED" : "SCALED");
+
+                inst = fs->instructions[i].inst2;
+                debug_printf("    2: TEX_ADDR   0x%08x: "
+                        "src: %d%s %s/%s/%s/%s dst: %d%s %s/%s/%s/%s\n",
+                        inst, inst & 0x7f, inst & (1 << 7) ? "(rel)" : "",
+                        r500_fs_swiz[(inst >> 8) & 0x3],
+                        r500_fs_swiz[(inst >> 10) & 0x3],
+                        r500_fs_swiz[(inst >> 12) & 0x3],
+                        r500_fs_swiz[(inst >> 14) & 0x3],
+                        (inst >> 16) & 0x7f, inst & (1 << 23) ? "(rel)" : "",
+                        r500_fs_swiz[(inst >> 24) & 0x3],
+                        r500_fs_swiz[(inst >> 26) & 0x3],
+                        r500_fs_swiz[(inst >> 28) & 0x3],
+                        r500_fs_swiz[(inst >> 30) & 0x3]);
+                
+                inst = fs->instructions[i].inst3;
+                debug_printf("    3: TEX_DXDY   0x%08x\n", inst);
+                break;
+        }
+    }
+}
diff --git a/src/gallium/drivers/r300/r300_debug.h b/src/gallium/drivers/r300/r300_debug.h
new file mode 100644
index 00000000000..de5d701ed9c
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_debug.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2009 Corbin Simpson <[email protected]>
+ *
+ * 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_DEBUG_H
+#define R300_DEBUG_H
+
+#include "r300_reg.h"
+#include "r300_state_shader.h"
+
+void r500_fs_dump(struct r500_fragment_shader* fs);
+
+#endif /* R300_DEBUG_H */
diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
index 585a9e729d7..a2e771bd1b2 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 */
@@ -79,7 +79,95 @@ void r300_emit_dsa_state(struct r300_context* r300,
     END_CS;
 }
 
-/* XXX add pitch, stride, z/stencil buf */
+void r300_emit_fragment_shader(struct r300_context* r300,
+                               struct r300_fragment_shader* fs)
+{
+    CS_LOCALS(r300);
+    int i;
+
+    BEGIN_CS(22);
+
+    OUT_CS_REG(R300_US_CONFIG, MAX2(fs->indirections - 1, 0));
+    OUT_CS_REG(R300_US_PIXSIZE, fs->shader.stack_size);
+    /* XXX figure out exactly how big the sizes are on this reg */
+    OUT_CS_REG(R300_US_CODE_OFFSET, 0x0);
+    /* XXX figure these ones out a bit better kthnx */
+    OUT_CS_REG(R300_US_CODE_ADDR_0, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_1, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_2, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_3, R300_RGBA_OUT);
+
+    for (i = 0; i < fs->alu_instruction_count; i++) {
+        OUT_CS_REG(R300_US_ALU_RGB_INST_0 + (4 * i),
+            fs->instructions[i].alu_rgb_inst);
+        OUT_CS_REG(R300_US_ALU_RGB_ADDR_0 + (4 * i),
+            fs->instructions[i].alu_rgb_addr);
+        OUT_CS_REG(R300_US_ALU_ALPHA_INST_0 + (4 * i),
+            fs->instructions[i].alu_alpha_inst);
+        OUT_CS_REG(R300_US_ALU_ALPHA_ADDR_0 + (4 * i),
+            fs->instructions[i].alu_alpha_addr);
+    }
+
+    END_CS;
+}
+
+void r500_emit_fragment_shader(struct r300_context* r300,
+                               struct r500_fragment_shader* fs)
+{
+    CS_LOCALS(r300);
+    struct r300_constant_buffer* constants =
+        &r300->shader_constants[PIPE_SHADER_FRAGMENT];
+    int i;
+
+    BEGIN_CS(9 + (fs->instruction_count * 6) + (constants->count ? 3 : 0) +
+            (constants->count * 4));
+    OUT_CS_REG(R500_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
+    OUT_CS_REG(R500_US_PIXSIZE, fs->shader.stack_size);
+    OUT_CS_REG(R500_US_CODE_ADDR, R500_US_CODE_START_ADDR(0) |
+            R500_US_CODE_END_ADDR(fs->instruction_count));
+
+    OUT_CS_REG(R500_GA_US_VECTOR_INDEX, R500_GA_US_VECTOR_INDEX_TYPE_INSTR);
+    OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, fs->instruction_count * 6);
+    for (i = 0; i < fs->instruction_count; i++) {
+        OUT_CS(fs->instructions[i].inst0);
+        OUT_CS(fs->instructions[i].inst1);
+        OUT_CS(fs->instructions[i].inst2);
+        OUT_CS(fs->instructions[i].inst3);
+        OUT_CS(fs->instructions[i].inst4);
+        OUT_CS(fs->instructions[i].inst5);
+    }
+
+    if (constants->count) {
+        OUT_CS_REG(R500_GA_US_VECTOR_INDEX,
+                R500_GA_US_VECTOR_INDEX_TYPE_CONST);
+        OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, constants->count * 4);
+        for (i = 0; i < constants->count; i++) {
+            OUT_CS_32F(constants->constants[i][0]);
+            OUT_CS_32F(constants->constants[i][1]);
+            OUT_CS_32F(constants->constants[i][2]);
+            OUT_CS_32F(constants->constants[i][3]);
+        }
+    }
+
+    END_CS;
+}
+
+/* Translate pipe_format into US_OUT_FMT. Note that formats are stored from
+ * C3 to C0. */
+uint32_t translate_out_fmt(enum pipe_format format)
+{
+    switch (format) {
+        case PIPE_FORMAT_A8R8G8B8_UNORM:
+            return R300_US_OUT_FMT_C4_8 |
+                R300_C0_SEL_B | R300_C1_SEL_G |
+                R300_C2_SEL_R | R300_C3_SEL_A;
+        default:
+            return R300_US_OUT_FMT_UNUSED;
+    }
+    return 0;
+}
+
+/* XXX add pitch, stride, clean up */
 void r300_emit_fb_state(struct r300_context* r300,
                         struct pipe_framebuffer_state* fb)
 {
@@ -87,23 +175,47 @@ void r300_emit_fb_state(struct r300_context* r300,
     struct r300_texture* tex;
     int i;
 
-    BEGIN_CS((3 * fb->nr_cbufs) + 6);
+    BEGIN_CS((6 * fb->nr_cbufs) + (fb->zsbuf ? 6 : 0) + 4);
     for (i = 0; i < fb->nr_cbufs; i++) {
         tex = (struct r300_texture*)fb->cbufs[i]->texture;
         OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0 + (4 * i), 1);
         OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
+
+        OUT_CS_REG(R300_US_OUT_FMT_0 + (4 * i),
+            translate_out_fmt(fb->cbufs[i]->format));
+    }
+
+    if (fb->zsbuf) {
+        tex = (struct r300_texture*)fb->zsbuf->texture;
+        OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
+        OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
+        if (fb->zsbuf->format == PIPE_FORMAT_Z24S8_UNORM) {
+            OUT_CS_REG(R300_ZB_FORMAT,
+                R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL);
+        } else {
+            OUT_CS_REG(R300_ZB_FORMAT, 0x0);
+        }
     }
-    R300_PACIFY;
+
+    OUT_CS_REG(R300_RB3D_DSTCACHE_CTLSTAT,
+        R300_RB3D_DSTCACHE_CTLSTAT_DC_FREE_FREE_3D_TAGS |
+        R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D);
+    OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT,
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE);
     END_CS;
 }
 
 void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
     CS_LOCALS(r300);
-    BEGIN_CS(14);
+
+    BEGIN_CS(20);
     OUT_CS_REG(R300_VAP_CNTL_STATUS, rs->vap_control_status);
+    OUT_CS_REG(R300_GA_POINT_SIZE, rs->point_size);
+    OUT_CS_REG_SEQ(R300_GA_POINT_MINMAX, 2);
+    OUT_CS(rs->point_minmax);
+    OUT_CS(rs->line_control);
     OUT_CS_REG_SEQ(R300_SU_POLY_OFFSET_FRONT_SCALE, 6);
     OUT_CS(rs->depth_scale_front);
     OUT_CS(rs->depth_offset_front);
@@ -113,43 +225,241 @@ void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs)
     OUT_CS(rs->cull_mode);
     OUT_CS_REG(R300_GA_LINE_STIPPLE_CONFIG, rs->line_stipple_config);
     OUT_CS_REG(R300_GA_LINE_STIPPLE_VALUE, rs->line_stipple_value);
+    OUT_CS_REG(R300_GA_COLOR_CONTROL, rs->color_control);
+    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]);
+        debug_printf("ip %d: 0x%08x\n", i, 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]);
+        debug_printf("inst %d: 0x%08x\n", i, rs->inst[i]);
+    }
+
+    debug_printf("count: 0x%08x inst_count: 0x%08x\n", rs->count,
+            rs->inst_count);
+
     END_CS;
 }
 
-static void r300_emit_dirty_state(struct r300_context* r300)
+void r300_emit_sampler(struct r300_context* r300,
+                       struct r300_sampler_state* sampler, unsigned offset)
 {
-    struct r300_screen* r300screen =
-        (struct r300_screen*)r300->context.screen;
     CS_LOCALS(r300);
 
+    BEGIN_CS(6);
+    OUT_CS_REG(R300_TX_FILTER0_0 + (offset * 4), sampler->filter0);
+    OUT_CS_REG(R300_TX_FILTER1_0 + (offset * 4), sampler->filter1);
+    OUT_CS_REG(R300_TX_BORDER_COLOR_0 + (offset * 4), sampler->border_color);
+    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);
+    OUT_CS(scissor->scissor_bottom_right);
+    END_CS;
+}
+
+void r300_emit_texture(struct r300_context* r300,
+                       struct r300_texture* tex, unsigned offset)
+{
+    CS_LOCALS(r300);
+
+    BEGIN_CS(10);
+    OUT_CS_REG(R300_TX_FORMAT0_0 + (offset * 4), tex->state.format0);
+    OUT_CS_REG(R300_TX_FORMAT1_0 + (offset * 4), tex->state.format1);
+    OUT_CS_REG(R300_TX_FORMAT2_0 + (offset * 4), tex->state.format2);
+    OUT_CS_REG_SEQ(R300_TX_OFFSET_0 + (offset * 4), 1);
+    OUT_CS_RELOC(tex->buffer, 0,
+            RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0, 0);
+    END_CS;
+}
+
+void r300_emit_vertex_format_state(struct r300_context* r300)
+{
+    CS_LOCALS(r300);
+    int i;
+
+    BEGIN_CS(26);
+    OUT_CS_REG(R300_VAP_VTX_SIZE, r300->vertex_info.vinfo.size);
+
+    OUT_CS_REG_SEQ(R300_VAP_VTX_STATE_CNTL, 2);
+    OUT_CS(r300->vertex_info.vinfo.hwfmt[0]);
+    OUT_CS(r300->vertex_info.vinfo.hwfmt[1]);
+    OUT_CS_REG_SEQ(R300_VAP_OUTPUT_VTX_FMT_0, 2);
+    OUT_CS(r300->vertex_info.vinfo.hwfmt[2]);
+    OUT_CS(r300->vertex_info.vinfo.hwfmt[3]);
+    for (i = 0; i < 4; i++) {
+        debug_printf("hwfmt%d: 0x%08x\n", i,
+                r300->vertex_info.vinfo.hwfmt[i]);
+    }
+
+    OUT_CS_REG_SEQ(R300_VAP_PROG_STREAM_CNTL_0, 8);
+    for (i = 0; i < 8; i++) {
+        OUT_CS(r300->vertex_info.vap_prog_stream_cntl[i]);
+        debug_printf("prog_stream_cntl%d: 0x%08x\n", i,
+                r300->vertex_info.vap_prog_stream_cntl[i]);
+    }
+    OUT_CS_REG_SEQ(R300_VAP_PROG_STREAM_CNTL_EXT_0, 8);
+    for (i = 0; i < 8; i++) {
+        OUT_CS(r300->vertex_info.vap_prog_stream_cntl_ext[i]);
+        debug_printf("prog_stream_cntl_ext%d: 0x%08x\n", i,
+                r300->vertex_info.vap_prog_stream_cntl_ext[i]);
+    }
+    END_CS;
+}
+
+void r300_emit_viewport_state(struct r300_context* r300,
+                              struct r300_viewport_state* viewport)
+{
+    return;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(7);
+    OUT_CS_REG_SEQ(R300_SE_VPORT_XSCALE, 7);
+    OUT_CS_32F(viewport->xscale);
+    OUT_CS_32F(viewport->xoffset);
+    OUT_CS_32F(viewport->yscale);
+    OUT_CS_32F(viewport->yoffset);
+    OUT_CS_32F(viewport->zscale);
+    OUT_CS_32F(viewport->zoffset);
+    OUT_CS(viewport->vte_control);
+    END_CS;
+}
+
+static void r300_flush_textures(struct r300_context* r300)
+{
+    CS_LOCALS(r300);
+
+    BEGIN_CS(4);
+    OUT_CS_REG(R300_TX_INVALTAGS, 0);
+    OUT_CS_REG(R300_TX_ENABLE, (1 << r300->texture_count) - 1);
+    END_CS;
+}
+
+/* Emit all dirty state. */
+void r300_emit_dirty_state(struct r300_context* r300)
+{
+    struct r300_screen* r300screen = r300_screen(r300->context.screen);
+    int i;
+    int dirty_tex = 0;
+
     if (!(r300->dirty_state) && !(r300->dirty_hw)) {
         return;
     }
 
+    r300_update_derived_state(r300);
+
     /* XXX check size */
 
     if (r300->dirty_state & R300_NEW_BLEND) {
         r300_emit_blend_state(r300, r300->blend_state);
+        r300->dirty_state &= ~R300_NEW_BLEND;
     }
 
     if (r300->dirty_state & R300_NEW_BLEND_COLOR) {
         r300_emit_blend_color_state(r300, r300->blend_color_state);
+        r300->dirty_state &= ~R300_NEW_BLEND_COLOR;
     }
 
     if (r300->dirty_state & R300_NEW_DSA) {
         r300_emit_dsa_state(r300, r300->dsa_state);
+        r300->dirty_state &= ~R300_NEW_DSA;
+    }
+
+    if (r300->dirty_state & R300_NEW_FRAGMENT_SHADER) {
+        if (r300screen->caps->is_r500) {
+            r500_emit_fragment_shader(r300,
+                (struct r500_fragment_shader*)r300->fs);
+        } else {
+            r300_emit_fragment_shader(r300,
+                (struct r300_fragment_shader*)r300->fs);
+        }
+        r300->dirty_state &= ~R300_NEW_FRAGMENT_SHADER;
+    }
+
+    if (r300->dirty_state & R300_NEW_FRAMEBUFFERS) {
+        r300_emit_fb_state(r300, &r300->framebuffer_state);
+        r300->dirty_state &= ~R300_NEW_FRAMEBUFFERS;
     }
 
     if (r300->dirty_state & R300_NEW_RASTERIZER) {
         r300_emit_rs_state(r300, r300->rs_state);
+        r300->dirty_state &= ~R300_NEW_RASTERIZER;
+    }
+
+    if (r300->dirty_state & R300_NEW_RS_BLOCK) {
+        r300_emit_rs_block_state(r300, r300->rs_block);
+        r300->dirty_state &= ~R300_NEW_RS_BLOCK;
+    }
+
+    if (r300->dirty_state & R300_ANY_NEW_SAMPLERS) {
+        for (i = 0; i < r300->sampler_count; i++) {
+            if (r300->dirty_state & (R300_NEW_SAMPLER << i)) {
+                r300_emit_sampler(r300, r300->sampler_states[i], i);
+                r300->dirty_state &= ~(R300_NEW_SAMPLER << i);
+                dirty_tex++;
+            }
+        }
     }
 
     if (r300->dirty_state & R300_NEW_SCISSOR) {
-        struct r300_scissor_state* scissor = r300->scissor_state;
-        /* XXX next two are contiguous regs */
-        OUT_CS_REG(R300_SC_SCISSORS_TL, scissor->scissor_top_left);
-        OUT_CS_REG(R300_SC_SCISSORS_BR, scissor->scissor_bottom_right);
+        r300_emit_scissor_state(r300, r300->scissor_state);
+        r300->dirty_state &= ~R300_NEW_SCISSOR;
     }
 
-    r300->dirty_state = 0;
+    if (r300->dirty_state & R300_ANY_NEW_TEXTURES) {
+        for (i = 0; i < r300->texture_count; i++) {
+            if (r300->dirty_state & (R300_NEW_TEXTURE << i)) {
+                r300_emit_texture(r300, r300->textures[i], i);
+                r300->dirty_state &= ~(R300_NEW_TEXTURE << i);
+                dirty_tex++;
+            }
+        }
+    }
+
+    if (r300->dirty_state & R300_NEW_VIEWPORT) {
+        r300_emit_viewport_state(r300, r300->viewport_state);
+        r300->dirty_state &= ~R300_NEW_VIEWPORT;
+    }
+
+    if (dirty_tex) {
+        r300_flush_textures(r300);
+    }
+
+    if (r300->dirty_state & R300_NEW_VERTEX_FORMAT) {
+        r300_emit_vertex_format_state(r300);
+        r300->dirty_state &= ~R300_NEW_VERTEX_FORMAT;
+    }
 }
diff --git a/src/gallium/drivers/r300/r300_emit.h b/src/gallium/drivers/r300/r300_emit.h
index b6e69386f95..4aba1ee08ce 100644
--- a/src/gallium/drivers/r300/r300_emit.h
+++ b/src/gallium/drivers/r300/r300_emit.h
@@ -20,6 +20,11 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
+#ifndef R300_EMIT_H
+#define R300_EMIT_H
+
+#include "util/u_math.h"
+
 #include "r300_context.h"
 #include "r300_cs.h"
 #include "r300_screen.h"
@@ -33,4 +38,26 @@ void r300_emit_blend_color_state(struct r300_context* r300,
 void r300_emit_dsa_state(struct r300_context* r300,
                          struct r300_dsa_state* dsa);
 
+void r300_emit_fragment_shader(struct r300_context* r300,
+                               struct r300_fragment_shader* fs);
+
+void r500_emit_fragment_shader(struct r300_context* r300,
+                               struct r500_fragment_shader* fs);
+
+void r300_emit_fb_state(struct r300_context* r300,
+                        struct pipe_framebuffer_state* fb);
+
 void r300_emit_rs_state(struct r300_context* r300, struct r300_rs_state* rs);
+
+void r300_emit_rs_block_state(struct r300_context* r300,
+                              struct r300_rs_block* rs);
+
+void r300_emit_scissor_state(struct r300_context* r300,
+                             struct r300_scissor_state* scissor);
+
+void r300_emit_vertex_format_state(struct r300_context* r300);
+
+/* Emit all dirty state. */
+void r300_emit_dirty_state(struct r300_context* r300);
+
+#endif /* R300_EMIT_H */
diff --git a/src/gallium/drivers/r300/r300_flush.c b/src/gallium/drivers/r300/r300_flush.c
index 3766f0a0a7b..20ca6905ad2 100644
--- a/src/gallium/drivers/r300/r300_flush.c
+++ b/src/gallium/drivers/r300/r300_flush.c
@@ -31,6 +31,7 @@ static void r300_flush(struct pipe_context* pipe,
 
     if (r300->dirty_hw) {
         FLUSH_CS;
+        r300_emit_invariant_state(r300);
         r300->dirty_state = R300_NEW_KITCHEN_SINK;
         r300->dirty_hw = 0;
     }
diff --git a/src/gallium/drivers/r300/r300_query.c b/src/gallium/drivers/r300/r300_query.c
new file mode 100644
index 00000000000..5f5f4c4dbd4
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_query.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009 Corbin Simpson <[email protected]>
+ *
+ * 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_query.h"
+
+static struct pipe_query* r300_create_query(struct pipe_context* pipe,
+                                            unsigned query_type)
+{
+    struct r300_query* q = CALLOC_STRUCT(r300_query);
+
+    q->type = query_type;
+    assert(q->type == PIPE_QUERY_OCCLUSION_COUNTER);
+
+    /* XXX this is to force winsys to give us a GTT buffer */
+    q->buf = pipe->screen->buffer_create(pipe->screen, 64,
+            PIPE_BUFFER_USAGE_VERTEX, 64);
+
+    return (struct pipe_query*)q;
+}
+
+static void r300_destroy_query(struct pipe_context* pipe,
+                               struct pipe_query* query)
+{
+    FREE(query);
+}
+
+static void r300_begin_query(struct pipe_context* pipe,
+                             struct pipe_query* query)
+{
+    struct r300_context* r300 = r300_context(pipe);
+    struct r300_query* q = (struct r300_query*)query;
+    CS_LOCALS(r300);
+
+    uint32_t* map = pipe_buffer_map(pipe->screen, q->buf,
+            PIPE_BUFFER_USAGE_CPU_WRITE);
+    *map = ~0;
+    pipe_buffer_unmap(pipe->screen, q->buf);
+
+    BEGIN_CS(2);
+    OUT_CS_REG(R300_ZB_ZPASS_DATA, 0);
+    END_CS;
+}
+
+static void r300_end_query(struct pipe_context* pipe,
+                           struct pipe_query* query)
+{
+    struct r300_context* r300 = r300_context(pipe);
+    struct r300_query* q = (struct r300_query*)query;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(4);
+    OUT_CS_REG_SEQ(R300_ZB_ZPASS_ADDR, 1);
+    OUT_CS_RELOC(q->buf, 0, 0, RADEON_GEM_DOMAIN_GTT, 0);
+    END_CS;
+}
+
+static boolean r300_get_query_result(struct pipe_context* pipe,
+                                     struct pipe_query* query,
+                                     boolean wait,
+                                     uint64_t* result)
+{
+    struct r300_query* q = (struct r300_query*)query;
+    uint32_t temp;
+
+    if (wait) {
+        /* Well, we're expected to just sit here and spin, so let's go ahead
+         * and flush so we can be sure that the card's spinning... */
+        /* XXX double-check these params */
+        pipe->flush(pipe, 0, NULL);
+    }
+
+    uint32_t* map = pipe_buffer_map(pipe->screen, q->buf,
+            PIPE_BUFFER_USAGE_CPU_READ);
+    temp = *map;
+    pipe_buffer_unmap(pipe->screen, q->buf);
+
+    if (temp < 0) {
+        /* Our results haven't been written yet... */
+        return FALSE;
+    }
+
+    *result = temp;
+    return TRUE;
+}
+
+void r300_init_query_functions(struct r300_context* r300) {
+    r300->context.create_query = r300_create_query;
+    r300->context.destroy_query = r300_destroy_query;
+    r300->context.begin_query = r300_begin_query;
+    r300->context.end_query = r300_end_query;
+    r300->context.get_query_result = r300_get_query_result;
+}
diff --git a/src/gallium/drivers/r300/r300_query.h b/src/gallium/drivers/r300/r300_query.h
new file mode 100644
index 00000000000..4f447ea45b8
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_query.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009 Corbin Simpson <[email protected]>
+ *
+ * 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_QUERY_H
+#define R300_QUERY_H
+
+#include "r300_context.h"
+#include "r300_cs.h"
+#include "r300_reg.h"
+
+struct r300_query {
+    /* The kind of query. Currently only OQ is supported. */
+    unsigned type;
+    /* Buffer object where we want our results to reside. */
+    struct pipe_buffer* buf;
+};
+
+static INLINE struct r300_query* r300_query(struct pipe_query* q)
+{
+    return (struct r300_query*)q;
+}
+
+void r300_init_query_functions(struct r300_context* r300);
+
+#endif /* R300_QUERY_H */
diff --git a/src/gallium/drivers/r300/r300_reg.h b/src/gallium/drivers/r300/r300_reg.h
index dbd0cc28e23..6f3ad970abc 100644
--- a/src/gallium/drivers/r300/r300_reg.h
+++ b/src/gallium/drivers/r300/r300_reg.h
@@ -64,7 +64,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define R300_SE_VPORT_ZSCALE                0x1DA8
 #define R300_SE_VPORT_ZOFFSET               0x1DAC
 
-
+#define R300_VAP_PORT_IDX0		    0x2040
 /*
  * Vertex Array Processing (VAP) Control
  */
@@ -139,17 +139,25 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R300_VAP_OUTPUT_VTX_FMT_1__3_COMPONENTS 3
 #	define R300_VAP_OUTPUT_VTX_FMT_1__4_COMPONENTS 4
 
-#define R300_SE_VTE_CNTL                  0x20b0
-#	define     R300_VPORT_X_SCALE_ENA                (1 << 0)
-#	define     R300_VPORT_X_OFFSET_ENA               (1 << 1)
-#	define     R300_VPORT_Y_SCALE_ENA                (1 << 2)
-#	define     R300_VPORT_Y_OFFSET_ENA               (1 << 3)
-#	define     R300_VPORT_Z_SCALE_ENA                (1 << 4)
-#	define     R300_VPORT_Z_OFFSET_ENA               (1 << 5)
-#	define     R300_VTX_XY_FMT                       (1 << 8)
-#	define     R300_VTX_Z_FMT                        (1 << 9)
-#	define     R300_VTX_W0_FMT                       (1 << 10)
-#	define     R300_SERIAL_PROC_ENA                  (1 << 11)
+#define R300_VAP_VPORT_XSCALE                     0x2098
+#define R300_VAP_VPORT_XOFFSET                    0x209c
+#define R300_VAP_VPORT_YSCALE                     0x20a0
+#define R300_VAP_VPORT_YOFFSET                    0x20a4
+#define R300_VAP_VPORT_ZSCALE                     0x20a8
+#define R300_VAP_VPORT_ZOFFSET                    0x20ac
+
+#define R300_VAP_VTE_CNTL                         0x20b0
+#define R300_SE_VTE_CNTL R300_VAP_VTE_CNTL
+#   define R300_VPORT_X_SCALE_ENA                           (1 << 0)
+#   define R300_VPORT_X_OFFSET_ENA                          (1 << 1)
+#   define R300_VPORT_Y_SCALE_ENA                           (1 << 2)
+#   define R300_VPORT_Y_OFFSET_ENA                          (1 << 3)
+#   define R300_VPORT_Z_SCALE_ENA                           (1 << 4)
+#   define R300_VPORT_Z_OFFSET_ENA                          (1 << 5)
+#   define R300_VTX_XY_FMT                                  (1 << 8)
+#   define R300_VTX_Z_FMT                                   (1 << 9)
+#   define R300_VTX_W0_FMT                                  (1 << 10)
+#   define R300_SERIAL_PROC_ENA                             (1 << 11)
 
 #define R300_VAP_VTX_SIZE               0x20b4
 
@@ -326,6 +334,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_WRITE_ENA_Z                         4
 #       define R300_WRITE_ENA_W                         8
 #       define R300_SWIZZLE1_SHIFT                      16
+
+#       define R300_VAP_SWIZZLE_XYZW \
+        ((R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_SHIFT) | \
+         (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_SHIFT) | \
+         (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_SHIFT) | \
+         (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_SHIFT) | \
+         (0xf << R300_WRITE_ENA_SHIFT))
+
 #define R300_VAP_PROG_STREAM_CNTL_EXT_1                 0x21e4
 #define R300_VAP_PROG_STREAM_CNTL_EXT_2                 0x21e8
 #define R300_VAP_PROG_STREAM_CNTL_EXT_3                 0x21ec
@@ -732,8 +748,12 @@ 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_COL_PTR(x)		        (x << 24)
-#       define R500_RS_COL_FMT(x)                       (x << 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 */
 #define R500_RS_IP_OFFSET_DIS 				(0 << 31)
 #define R500_RS_IP_OFFSET_EN 				(1 << 31)
@@ -1019,20 +1039,27 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_THIRD  (2 << 16)
 #	define R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST   (3 << 16)
 
-/** TODO: might be candidate for removal */
-#	define R300_RE_SHADE_MODEL_SMOOTH     ( \
-	R300_GA_COLOR_CONTROL_RGB0_SHADING_GOURAUD | R300_GA_COLOR_CONTROL_ALPHA0_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_RGB1_SHADING_GOURAUD | R300_GA_COLOR_CONTROL_ALPHA1_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_RGB2_SHADING_GOURAUD | R300_GA_COLOR_CONTROL_ALPHA2_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_RGB3_SHADING_GOURAUD | R300_GA_COLOR_CONTROL_ALPHA3_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST )
-/** TODO: might be candidate for removal, the GOURAUD stuff also looks buggy to me */
-#	define R300_RE_SHADE_MODEL_FLAT     ( \
-	R300_GA_COLOR_CONTROL_RGB0_SHADING_FLAT | R300_GA_COLOR_CONTROL_ALPHA0_SHADING_FLAT | \
-	R300_GA_COLOR_CONTROL_RGB1_SHADING_FLAT | R300_GA_COLOR_CONTROL_ALPHA1_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_RGB2_SHADING_FLAT | R300_GA_COLOR_CONTROL_ALPHA2_SHADING_FLAT | \
-	R300_GA_COLOR_CONTROL_RGB3_SHADING_FLAT | R300_GA_COLOR_CONTROL_ALPHA3_SHADING_GOURAUD | \
-	R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST )
+#       define R300_SHADE_MODEL_FLAT ( \
+        R300_GA_COLOR_CONTROL_RGB0_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_ALPHA0_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_RGB1_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_ALPHA1_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_RGB2_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_ALPHA2_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_RGB3_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_ALPHA3_SHADING_FLAT | \
+        R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST )
+
+#       define R300_SHADE_MODEL_SMOOTH ( \
+        R300_GA_COLOR_CONTROL_RGB0_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_ALPHA0_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_RGB1_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_ALPHA1_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_RGB2_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_ALPHA2_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_RGB3_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_ALPHA3_SHADING_GOURAUD | \
+        R300_GA_COLOR_CONTROL_PROVOKING_VERTEX_LAST )
 
 /* Specifies red & green components of fill color -- S312 format -- Backwards comp. */
 #define R300_GA_SOLID_RG                         0x427c
@@ -1146,6 +1173,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_W_ADDR_MASK                  0x0003f000
 #       define R300_HIRES_DIS                    (0 << 18)
 #       define R300_HIRES_EN                     (1 << 18)
+#       define R300_IT_COUNT(x)                  ((x) << 0)
+#       define R300_IC_COUNT(x)                  ((x) << 7)
+#       define R300_W_COUNT(x)                   ((x) << 12)
 
 #define R300_RS_INST_COUNT                       0x4304
 #       define R300_RS_INST_COUNT_SHIFT          0
@@ -1175,8 +1205,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_RS_INTERP_SRC_SHIFT          2 /* TODO: check for removal */
 #       define R300_RS_INTERP_SRC_MASK           (7 << 2) /* TODO: check for removal */
 #	define R300_RS_TEX_PTR(x)		        (x << 0)
-#	define R300_RS_COL_PTR(x)		        (x << 6)
-#	define R300_RS_COL_FMT(x)		        (x << 9)
+#	define R300_RS_COL_PTR(x)		        ((x) << 6)
+#	define R300_RS_COL_FMT(x)		        ((x) << 9)
 #	define R300_RS_COL_FMT_RGBA		        0
 #	define R300_RS_COL_FMT_RGB0		        1
 #	define R300_RS_COL_FMT_RGB1		        2
@@ -1186,10 +1216,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R300_RS_COL_FMT_111A		        8
 #	define R300_RS_COL_FMT_1110		        9
 #	define R300_RS_COL_FMT_1111		        10
-#	define R300_RS_SEL_S(x)		                (x << 13)
-#	define R300_RS_SEL_T(x)		                (x << 16)
-#	define R300_RS_SEL_R(x)		                (x << 19)
-#	define R300_RS_SEL_Q(x)		                (x << 22)
+#	define R300_RS_SEL_S(x)		                ((x) << 13)
+#	define R300_RS_SEL_T(x)		                ((x) << 16)
+#	define R300_RS_SEL_R(x)		                ((x) << 19)
+#	define R300_RS_SEL_Q(x)		                ((x) << 22)
 #	define R300_RS_SEL_C0		                0
 #	define R300_RS_SEL_C1		                1
 #	define R300_RS_SEL_C2		                2
@@ -1216,14 +1246,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 +1274,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
@@ -1411,18 +1447,21 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R500_MACRO_SWITCH               (1<<22)
 #	define R500_BORDER_FIX                 (1<<31)
 
-#define R300_TX_SIZE_0                      0x4480
+#define R300_TX_FORMAT0_0                   0x4480
 #       define R300_TX_WIDTHMASK_SHIFT           0
 #       define R300_TX_WIDTHMASK_MASK            (2047 << 0)
 #       define R300_TX_HEIGHTMASK_SHIFT          11
 #       define R300_TX_HEIGHTMASK_MASK           (2047 << 11)
-#	define R300_TX_DEPTHMASK_SHIFT		 22
-#	define R300_TX_DEPTHMASK_MASK		 (0xf << 22)
+#	define R300_TX_DEPTHMASK_SHIFT           22
+#	define R300_TX_DEPTHMASK_MASK            (0xf << 22)
 #       define R300_TX_MAX_MIP_LEVEL_SHIFT       26
 #       define R300_TX_MAX_MIP_LEVEL_MASK        (0xf << 26)
-#       define R300_TX_SIZE_PROJECTED            (1<<30)
-#       define R300_TX_SIZE_TXPITCH_EN           (1<<31)
-#define R300_TX_FORMAT_0                    0x44C0
+#       define R300_TX_SIZE_PROJECTED            (1 << 30)
+#       define R300_TX_PITCH_EN                  (1 << 31)
+#       define R300_TX_WIDTH(x)                  ((x) << 0)
+#       define R300_TX_HEIGHT(x)                 ((x) << 11)
+
+#define R300_TX_FORMAT1_0                   0x44C0
 	/* The interpretation of the format word by Wladimir van der Laan */
 	/* The X, Y, Z and W refer to the layout of the components.
 	   They are given meanings as R, G, B and Alpha by the swizzle
@@ -1708,7 +1747,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #   define R300_C3_SEL_R				(1 << 14)
 #   define R300_C3_SEL_G				(2 << 14)
 #   define R300_C3_SEL_B				(3 << 14)
-#   define R300_OUT_SIGN(x)				(x << 16)
+#   define R300_OUT_SIGN(x)				((x) << 16)
+#   define R500_ROUND_ADJ				(1 << 20)
 
 /* ALU
  * The ALU instructions register blocks are enumerated according to the order
@@ -1795,6 +1835,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_ALU_DSTC_OUTPUT_X           (1 << 26)
 #       define R300_ALU_DSTC_OUTPUT_Y           (1 << 27)
 #       define R300_ALU_DSTC_OUTPUT_Z           (1 << 28)
+#       define R300_ALU_DSTC_OUTPUT_XYZ         (7 << 26)
+#       define R300_RGB_ADDR0(x)                ((x) << 0)
+#       define R300_RGB_ADDR1(x)                ((x) << 6)
+#       define R300_RGB_ADDR2(x)                ((x) << 12)
 
 #define R300_US_ALU_ALPHA_ADDR_0                 0x47C0
 #       define R300_ALU_SRC0A_SHIFT             0
@@ -1812,6 +1856,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_ALU_DSTA_REG                (1 << 23)
 #       define R300_ALU_DSTA_OUTPUT             (1 << 24)
 #		define R300_ALU_DSTA_DEPTH              (1 << 27)
+#       define R300_ALPHA_ADDR0(x)                ((x) << 0)
+#       define R300_ALPHA_ADDR1(x)                ((x) << 6)
+#       define R300_ALPHA_ADDR2(x)                ((x) << 12)
 
 #define R300_US_ALU_RGB_INST_0                   0x48C0
 #       define R300_ALU_ARGC_SRC0C_XYZ          0
@@ -1846,6 +1893,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_ALU_ARGC_SRC0CA_WZY         29
 #       define R300_ALU_ARGC_SRC1CA_WZY         30
 #       define R300_ALU_ARGC_SRC2CA_WZY         31
+#       define R300_RGB_SWIZA(x)                ((x) << 0)
+#       define R300_RGB_SWIZB(x)                ((x) << 7)
+#       define R300_RGB_SWIZC(x)                ((x) << 14)
 
 #       define R300_ALU_ARG0C_SHIFT             0
 #       define R300_ALU_ARG0C_MASK              (31 << 0)
@@ -1909,10 +1959,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_ALU_ARGA_SRCP_Y             13
 #       define R300_ALU_ARGA_SRCP_Z             14
 #       define R300_ALU_ARGA_SRCP_W             15
-
 #       define R300_ALU_ARGA_ZERO               16
 #       define R300_ALU_ARGA_ONE                17
 #       define R300_ALU_ARGA_HALF               18
+#       define R300_ALPHA_SWIZA(x)              ((x) << 0)
+#       define R300_ALPHA_SWIZB(x)              ((x) << 7)
+#       define R300_ALPHA_SWIZC(x)              ((x) << 14)
+
 #       define R300_ALU_ARG0A_SHIFT             0
 #       define R300_ALU_ARG0A_MASK              (31 << 0)
 #       define R300_ALU_ARG0A_NOP               (0 << 5)
@@ -2731,7 +2784,7 @@ enum {
 #   define R500_ALPHA_OP_COS				13
 #   define R500_ALPHA_OP_MDH				14
 #   define R500_ALPHA_OP_MDV				15
-#   define R500_ALPHA_ADDRD(x)				(x << 4)
+#   define R500_ALPHA_ADDRD(x)				((x) << 4)
 #   define R500_ALPHA_ADDRD_REL				(1 << 11)
 #  define R500_ALPHA_SEL_A_SHIFT			12
 #   define R500_ALPHA_SEL_A_SRC0			(0 << 12)
@@ -2775,16 +2828,16 @@ enum {
 #   define R500_ALPHA_OMOD_DIV_4			(5 << 26)
 #   define R500_ALPHA_OMOD_DIV_8			(6 << 26)
 #   define R500_ALPHA_OMOD_DISABLE			(7 << 26)
-#   define R500_ALPHA_TARGET(x)				(x << 29)
+#   define R500_ALPHA_TARGET(x)				((x) << 29)
 #   define R500_ALPHA_W_OMASK				(1 << 31)
 #define R500_US_ALU_ALPHA_ADDR_0			0x9800
-#   define R500_ALPHA_ADDR0(x)				(x << 0)
+#   define R500_ALPHA_ADDR0(x)				((x) << 0)
 #   define R500_ALPHA_ADDR0_CONST			(1 << 8)
 #   define R500_ALPHA_ADDR0_REL				(1 << 9)
-#   define R500_ALPHA_ADDR1(x)				(x << 10)
+#   define R500_ALPHA_ADDR1(x)				((x) << 10)
 #   define R500_ALPHA_ADDR1_CONST			(1 << 18)
 #   define R500_ALPHA_ADDR1_REL				(1 << 19)
-#   define R500_ALPHA_ADDR2(x)				(x << 20)
+#   define R500_ALPHA_ADDR2(x)				((x) << 20)
 #   define R500_ALPHA_ADDR2_CONST			(1 << 28)
 #   define R500_ALPHA_ADDR2_REL				(1 << 29)
 #   define R500_ALPHA_SRCP_OP_1_MINUS_2A0		(0 << 30)
@@ -2805,7 +2858,7 @@ enum {
 #   define R500_ALU_RGBA_OP_SOP				(10 << 0)
 #   define R500_ALU_RGBA_OP_MDH				(11 << 0)
 #   define R500_ALU_RGBA_OP_MDV				(12 << 0)
-#   define R500_ALU_RGBA_ADDRD(x)			(x << 4)
+#   define R500_ALU_RGBA_ADDRD(x)			((x) << 4)
 #   define R500_ALU_RGBA_ADDRD_REL			(1 << 11)
 #  define R500_ALU_RGBA_SEL_C_SHIFT			12
 #   define R500_ALU_RGBA_SEL_C_SRC0			(0 << 12)
@@ -2932,16 +2985,16 @@ enum {
 #   define R500_ALU_RGB_OMOD_DIV_4			(5 << 26)
 #   define R500_ALU_RGB_OMOD_DIV_8			(6 << 26)
 #   define R500_ALU_RGB_OMOD_DISABLE			(7 << 26)
-#   define R500_ALU_RGB_TARGET(x)			(x << 29)
+#   define R500_ALU_RGB_TARGET(x)			((x) << 29)
 #   define R500_ALU_RGB_WMASK				(1 << 31)
 #define R500_US_ALU_RGB_ADDR_0				0x9000
-#   define R500_RGB_ADDR0(x)				(x << 0)
+#   define R500_RGB_ADDR0(x)				((x) << 0)
 #   define R500_RGB_ADDR0_CONST				(1 << 8)
 #   define R500_RGB_ADDR0_REL				(1 << 9)
-#   define R500_RGB_ADDR1(x)				(x << 10)
+#   define R500_RGB_ADDR1(x)				((x) << 10)
 #   define R500_RGB_ADDR1_CONST				(1 << 18)
 #   define R500_RGB_ADDR1_REL				(1 << 19)
-#   define R500_RGB_ADDR2(x)				(x << 20)
+#   define R500_RGB_ADDR2(x)				((x) << 20)
 #   define R500_RGB_ADDR2_CONST				(1 << 28)
 #   define R500_RGB_ADDR2_REL				(1 << 29)
 #   define R500_RGB_SRCP_OP_1_MINUS_2RGB0		(0 << 30)
@@ -2973,6 +3026,7 @@ enum {
 #   define R500_INST_RGB_OMASK_R			(1 << 15)
 #   define R500_INST_RGB_OMASK_G			(1 << 16)
 #   define R500_INST_RGB_OMASK_B			(1 << 17)
+#   define R500_INST_RGB_OMASK_RGB			(7 << 15)
 #   define R500_INST_ALPHA_OMASK			(1 << 18)
 #   define R500_INST_RGB_CLAMP				(1 << 19)
 #   define R500_INST_ALPHA_CLAMP			(1 << 20)
@@ -2996,19 +3050,19 @@ enum {
 
 /* note that these are 8 bit lengths, despite the offsets, at least for R500 */
 #define R500_US_CODE_ADDR				0x4630
-#   define R500_US_CODE_START_ADDR(x)			(x << 0)
-#   define R500_US_CODE_END_ADDR(x)			(x << 16)
+#   define R500_US_CODE_START_ADDR(x)			((x) << 0)
+#   define R500_US_CODE_END_ADDR(x)			((x) << 16)
 #define R500_US_CODE_OFFSET				0x4638
-#   define R500_US_CODE_OFFSET_ADDR(x)			(x << 0)
+#   define R500_US_CODE_OFFSET_ADDR(x)			((x) << 0)
 #define R500_US_CODE_RANGE				0x4634
-#   define R500_US_CODE_RANGE_ADDR(x)			(x << 0)
-#   define R500_US_CODE_RANGE_SIZE(x)			(x << 16)
+#   define R500_US_CODE_RANGE_ADDR(x)			((x) << 0)
+#   define R500_US_CODE_RANGE_SIZE(x)			((x) << 16)
 #define R500_US_CONFIG					0x4600
 #   define R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO		(1 << 1)
 #define R500_US_FC_ADDR_0				0xa000
-#   define R500_FC_BOOL_ADDR(x)				(x << 0)
-#   define R500_FC_INT_ADDR(x)				(x << 8)
-#   define R500_FC_JUMP_ADDR(x)				(x << 16)
+#   define R500_FC_BOOL_ADDR(x)				((x) << 0)
+#   define R500_FC_INT_ADDR(x)				((x) << 8)
+#   define R500_FC_JUMP_ADDR(x)				((x) << 16)
 #   define R500_FC_JUMP_GLOBAL				(1 << 31)
 #define R500_US_FC_BOOL_CONST				0x4620
 #   define R500_FC_KBOOL(x)				(x)
@@ -3029,8 +3083,8 @@ enum {
 #   define R500_FC_A_OP_NONE				(0 << 6)
 #   define R500_FC_A_OP_POP				(1 << 6)
 #   define R500_FC_A_OP_PUSH				(2 << 6)
-#   define R500_FC_JUMP_FUNC(x)				(x << 8)
-#   define R500_FC_B_POP_CNT(x)				(x << 16)
+#   define R500_FC_JUMP_FUNC(x)				((x) << 8)
+#   define R500_FC_B_POP_CNT(x)				((x) << 16)
 #   define R500_FC_B_OP0_NONE				(0 << 24)
 #   define R500_FC_B_OP0_DECR				(1 << 24)
 #   define R500_FC_B_OP0_INCR				(2 << 24)
@@ -3039,60 +3093,18 @@ enum {
 #   define R500_FC_B_OP1_INCR				(2 << 26)
 #   define R500_FC_IGNORE_UNCOVERED			(1 << 28)
 #define R500_US_FC_INT_CONST_0				0x4c00
-#   define R500_FC_INT_CONST_KR(x)			(x << 0)
-#   define R500_FC_INT_CONST_KG(x)			(x << 8)
-#   define R500_FC_INT_CONST_KB(x)			(x << 16)
+#   define R500_FC_INT_CONST_KR(x)			((x) << 0)
+#   define R500_FC_INT_CONST_KG(x)			((x) << 8)
+#   define R500_FC_INT_CONST_KB(x)			((x) << 16)
 /* _0 through _15 */
 #define R500_US_FORMAT0_0				0x4640
-#   define R500_FORMAT_TXWIDTH(x)			(x << 0)
-#   define R500_FORMAT_TXHEIGHT(x)			(x << 11)
-#   define R500_FORMAT_TXDEPTH(x)			(x << 22)
-/* _0 through _3 */
-#define R500_US_OUT_FMT_0				0x46A4
-#   define R500_OUT_FMT_C4_8				(0 << 0)
-#   define R500_OUT_FMT_C4_10				(1 << 0)
-#   define R500_OUT_FMT_C4_10_GAMMA			(2 << 0)
-#   define R500_OUT_FMT_C_16				(3 << 0)
-#   define R500_OUT_FMT_C2_16				(4 << 0)
-#   define R500_OUT_FMT_C4_16				(5 << 0)
-#   define R500_OUT_FMT_C_16_MPEG			(6 << 0)
-#   define R500_OUT_FMT_C2_16_MPEG			(7 << 0)
-#   define R500_OUT_FMT_C2_4				(8 << 0)
-#   define R500_OUT_FMT_C_3_3_2				(9 << 0)
-#   define R500_OUT_FMT_C_6_5_6				(10 << 0)
-#   define R500_OUT_FMT_C_11_11_10			(11 << 0)
-#   define R500_OUT_FMT_C_10_11_11			(12 << 0)
-#   define R500_OUT_FMT_C_2_10_10_10			(13 << 0)
-/* #define R500_OUT_FMT_RESERVED			(14 << 0) */
-#   define R500_OUT_FMT_UNUSED				(15 << 0)
-#   define R500_OUT_FMT_C_16_FP				(16 << 0)
-#   define R500_OUT_FMT_C2_16_FP			(17 << 0)
-#   define R500_OUT_FMT_C4_16_FP			(18 << 0)
-#   define R500_OUT_FMT_C_32_FP				(19 << 0)
-#   define R500_OUT_FMT_C2_32_FP			(20 << 0)
-#   define R500_OUT_FMT_C4_32_FP			(21 << 0)
-#   define R500_C0_SEL_A				(0 << 8)
-#   define R500_C0_SEL_R				(1 << 8)
-#   define R500_C0_SEL_G				(2 << 8)
-#   define R500_C0_SEL_B				(3 << 8)
-#   define R500_C1_SEL_A				(0 << 10)
-#   define R500_C1_SEL_R				(1 << 10)
-#   define R500_C1_SEL_G				(2 << 10)
-#   define R500_C1_SEL_B				(3 << 10)
-#   define R500_C2_SEL_A				(0 << 12)
-#   define R500_C2_SEL_R				(1 << 12)
-#   define R500_C2_SEL_G				(2 << 12)
-#   define R500_C2_SEL_B				(3 << 12)
-#   define R500_C3_SEL_A				(0 << 14)
-#   define R500_C3_SEL_R				(1 << 14)
-#   define R500_C3_SEL_G				(2 << 14)
-#   define R500_C3_SEL_B				(3 << 14)
-#   define R500_OUT_SIGN(x)				(x << 16)
-#   define R500_ROUND_ADJ				(1 << 20)
+#   define R500_FORMAT_TXWIDTH(x)			((x) << 0)
+#   define R500_FORMAT_TXHEIGHT(x)			((x) << 11)
+#   define R500_FORMAT_TXDEPTH(x)			((x) << 22)
 #define R500_US_PIXSIZE					0x4604
 #   define R500_PIX_SIZE(x)				(x)
 #define R500_US_TEX_ADDR_0				0x9800
-#   define R500_TEX_SRC_ADDR(x)				(x << 0)
+#   define R500_TEX_SRC_ADDR(x)				((x) << 0)
 #   define R500_TEX_SRC_ADDR_REL			(1 << 7)
 #   define R500_TEX_SRC_S_SWIZ_R			(0 << 8)
 #   define R500_TEX_SRC_S_SWIZ_G			(1 << 8)
@@ -3110,7 +3122,7 @@ enum {
 #   define R500_TEX_SRC_Q_SWIZ_G			(1 << 14)
 #   define R500_TEX_SRC_Q_SWIZ_B			(2 << 14)
 #   define R500_TEX_SRC_Q_SWIZ_A			(3 << 14)
-#   define R500_TEX_DST_ADDR(x)				(x << 16)
+#   define R500_TEX_DST_ADDR(x)				((x) << 16)
 #   define R500_TEX_DST_ADDR_REL			(1 << 23)
 #   define R500_TEX_DST_R_SWIZ_R			(0 << 24)
 #   define R500_TEX_DST_R_SWIZ_G			(1 << 24)
@@ -3129,7 +3141,7 @@ enum {
 #   define R500_TEX_DST_A_SWIZ_B			(2 << 30)
 #   define R500_TEX_DST_A_SWIZ_A			(3 << 30)
 #define R500_US_TEX_ADDR_DXDY_0				0xa000
-#   define R500_DX_ADDR(x)				(x << 0)
+#   define R500_DX_ADDR(x)				((x) << 0)
 #   define R500_DX_ADDR_REL				(1 << 7)
 #   define R500_DX_S_SWIZ_R				(0 << 8)
 #   define R500_DX_S_SWIZ_G				(1 << 8)
@@ -3147,7 +3159,7 @@ enum {
 #   define R500_DX_Q_SWIZ_G				(1 << 14)
 #   define R500_DX_Q_SWIZ_B				(2 << 14)
 #   define R500_DX_Q_SWIZ_A				(3 << 14)
-#   define R500_DY_ADDR(x)				(x << 16)
+#   define R500_DY_ADDR(x)				((x) << 16)
 #   define R500_DY_ADDR_REL				(1 << 17)
 #   define R500_DY_S_SWIZ_R				(0 << 24)
 #   define R500_DY_S_SWIZ_G				(1 << 24)
@@ -3166,7 +3178,7 @@ enum {
 #   define R500_DY_Q_SWIZ_B				(2 << 30)
 #   define R500_DY_Q_SWIZ_A				(3 << 30)
 #define R500_US_TEX_INST_0				0x9000
-#   define R500_TEX_ID(x)				(x << 16)
+#   define R500_TEX_ID(x)				((x) << 16)
 #   define R500_TEX_INST_NOP				(0 << 22)
 #   define R500_TEX_INST_LD				(1 << 22)
 #   define R500_TEX_INST_TEXKILL			(2 << 22)
@@ -3227,9 +3239,9 @@ enum {
 #define R300_PACKET3_3D_LOAD_VBPNTR         0x00002F00
 
 #define R300_PACKET3_INDX_BUFFER            0x00003300
-#    define R300_EB_UNK1_SHIFT                      24
-#    define R300_EB_UNK1                    (0x80<<24)
-#    define R300_EB_UNK2                        0x0810
+#    define R300_INDX_BUFFER_DST_SHIFT          0
+#    define R300_INDX_BUFFER_SKIP_SHIFT         16
+#    define R300_INDX_BUFFER_ONE_REG_WR		(1<<31)
 
 /* Same as R300_PACKET3_3D_DRAW_VBUF but without VAP_VTX_FMT */
 #define R300_PACKET3_3D_DRAW_VBUF_2         0x00003400
diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c
index 8ed66a1660c..d2c5998c261 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",
@@ -100,11 +101,9 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
             /* IN THEORY */
             return 0;
         case PIPE_CAP_MAX_RENDER_TARGETS:
-            /* XXX 4 eventually */
-            return 1;
+            return 4;
         case PIPE_CAP_OCCLUSION_QUERY:
-            /* IN THEORY */
-            return 0;
+            return 1;
         case PIPE_CAP_TEXTURE_SHADOW_MAP:
             /* IN THEORY */
             return 0;
@@ -121,7 +120,7 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
              * shows why this is silly. Assuming RGBA, 4cpp, we can see that
              * 4096*4096*4096 = 64.0 GiB exactly, so it's not exactly
              * practical. However, if at some point a game really wants this,
-             * then we can remove this limit. */
+             * then we can remove or raise this limit. */
             if (r300screen->caps->is_r500) {
                 /* 9 == 256x256x256 */
                 return 9;
@@ -142,7 +141,7 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
         case PIPE_CAP_TEXTURE_MIRROR_REPEAT:
             return 1;
         case PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS:
-            /* XXX guessing */
+            /* XXX guessing (what a terrible guess) */
             return 2;
         default:
             debug_printf("r300: Implementation error: Bad param %d\n",
@@ -175,15 +174,44 @@ static float r300_get_paramf(struct pipe_screen* pscreen, int param)
     }
 }
 
-/* XXX moar formats */
-static boolean check_tex_2d_format(enum pipe_format format)
+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:
+        /* Colorbuffer or texture */
         case PIPE_FORMAT_I8_UNORM:
+        /* Z buffer */
+        case PIPE_FORMAT_Z16_UNORM:
+        /* Z buffer with stencil */
+        case PIPE_FORMAT_Z24S8_UNORM:
             return TRUE;
+
+        /* 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)
+            debug_printf("r300: Warning: Got unimplemented format: %s in %s\n",
+                pf_name(format), __FUNCTION__);
+            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:
+            debug_printf(
+                "r300: Warning: Got unimplemented r500 format: %s in %s\n",
+                pf_name(format), __FUNCTION__);
+            return FALSE; */
+
         default:
-            debug_printf("r300: Warning: Got unknown format: %s, in %s\n",
+            debug_printf("r300: Warning: Got unsupported format: %s in %s\n",
                 pf_name(format), __FUNCTION__);
             break;
     }
@@ -200,7 +228,8 @@ static boolean r300_is_format_supported(struct pipe_screen* pscreen,
 {
     switch (target) {
         case PIPE_TEXTURE_2D:
-            return check_tex_2d_format(format);
+            return check_tex_2d_format(format,
+                r300_screen(pscreen)->caps->is_r500);
         default:
             debug_printf("r300: Warning: Got unknown format target: %d\n",
                 format);
@@ -210,24 +239,84 @@ static boolean r300_is_format_supported(struct pipe_screen* pscreen,
     return FALSE;
 }
 
-static void* r300_surface_map(struct pipe_screen* screen,
-                              struct pipe_surface* surface,
-                              unsigned flags)
+static struct pipe_transfer*
+r300_get_tex_transfer(struct pipe_screen *screen,
+                      struct pipe_texture *texture,
+                      unsigned face, unsigned level, unsigned zslice,
+                      enum pipe_transfer_usage usage, unsigned x, unsigned y,
+                      unsigned w, unsigned h)
+{
+    struct r300_texture *tex = (struct r300_texture *)texture;
+    struct r300_transfer *trans;
+    unsigned offset;  /* in bytes */
+
+    /* XXX Add support for these things */
+    if (texture->target == PIPE_TEXTURE_CUBE) {
+        debug_printf("PIPE_TEXTURE_CUBE is not yet supported.\n");
+        /* offset = tex->image_offset[level][face]; */
+    }
+    else if (texture->target == PIPE_TEXTURE_3D) {
+        debug_printf("PIPE_TEXTURE_3D is not yet supported.\n");
+        /* offset = tex->image_offset[level][zslice]; */
+    }
+    else {
+        offset = tex->offset[level];
+        assert(face == 0);
+        assert(zslice == 0);
+    }
+
+    trans = CALLOC_STRUCT(r300_transfer);
+    if (trans) {
+        pipe_texture_reference(&trans->transfer.texture, texture);
+        trans->transfer.format = trans->transfer.format;
+        trans->transfer.width = w;
+        trans->transfer.height = h;
+        trans->transfer.block = texture->block;
+        trans->transfer.nblocksx = texture->nblocksx[level];
+        trans->transfer.nblocksy = texture->nblocksy[level];
+        trans->transfer.stride = tex->stride;
+        trans->transfer.usage = usage;
+        trans->offset = offset;
+    }
+    return &trans->transfer;
+}
+
+static void
+r300_tex_transfer_destroy(struct pipe_transfer *trans)
 {
-    struct r300_texture* tex = (struct r300_texture*)surface->texture;
-    char* map = pipe_buffer_map(screen, tex->buffer, flags);
+   pipe_texture_reference(&trans->texture, NULL);
+   FREE(trans);
+}
+
+static void* r300_transfer_map(struct pipe_screen* screen,
+                              struct pipe_transfer* transfer)
+{
+    struct r300_texture* tex = (struct r300_texture*)transfer->texture;
+    char* map;
+    unsigned flags = 0;
+
+    if (transfer->usage != PIPE_TRANSFER_WRITE) {
+        flags |= PIPE_BUFFER_USAGE_CPU_READ;
+    }
+    if (transfer->usage != PIPE_TRANSFER_READ) {
+        flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+    }
+    
+    map = pipe_buffer_map(screen, tex->buffer, flags);
 
     if (!map) {
         return NULL;
     }
 
-    return map + surface->offset;
+    return map + r300_transfer(transfer)->offset +
+        transfer->y / transfer->block.height * transfer->stride +
+        transfer->x / transfer->block.width * transfer->block.size;
 }
 
-static void r300_surface_unmap(struct pipe_screen* screen,
-                               struct pipe_surface* surface)
+static void r300_transfer_unmap(struct pipe_screen* screen,
+                                struct pipe_transfer* transfer)
 {
-    struct r300_texture* tex = (struct r300_texture*)surface->texture;
+    struct r300_texture* tex = (struct r300_texture*)transfer->texture;
     pipe_buffer_unmap(screen, tex->buffer);
 }
 
@@ -239,8 +328,7 @@ static void r300_destroy_screen(struct pipe_screen* pscreen)
     FREE(r300screen);
 }
 
-struct pipe_screen* r300_create_screen(struct pipe_winsys* winsys,
-                                       struct r300_winsys* r300_winsys)
+struct pipe_screen* r300_create_screen(struct r300_winsys* r300_winsys)
 {
     struct r300_screen* r300screen = CALLOC_STRUCT(r300_screen);
     struct r300_capabilities* caps = CALLOC_STRUCT(r300_capabilities);
@@ -254,15 +342,17 @@ struct pipe_screen* r300_create_screen(struct pipe_winsys* winsys,
     r300_parse_chipset(caps);
 
     r300screen->caps = caps;
-    r300screen->screen.winsys = winsys;
+    r300screen->screen.winsys = (struct pipe_winsys*)r300_winsys;
     r300screen->screen.destroy = r300_destroy_screen;
     r300screen->screen.get_name = r300_get_name;
     r300screen->screen.get_vendor = r300_get_vendor;
     r300screen->screen.get_param = r300_get_param;
     r300screen->screen.get_paramf = r300_get_paramf;
     r300screen->screen.is_format_supported = r300_is_format_supported;
-    r300screen->screen.surface_map = r300_surface_map;
-    r300screen->screen.surface_unmap = r300_surface_unmap;
+    r300screen->screen.get_tex_transfer = r300_get_tex_transfer;
+    r300screen->screen.tex_transfer_destroy = r300_tex_transfer_destroy;
+    r300screen->screen.transfer_map = r300_transfer_map;
+    r300screen->screen.transfer_unmap = r300_transfer_unmap;
 
     r300_init_screen_texture_functions(&r300screen->screen);
     u_simple_screen_init(&r300screen->screen);
diff --git a/src/gallium/drivers/r300/r300_screen.h b/src/gallium/drivers/r300/r300_screen.h
index 2e25f61dbf1..3f52dbc3bea 100644
--- a/src/gallium/drivers/r300/r300_screen.h
+++ b/src/gallium/drivers/r300/r300_screen.h
@@ -40,13 +40,27 @@ struct r300_screen {
     struct r300_capabilities* caps;
 };
 
+struct r300_transfer {
+    /* Parent class */
+    struct pipe_transfer transfer;
+
+    /* Offset from start of buffer. */
+    unsigned offset;
+};
+
 /* Convenience cast wrapper. */
 static struct r300_screen* r300_screen(struct pipe_screen* screen) {
     return (struct r300_screen*)screen;
 }
 
+/* Convenience cast wrapper. */
+static INLINE struct r300_transfer*
+r300_transfer(struct pipe_transfer* transfer)
+{
+    return (struct r300_transfer*)transfer;
+}
+
 /* Creates a new r300 screen. */
-struct pipe_screen* r300_create_screen(struct pipe_winsys* winsys,
-                                       struct r300_winsys* r300_winsys);
+struct pipe_screen* r300_create_screen(struct r300_winsys* r300_winsys);
 
 #endif /* R300_SCREEN_H */
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index 9392d723427..58bce22fc81 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -22,92 +22,17 @@
 
 #include "util/u_math.h"
 #include "util/u_pack_color.h"
-#include "pipe/p_debug.h"
+
+#include "util/u_debug.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #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.
  *
@@ -123,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);
     }
 
@@ -175,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);
 
@@ -210,83 +131,24 @@ static void
                              uint shader, uint index,
                              const struct pipe_constant_buffer* buffer)
 {
-    /* XXX */
-}
-
-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;
-}
+    struct r300_context* r300 = r300_context(pipe);
 
-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;
+    /* This entire chunk of code seems ever-so-slightly baked.
+     * It's as if I've got pipe_buffer* matryoshkas... */
+    if (buffer && buffer->buffer && buffer->buffer->size) {
+        void* map = pipe->winsys->buffer_map(pipe->winsys, buffer->buffer,
+                                             PIPE_BUFFER_USAGE_CPU_READ);
+        memcpy(r300->shader_constants[shader].constants,
+            map, buffer->buffer->size);
+        pipe->winsys->buffer_unmap(pipe->winsys, buffer->buffer);
+
+        r300->shader_constants[shader].user_count =
+            buffer->buffer->size / (sizeof(float) * 4);
+    } else {
+        r300->shader_constants[shader].user_count = 0;
     }
-    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;
+    r300->dirty_state |= R300_NEW_CONSTANTS;
 }
 
 /* Create a new depth, stencil, and alpha state based on the CSO dsa state.
@@ -309,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);
     }
 
@@ -317,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) |
@@ -333,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) |
@@ -350,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);
@@ -415,6 +278,8 @@ static void* r300_create_fs_state(struct pipe_context* pipe,
     /* Copy state directly into shader. */
     fs->state = *shader;
 
+    tgsi_scan_shader(shader->tokens, &fs->info);
+
     return (void*)fs;
 }
 
@@ -424,14 +289,18 @@ static void r300_bind_fs_state(struct pipe_context* pipe, void* shader)
     struct r300_context* r300 = r300_context(pipe);
     struct r3xx_fragment_shader* fs = (struct r3xx_fragment_shader*)shader;
 
-    if (!fs->translated) {
+    if (fs == NULL) {
+        r300->fs = NULL;
+        return;
+    } else if (!fs->translated) {
         if (r300_screen(r300->context.screen)->caps->is_r500) {
-            r500_translate_shader(r300, fs);
+            r500_translate_fragment_shader(r300, (struct r500_fragment_shader*)fs);
         } else {
-            r300_translate_shader(r300, fs);
+            r300_translate_fragment_shader(r300, (struct r300_fragment_shader*)fs);
         }
     }
 
+    fs->translated = TRUE;
     r300->fs = fs;
 
     r300->dirty_state |= R300_NEW_FRAGMENT_SHADER;
@@ -449,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
@@ -472,6 +337,12 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
     rs->point_size = pack_float_16_6x(state->point_size) |
         (pack_float_16_6x(state->point_size) << R300_POINTSIZE_X_SHIFT);
 
+    rs->point_minmax =
+        ((int)(state->point_size_min * 6.0) <<
+         R300_GA_POINT_MINMAX_MIN_SHIFT) |
+        ((int)(state->point_size_max * 6.0) <<
+         R300_GA_POINT_MINMAX_MAX_SHIFT);
+
     rs->line_control = pack_float_16_6x(state->line_width) |
         R300_GA_LINE_CNTL_END_TYPE_COMP;
 
@@ -504,20 +375,28 @@ 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;
     }
 
+    if (state->flatshade) {
+        rs->color_control = R300_SHADE_MODEL_FLAT;
+    } else {
+        rs->color_control = R300_SHADE_MODEL_SMOOTH;
+    }
+
+    rs->rs = *state;
+
     return (void*)rs;
 }
 
@@ -525,8 +404,11 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
 static void r300_bind_rs_state(struct pipe_context* pipe, void* state)
 {
     struct r300_context* r300 = r300_context(pipe);
+    struct r300_rs_state* rs = (struct r300_rs_state*)state;
+
+    draw_set_rasterizer_state(r300->draw, &rs->rs);
 
-    r300->rs_state = (struct r300_rs_state*)state;
+    r300->rs_state = rs;
     r300->dirty_state |= R300_NEW_RASTERIZER;
 }
 
@@ -536,83 +418,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)
@@ -622,19 +427,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);
@@ -710,20 +515,12 @@ static void r300_set_scissor_state(struct pipe_context* pipe,
     struct r300_context* r300 = r300_context(pipe);
     draw_flush(r300->draw);
 
-    uint32_t left, top, right, bottom;
-
-    /* So, a bit of info. The scissors are offset by R300_SCISSORS_OFFSET in
-     * both directions for all values, and can only be 13 bits wide. Why?
-     * We may never know. */
-    left = (state->minx + R300_SCISSORS_OFFSET) & 0x1fff;
-    top = (state->miny + R300_SCISSORS_OFFSET) & 0x1fff;
-    right = (state->maxx + R300_SCISSORS_OFFSET) & 0x1fff;
-    bottom = (state->maxy + R300_SCISSORS_OFFSET) & 0x1fff;
-
-    r300->scissor_state->scissor_top_left = (left << R300_SCISSORS_X_SHIFT) |
-            (top << R300_SCISSORS_Y_SHIFT);
+    r300->scissor_state->scissor_top_left =
+        (state->minx << R300_SCISSORS_X_SHIFT) |
+        (state->miny << R300_SCISSORS_Y_SHIFT);
     r300->scissor_state->scissor_bottom_right =
-        (right << R300_SCISSORS_X_SHIFT) | (bottom << R300_SCISSORS_Y_SHIFT);
+        (state->maxx << R300_SCISSORS_X_SHIFT) |
+        (state->maxy << R300_SCISSORS_Y_SHIFT);
 
     r300->dirty_state |= R300_NEW_SCISSOR;
 }
@@ -732,8 +529,26 @@ static void r300_set_viewport_state(struct pipe_context* pipe,
                                     const struct pipe_viewport_state* state)
 {
     struct r300_context* r300 = r300_context(pipe);
-    /* XXX handing this off to Draw for now */
-    draw_set_viewport_state(r300->draw, state);
+
+    r300->viewport_state->xscale = state->scale[0];
+    r300->viewport_state->yscale = state->scale[1];
+    r300->viewport_state->zscale = state->scale[2];
+
+    r300->viewport_state->xoffset = state->translate[0];
+    r300->viewport_state->yoffset = state->translate[1];
+    r300->viewport_state->zoffset = state->translate[2];
+
+    r300->viewport_state->vte_control = 0;
+    if (r300_screen(r300->context.screen)->caps->has_tcl) {
+        /* Do the transform in HW. */
+        r300->viewport_state->vte_control |=
+            R300_VPORT_X_SCALE_ENA | R300_VPORT_X_OFFSET_ENA |
+            R300_VPORT_Y_SCALE_ENA | R300_VPORT_Y_OFFSET_ENA |
+            R300_VPORT_Z_SCALE_ENA | R300_VPORT_Z_OFFSET_ENA;
+    } else {
+        /* Have Draw do the actual transform. */
+        draw_set_viewport_state(r300->draw, state);
+    }
 }
 
 static void r300_set_vertex_buffers(struct pipe_context* pipe,
@@ -741,7 +556,12 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
                                     const struct pipe_vertex_buffer* buffers)
 {
     struct r300_context* r300 = r300_context(pipe);
-    /* XXX Draw */
+
+    memcpy(r300->vertex_buffers, buffers,
+        sizeof(struct pipe_vertex_buffer) * count);
+
+    r300->vertex_buffer_count = count;
+
     draw_flush(r300->draw);
     draw_set_vertex_buffers(r300->draw, count, buffers);
 }
diff --git a/src/gallium/drivers/r300/r300_state_derived.c b/src/gallium/drivers/r300/r300_state_derived.c
new file mode 100644
index 00000000000..d761a0302f0
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_derived.c
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2008 Corbin Simpson <[email protected]>
+ *
+ * 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_derived.h"
+
+/* r300_state_derived: Various bits of state which are dependent upon
+ * currently bound CSO data. */
+
+/* Update the vertex_info struct in our r300_context.
+ *
+ * The vertex_info struct describes the post-TCL format of vertices. It is
+ * required for Draw when doing SW TCL, and also for describing the
+ * dreaded RS block on R300 chipsets. */
+/* 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;
+    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);
+
+    for (i = 0; i < info->num_inputs; i++) {
+        switch (info->input_semantic_name[i]) {
+            case TGSI_SEMANTIC_POSITION:
+                pos = TRUE;
+                tab[i] = 0;
+                break;
+            case TGSI_SEMANTIC_COLOR:
+                tab[i] = 2 + cols++;
+                break;
+            case TGSI_SEMANTIC_PSIZE:
+                psize = TRUE;
+                tab[i] = 1;
+                break;
+            case TGSI_SEMANTIC_FOG:
+                fog = TRUE;
+                /* Fall through... */
+            case TGSI_SEMANTIC_GENERIC:
+                tab[i] = 6 + texs++;
+                break;
+            default:
+                debug_printf("r300: Unknown vertex input %d\n",
+                    info->input_semantic_name[i]);
+                break;
+        }
+    }
+
+    /* Do the actual vertex_info setup.
+     *
+     * vertex_info has four uints of hardware-specific data in it.
+     * vinfo.hwfmt[0] is R300_VAP_VTX_STATE_CNTL
+     * vinfo.hwfmt[1] is R300_VAP_VSM_VTX_ASSM
+     * vinfo.hwfmt[2] is R300_VAP_OUTPUT_VTX_FMT_0
+     * vinfo.hwfmt[3] is R300_VAP_OUTPUT_VTX_FMT_1 */
+
+    vinfo.hwfmt[0] = 0x5555; /* XXX this is classic Mesa bonghits */
+
+    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 = 15; i > 0; i--) {
+            tab[i] = tab[i-1];
+        }
+        tab[0] = 0;
+
+        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_POS,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_POSITION, 0));
+    } else {
+        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_PERSPECTIVE,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_POSITION, 0));
+    }
+    vinfo.hwfmt[1] |= R300_INPUT_CNTL_POS;
+    vinfo.hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
+
+    if (psize) {
+        draw_emit_vertex_attr(&vinfo, EMIT_1F_PSIZE, INTERP_POS,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_PSIZE, 0));
+        vinfo.hwfmt[2] |= R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;
+    }
+
+    for (i = 0; i < cols; i++) {
+        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_LINEAR,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_COLOR, i));
+        vinfo.hwfmt[1] |= R300_INPUT_CNTL_COLOR;
+        vinfo.hwfmt[2] |= (R300_VAP_OUTPUT_VTX_FMT_0__COLOR_0_PRESENT << i);
+    }
+
+    for (i = 0; i < texs; i++) {
+        draw_emit_vertex_attr(&vinfo, EMIT_4F, INTERP_PERSPECTIVE,
+            draw_find_vs_output(r300->draw, TGSI_SEMANTIC_GENERIC, i));
+        vinfo.hwfmt[1] |= (R300_INPUT_CNTL_TC0 << i);
+        vinfo.hwfmt[3] |= (4 << (3 * 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));
+    }
+
+    draw_compute_vertex_size(&vinfo);
+
+    if (memcmp(&r300->vertex_info, &vinfo, sizeof(struct vertex_info))) {
+        uint32_t temp;
+        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]);
+        }
+
+        for (i = 0; i < vinfo.num_attribs; i++) {
+            /* Make sure we have a proper destination for our attribute */
+            assert(tab[i] != -1);
+
+            temp = translate_vertex_data_type(vinfo.attrib[i].emit) |
+                (tab[i] << R300_DST_VEC_LOC_SHIFT);
+            if (i & 1) {
+                r300->vertex_info.vap_prog_stream_cntl[i >> 1] &= 0x0000ffff;
+                r300->vertex_info.vap_prog_stream_cntl[i >> 1] |= temp << 16;
+            } else {
+                r300->vertex_info.vap_prog_stream_cntl[i >> 1] &= 0xffff0000;
+                r300->vertex_info.vap_prog_stream_cntl[i >> 1] |= temp;
+            }
+
+            r300->vertex_info.vap_prog_stream_cntl_ext[i >> 1] |=
+                (R300_VAP_SWIZZLE_XYZW << (i & 1 ? 16 : 0));
+        }
+        /* Set the last vector. */
+        i--;
+        r300->vertex_info.vap_prog_stream_cntl[i >> 1] |= (R300_LAST_VEC <<
+                (i & 1 ? 16 : 0));
+
+        memcpy(r300->vertex_info.tab, tab, sizeof(tab));
+        memcpy(&r300->vertex_info, &vinfo, sizeof(struct vertex_info));
+        r300->dirty_state |= R300_NEW_VERTEX_FORMAT;
+    }
+}
+
+/* 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. */
+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* tab = r300->vertex_info.tab;
+    int col_count = 0, fp_offset = 0, i, memory_pos, 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++) {
+            assert(tab[vinfo->attrib[i].src_index] != -1);
+            memory_pos = tab[vinfo->attrib[i].src_index] * 4;
+            switch (vinfo->attrib[i].interp_mode) {
+                case INTERP_LINEAR:
+                    rs->ip[col_count] |=
+                        R500_RS_COL_PTR(memory_pos) |
+                        R500_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
+                    col_count++;
+                    break;
+                case INTERP_PERSPECTIVE:
+                    rs->ip[tex_count] |=
+                        R500_RS_SEL_S(memory_pos) |
+                        R500_RS_SEL_T(memory_pos + 1) |
+                        R500_RS_SEL_R(memory_pos + 2) |
+                        R500_RS_SEL_Q(memory_pos + 3);
+                    tex_count++;
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if (col_count == 0) {
+            rs->ip[0] |= R500_RS_COL_FMT(R300_RS_COL_FMT_0001);
+        }
+
+        /* Set up at least one texture pointer or RS will not be happy. */
+        if (tex_count == 0) {
+            rs->ip[0] |=
+                R500_RS_SEL_S(R500_RS_IP_PTR_K0) |
+                R500_RS_SEL_T(R500_RS_IP_PTR_K0) |
+                R500_RS_SEL_R(R500_RS_IP_PTR_K0) |
+                R500_RS_SEL_Q(R500_RS_IP_PTR_K1);
+        }
+
+        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++;
+        }
+    } else {
+        for (i = 0; i < vinfo->num_attribs; i++) {
+            memory_pos = tab[vinfo->attrib[i].src_index] * 4;
+            assert(tab[vinfo->attrib[i].src_index] != -1);
+            switch (vinfo->attrib[i].interp_mode) {
+                case INTERP_LINEAR:
+                    rs->ip[col_count] |=
+                        R300_RS_COL_PTR(memory_pos) |
+                        R300_RS_COL_FMT(R300_RS_COL_FMT_RGBA);
+                    col_count++;
+                    break;
+                case INTERP_PERSPECTIVE:
+                    rs->ip[tex_count] |=
+                        R300_RS_TEX_PTR(memory_pos) |
+                        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++;
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if (col_count == 0) {
+            rs->ip[0] |= R300_RS_COL_FMT(R300_RS_COL_FMT_0001);
+        }
+
+        if (tex_count == 0) {
+            rs->ip[0] |=
+                R300_RS_SEL_S(R300_RS_SEL_K0) |
+                R300_RS_SEL_T(R300_RS_SEL_K0) |
+                R300_RS_SEL_R(R300_RS_SEL_K0) |
+                R300_RS_SEL_Q(R300_RS_SEL_K1);
+        }
+
+        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(MAX2(col_count - 1, tex_count - 1), 0);
+}
+
+void r300_update_derived_state(struct r300_context* r300)
+{
+    if (r300->dirty_state & R300_NEW_FRAGMENT_SHADER) {
+        r300_update_vertex_layout(r300);
+    }
+
+    if (r300->dirty_state & R300_NEW_VERTEX_FORMAT) {
+        r300_update_rs_block(r300);
+    }
+}
diff --git a/src/gallium/drivers/r300/r300_state_derived.h b/src/gallium/drivers/r300/r300_state_derived.h
new file mode 100644
index 00000000000..63ae8eb8d08
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_derived.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2008 Corbin Simpson <[email protected]>
+ *
+ * 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_DERIVED_H
+#define R300_STATE_DERIVED_H
+
+#include "draw/draw_vertex.h"
+
+#include "r300_context.h"
+#include "r300_reg.h"
+#include "r300_state_inlines.h"
+
+void r300_update_derived_state(struct r300_context* r300);
+
+#endif /* R300_STATE_DERIVED_H */
diff --git a/src/gallium/drivers/r300/r300_state_inlines.h b/src/gallium/drivers/r300/r300_state_inlines.h
new file mode 100644
index 00000000000..fd92c71756b
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_inlines.h
@@ -0,0 +1,384 @@
+/*
+ * Copyright 2009 Joakim Sindholt <[email protected]>
+ *                Corbin Simpson <[email protected]>
+ *
+ * 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_INLINES_H
+#define R300_STATE_INLINES_H
+
+#include "pipe/p_format.h"
+
+#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;
+            break;
+        case PIPE_TEX_FILTER_LINEAR:
+            retval |= R300_TX_MIN_FILTER_LINEAR;
+            break;
+        case PIPE_TEX_FILTER_ANISO:
+            retval |= R300_TX_MIN_FILTER_ANISO;
+            break;
+        default:
+            debug_printf("r300: Unknown texture filter %d\n", min);
+            break;
+    }
+    switch (mag) {
+        case PIPE_TEX_FILTER_NEAREST:
+            retval |= R300_TX_MAG_FILTER_NEAREST;
+            break;
+        case PIPE_TEX_FILTER_LINEAR:
+            retval |= R300_TX_MAG_FILTER_LINEAR;
+            break;
+        case PIPE_TEX_FILTER_ANISO:
+            retval |= R300_TX_MAG_FILTER_ANISO;
+            break;
+        default:
+            debug_printf("r300: Unknown texture filter %d\n", mag);
+            break;
+    }
+    switch (mip) {
+        case PIPE_TEX_MIPFILTER_NONE:
+            retval |= R300_TX_MIN_FILTER_MIP_NONE;
+            break;
+        case PIPE_TEX_MIPFILTER_NEAREST:
+            retval |= R300_TX_MIN_FILTER_MIP_NEAREST;
+            break;
+        case PIPE_TEX_MIPFILTER_LINEAR:
+            retval |= R300_TX_MIN_FILTER_MIP_LINEAR;
+            break;
+        default:
+            debug_printf("r300: Unknown texture filter %d\n", 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) {
+        /* 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) {
+        /* 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;
+}
+
+static INLINE uint32_t translate_vertex_data_type(int type) {
+    switch (type) {
+        case EMIT_1F:
+        case EMIT_1F_PSIZE:
+            return R300_DATA_TYPE_FLOAT_1;
+            break;
+        case EMIT_2F:
+            return R300_DATA_TYPE_FLOAT_2;
+            break;
+        case EMIT_3F:
+            return R300_DATA_TYPE_FLOAT_3;
+            break;
+        case EMIT_4F:
+            return R300_DATA_TYPE_FLOAT_4;
+            break;
+        case EMIT_4UB:
+            return R300_DATA_TYPE_BYTE;
+            break;
+        default:
+            debug_printf("r300: Implementation error: "
+                    "Bad vertex data type!\n");
+            assert(0);
+            break;
+    }
+
+    return 0;
+}
+
+#endif /* R300_STATE_INLINES_H */
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 00000000000..3d51a8e65d2
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_invariant.c
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2009 Joakim Sindholt <[email protected]>
+ *                Corbin Simpson <[email protected]>
+ *
+ * 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(24 + (caps->has_tcl ? 2: 0));
+
+    /* 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);
+    /* GA errata fixes. */
+    if (caps->is_r500) {
+        OUT_CS_REG(R300_GA_ENHANCE,
+                R300_GA_ENHANCE_DEADLOCK_CNTL_PREVENT_TCL |
+                R300_GA_ENHANCE_FASTSYNC_CNTL_ENABLE |
+                R500_GA_ENHANCE_REG_READWRITE_ENABLE |
+                R500_GA_ENHANCE_REG_NOSTALL_ENABLE);
+    } else {
+        OUT_CS_REG(R300_GA_ENHANCE,
+                R300_GA_ENHANCE_DEADLOCK_CNTL_PREVENT_TCL |
+                R300_GA_ENHANCE_FASTSYNC_CNTL_ENABLE);
+    }
+
+    /* Fog block. */
+    OUT_CS_REG(R300_FG_FOG_BLEND, 0x00000000);
+    OUT_CS_REG(R300_FG_FOG_COLOR_R, 0x00000000);
+    OUT_CS_REG(R300_FG_FOG_COLOR_G, 0x00000000);
+    OUT_CS_REG(R300_FG_FOG_COLOR_B, 0x00000000);
+    OUT_CS_REG(R300_FG_DEPTH_SRC, 0x00000000);
+
+    /* TCL-only stuff */
+    if (caps->has_tcl) {
+        /* Amount of time to wait for vertex fetches in PVS */
+        OUT_CS_REG(VAP_PVS_VTX_TIMEOUT_REG, 0xffff);
+    }
+
+    END_CS;
+
+    /* XXX unsorted stuff from surface_fill */
+    BEGIN_CS(99 + (caps->has_tcl ? 26 : 0));
+    /* Flush PVS. */
+    OUT_CS_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0x0);
+
+    OUT_CS_REG(R300_SE_VTE_CNTL, R300_VPORT_X_SCALE_ENA |
+        R300_VPORT_X_OFFSET_ENA | R300_VPORT_Y_SCALE_ENA |
+        R300_VPORT_Y_OFFSET_ENA | R300_VPORT_Z_SCALE_ENA |
+        R300_VPORT_Z_OFFSET_ENA | R300_VTX_W0_FMT);
+    /* Max and min vertex index clamp. */
+    OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, 0xFFFFFF);
+    OUT_CS_REG(R300_VAP_VF_MIN_VTX_INDX, 0x0);
+    /* XXX endian */
+    if (caps->has_tcl) {
+        OUT_CS_REG(R300_VAP_CNTL_STATUS, R300_VC_NO_SWAP);
+        OUT_CS_REG(R300_VAP_CLIP_CNTL, R300_CLIP_DISABLE |
+            R300_PS_UCP_MODE_CLIP_AS_TRIFAN);
+        OUT_CS_REG_SEQ(R300_VAP_GB_VERT_CLIP_ADJ, 4);
+        OUT_CS_32F(1.0);
+        OUT_CS_32F(1.0);
+        OUT_CS_32F(1.0);
+        OUT_CS_32F(1.0);
+    } else {
+        OUT_CS_REG(R300_VAP_CNTL_STATUS, R300_VC_NO_SWAP |
+                R300_VAP_TCL_BYPASS);
+    }
+    /* XXX magic number not in r300_reg */
+    OUT_CS_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0xAAAAAAAA);
+    /* XXX point tex stuffing */
+    OUT_CS_REG_SEQ(R300_GA_POINT_S0, 1);
+    OUT_CS_32F(0.0);
+    OUT_CS_REG_SEQ(R300_GA_POINT_S1, 1);
+    OUT_CS_32F(1.0);
+    OUT_CS_REG(R300_GA_TRIANGLE_STIPPLE, 0x5 |
+        (0x5 << R300_GA_TRIANGLE_STIPPLE_Y_SHIFT_SHIFT));
+    /* XXX this big chunk should be refactored into rs_state */
+    OUT_CS_REG(R300_GA_LINE_S0, 0x00000000);
+    OUT_CS_REG(R300_GA_LINE_S1, 0x3F800000);
+    OUT_CS_REG(R300_GA_SOLID_RG, 0x00000000);
+    OUT_CS_REG(R300_GA_SOLID_BA, 0x00000000);
+    OUT_CS_REG(R300_GA_POLY_MODE, 0x00000000);
+    OUT_CS_REG(R300_GA_ROUND_MODE, 0x00000001);
+    OUT_CS_REG(R300_GA_OFFSET, 0x00000000);
+    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_DEPTH_SCALE, 0x4B7FFFFF);
+    OUT_CS_REG(R300_SU_DEPTH_OFFSET, 0x00000000);
+    OUT_CS_REG(R300_SC_HYPERZ, 0x0000001C);
+    OUT_CS_REG(R300_SC_EDGERULE, 0x2DA49525);
+    OUT_CS_REG(R300_RB3D_CCTL, 0x00000000);
+    OUT_CS_REG(RB3D_COLOR_CHANNEL_MASK, 0x0000000F);
+    OUT_CS_REG(R300_RB3D_AARESOLVE_CTL, 0x00000000);
+    OUT_CS_REG(R500_RB3D_DISCARD_SRC_PIXEL_LTE_THRESHOLD, 0x00000000);
+    OUT_CS_REG(R500_RB3D_DISCARD_SRC_PIXEL_GTE_THRESHOLD, 0xFFFFFFFF);
+    OUT_CS_REG(R300_ZB_FORMAT, 0x00000002);
+    OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT, 0x00000003);
+    OUT_CS_REG(R300_ZB_BW_CNTL, 0x00000000);
+    OUT_CS_REG(R300_ZB_DEPTHCLEARVALUE, 0x00000000);
+    OUT_CS_REG(R300_ZB_HIZ_OFFSET, 0x00000000);
+    OUT_CS_REG(R300_ZB_HIZ_PITCH, 0x00000000);
+    if (caps->has_tcl) {
+        OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_0,
+            (R300_DATA_TYPE_FLOAT_4 << R300_DATA_TYPE_0_SHIFT) |
+            ((R300_LAST_VEC | (1 << R300_DST_VEC_LOC_SHIFT) |
+                R300_DATA_TYPE_FLOAT_4) << R300_DATA_TYPE_1_SHIFT));
+    } else {
+        OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_0,
+            (R300_DATA_TYPE_FLOAT_4 << R300_DATA_TYPE_0_SHIFT) |
+            ((R300_LAST_VEC | (2 << R300_DST_VEC_LOC_SHIFT) |
+                R300_DATA_TYPE_FLOAT_4) << R300_DATA_TYPE_1_SHIFT));
+    }
+    OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_EXT_0,
+            (R300_VAP_SWIZZLE_XYZW << R300_SWIZZLE0_SHIFT) |
+            (R300_VAP_SWIZZLE_XYZW << R300_SWIZZLE1_SHIFT));
+    OUT_CS_REG(R300_VAP_VTX_STATE_CNTL, 0x1);
+    OUT_CS_REG(R300_VAP_VSM_VTX_ASSM, 0x405);
+    OUT_CS_REG(R300_SE_VTE_CNTL, 0x0000043F);
+    /* Vertex size. */
+    OUT_CS_REG(R300_VAP_VTX_SIZE, 0x8);
+    OUT_CS_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0xAAAAAAAA);
+    OUT_CS_REG(R300_VAP_OUTPUT_VTX_FMT_0, 0x00000003);
+    OUT_CS_REG(R300_VAP_OUTPUT_VTX_FMT_1, 0x00000000);
+    OUT_CS_REG(R300_TX_ENABLE, 0x0);
+
+    /* XXX */
+    OUT_CS_REG(R300_SC_CLIP_RULE, 0xaaaa);
+
+    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);
+    OUT_CS(R300_US_OUT_FMT_UNUSED);
+    OUT_CS(R300_US_OUT_FMT_UNUSED);
+    OUT_CS_REG(R300_US_W_FMT, R300_W_FMT_W0);
+    /* XXX these magic numbers should be explained when
+     * this becomes a cached state object */
+    if (caps->has_tcl) {
+        OUT_CS_REG(R300_VAP_CNTL, 0xA |
+            (0x5 << R300_PVS_NUM_CNTLRS_SHIFT) |
+            (0xB << R300_VF_MAX_VTX_NUM_SHIFT) |
+            (caps->num_vert_fpus << R300_PVS_NUM_FPUS_SHIFT));
+        OUT_CS_REG(R300_VAP_PVS_CODE_CNTL_0, 0x00100000);
+        OUT_CS_REG(R300_VAP_PVS_CONST_CNTL, 0x00000000);
+        OUT_CS_REG(R300_VAP_PVS_CODE_CNTL_1, 0x00000001);
+        /* XXX translate these back into normal instructions */
+        OUT_CS_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0x1);
+        OUT_CS_REG(R300_VAP_PVS_VECTOR_INDX_REG, 0x0);
+        OUT_CS_ONE_REG(R300_VAP_PVS_UPLOAD_DATA, 8);
+        OUT_CS(0x00F00203);
+        OUT_CS(0x00D10001);
+        OUT_CS(0x01248001);
+        OUT_CS(0x00000000);
+        OUT_CS(0x00F02203);
+        OUT_CS(0x00D10021);
+        OUT_CS(0x01248021);
+        OUT_CS(0x00000000);
+    } else {
+        OUT_CS_REG(R300_VAP_CNTL, 0xA |
+            (0x5 << R300_PVS_NUM_CNTLRS_SHIFT) |
+            (0x5 << R300_VF_MAX_VTX_NUM_SHIFT) |
+            (caps->num_vert_fpus << R300_PVS_NUM_FPUS_SHIFT));
+    }
+    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 00000000000..8204bf9588b
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state_invariant.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2008 Corbin Simpson <[email protected]>
+ *
+ * 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_state_shader.c b/src/gallium/drivers/r300/r300_state_shader.c
index e87172128fa..20b83bd15b1 100644
--- a/src/gallium/drivers/r300/r300_state_shader.c
+++ b/src/gallium/drivers/r300/r300_state_shader.c
@@ -22,12 +22,557 @@
 
 #include "r300_state_shader.h"
 
-void r300_translate_shader(struct r300_context* r300,
-                           struct r300_fragment_shader* fs)
+static void r300_copy_passthrough_shader(struct r300_fragment_shader* fs)
 {
+    struct r300_fragment_shader* pt = &r300_passthrough_fragment_shader;
+    fs->shader.stack_size = pt->shader.stack_size;
+    fs->alu_instruction_count = pt->alu_instruction_count;
+    fs->tex_instruction_count = pt->tex_instruction_count;
+    fs->indirections = pt->indirections;
+    fs->instructions[0] = pt->instructions[0];
 }
 
-void r500_translate_shader(struct r300_context* r300,
-                           struct r500_fragment_shader* fs)
+static void r500_copy_passthrough_shader(struct r500_fragment_shader* fs)
 {
+    struct r500_fragment_shader* pt = &r500_passthrough_fragment_shader;
+    fs->shader.stack_size = pt->shader.stack_size;
+    fs->instruction_count = pt->instruction_count;
+    fs->instructions[0] = pt->instructions[0];
+}
+
+static void r300_fs_declare(struct r300_fs_asm* assembler,
+                            struct tgsi_full_declaration* decl)
+{
+    switch (decl->Declaration.File) {
+        case TGSI_FILE_INPUT:
+            switch (decl->Semantic.SemanticName) {
+                case TGSI_SEMANTIC_COLOR:
+                    assembler->color_count++;
+                    break;
+                case TGSI_SEMANTIC_GENERIC:
+                    assembler->tex_count++;
+                    break;
+                default:
+                    debug_printf("r300: fs: Bad semantic declaration %d\n",
+                        decl->Semantic.SemanticName);
+                    break;
+            }
+            break;
+        case TGSI_FILE_OUTPUT:
+        case TGSI_FILE_CONSTANT:
+            break;
+        case TGSI_FILE_TEMPORARY:
+            assembler->temp_count++;
+            break;
+        default:
+            debug_printf("r300: fs: Bad file %d\n", decl->Declaration.File);
+            break;
+    }
+
+    assembler->temp_offset = assembler->color_count + assembler->tex_count;
+}
+
+static INLINE unsigned r300_fs_src(struct r300_fs_asm* assembler,
+                                   struct tgsi_src_register* src)
+{
+    switch (src->File) {
+        case TGSI_FILE_NULL:
+            return 0;
+        case TGSI_FILE_INPUT:
+            /* XXX may be wrong */
+            return src->Index;
+            break;
+        case TGSI_FILE_TEMPORARY:
+            return src->Index + assembler->temp_offset;
+            break;
+        case TGSI_FILE_IMMEDIATE:
+            return (src->Index + assembler->imm_offset) | (1 << 8);
+            break;
+        case TGSI_FILE_CONSTANT:
+            /* XXX magic */
+            return src->Index | (1 << 8);
+            break;
+        default:
+            debug_printf("r300: fs: Unimplemented src %d\n", src->File);
+            break;
+    }
+    return 0;
+}
+
+static INLINE unsigned r300_fs_dst(struct r300_fs_asm* assembler,
+                                   struct tgsi_dst_register* dst)
+{
+    switch (dst->File) {
+        case TGSI_FILE_NULL:
+            /* This happens during KIL instructions. */
+            return 0;
+            break;
+        case TGSI_FILE_OUTPUT:
+            return 0;
+            break;
+        case TGSI_FILE_TEMPORARY:
+            return dst->Index + assembler->temp_offset;
+            break;
+        default:
+            debug_printf("r300: fs: Unimplemented dst %d\n", dst->File);
+            break;
+    }
+    return 0;
+}
+
+static INLINE unsigned r500_fix_swiz(unsigned s)
+{
+    /* For historical reasons, the swizzle values x, y, z, w, and 0 are
+     * equivalent to the actual machine code, but 1 is not. Thus, we just
+     * adjust it a bit... */
+    if (s == TGSI_EXTSWIZZLE_ONE) {
+        return R500_SWIZZLE_ONE;
+    } else {
+        return s;
+    }
+}
+
+static uint32_t r500_rgba_swiz(struct tgsi_full_src_register* reg)
+{
+    if (reg->SrcRegister.Extended) {
+        return r500_fix_swiz(reg->SrcRegisterExtSwz.ExtSwizzleX) |
+            (r500_fix_swiz(reg->SrcRegisterExtSwz.ExtSwizzleY) << 3) |
+            (r500_fix_swiz(reg->SrcRegisterExtSwz.ExtSwizzleZ) << 6) |
+            (r500_fix_swiz(reg->SrcRegisterExtSwz.ExtSwizzleW) << 9);
+    } else {
+        return reg->SrcRegister.SwizzleX |
+            (reg->SrcRegister.SwizzleY << 3) |
+            (reg->SrcRegister.SwizzleZ << 6) |
+            (reg->SrcRegister.SwizzleW << 9);
+    }
+}
+
+static uint32_t r500_strq_swiz(struct tgsi_full_src_register* reg)
+{
+    return reg->SrcRegister.SwizzleX |
+        (reg->SrcRegister.SwizzleY << 2) |
+        (reg->SrcRegister.SwizzleZ << 4) |
+        (reg->SrcRegister.SwizzleW << 6);
+}
+
+static INLINE uint32_t r500_rgb_swiz(struct tgsi_full_src_register* reg)
+{
+    /* Only the first 9 bits... */
+    return (r500_rgba_swiz(reg) & 0x1ff) |
+        (reg->SrcRegister.Negate ? (1 << 9) : 0) |
+        (reg->SrcRegisterExtMod.Absolute ? (1 << 10) : 0);
+}
+
+static INLINE uint32_t r500_alpha_swiz(struct tgsi_full_src_register* reg)
+{
+    /* Only the last 3 bits... */
+    return (r500_rgba_swiz(reg) >> 9) |
+        (reg->SrcRegister.Negate ? (1 << 9) : 0) |
+        (reg->SrcRegisterExtMod.Absolute ? (1 << 10) : 0);
+}
+
+static INLINE uint32_t r500_rgba_op(unsigned op)
+{
+    switch (op) {
+        case TGSI_OPCODE_EX2:
+        case TGSI_OPCODE_LG2:
+        case TGSI_OPCODE_RCP:
+        case TGSI_OPCODE_RSQ:
+            return R500_ALU_RGBA_OP_SOP;
+        case TGSI_OPCODE_FRC:
+            return R500_ALU_RGBA_OP_FRC;
+        case TGSI_OPCODE_DP3:
+            return R500_ALU_RGBA_OP_DP3;
+        case TGSI_OPCODE_DP4:
+        case TGSI_OPCODE_DPH:
+            return R500_ALU_RGBA_OP_DP4;
+        case TGSI_OPCODE_ABS:
+        case TGSI_OPCODE_CMP:
+        case TGSI_OPCODE_MOV:
+        case TGSI_OPCODE_SWZ:
+            return R500_ALU_RGBA_OP_CMP;
+        case TGSI_OPCODE_ADD:
+        case TGSI_OPCODE_MAD:
+        case TGSI_OPCODE_MUL:
+        case TGSI_OPCODE_SUB:
+            return R500_ALU_RGBA_OP_MAD;
+        default:
+            return 0;
+    }
+}
+
+static INLINE uint32_t r500_alpha_op(unsigned op)
+{
+    switch (op) {
+        case TGSI_OPCODE_EX2:
+            return R500_ALPHA_OP_EX2;
+        case TGSI_OPCODE_LG2:
+            return R500_ALPHA_OP_LN2;
+        case TGSI_OPCODE_RCP:
+            return R500_ALPHA_OP_RCP;
+        case TGSI_OPCODE_RSQ:
+            return R500_ALPHA_OP_RSQ;
+        case TGSI_OPCODE_FRC:
+            return R500_ALPHA_OP_FRC;
+        case TGSI_OPCODE_DP3:
+        case TGSI_OPCODE_DP4:
+        case TGSI_OPCODE_DPH:
+            return R500_ALPHA_OP_DP;
+        case TGSI_OPCODE_ABS:
+        case TGSI_OPCODE_CMP:
+        case TGSI_OPCODE_MOV:
+        case TGSI_OPCODE_SWZ:
+            return R500_ALPHA_OP_CMP;
+        case TGSI_OPCODE_ADD:
+        case TGSI_OPCODE_MAD:
+        case TGSI_OPCODE_MUL:
+        case TGSI_OPCODE_SUB:
+            return R500_ALPHA_OP_MAD;
+        default:
+            return 0;
+    }
+}
+
+static INLINE uint32_t r500_tex_op(unsigned op)
+{
+    switch (op) {
+        case TGSI_OPCODE_KIL:
+            return R500_TEX_INST_TEXKILL;
+        case TGSI_OPCODE_TEX:
+            return R500_TEX_INST_LD;
+        case TGSI_OPCODE_TXB:
+            return R500_TEX_INST_LODBIAS;
+        case TGSI_OPCODE_TXP:
+            return R500_TEX_INST_PROJ;
+        default:
+            return 0;
+    }
+}
+
+/* Setup an ALU operation. */
+static INLINE void r500_emit_alu(struct r500_fragment_shader* fs,
+                                 struct r300_fs_asm* assembler,
+                                 struct tgsi_full_dst_register* dst)
+{
+    int i = fs->instruction_count;
+
+    if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
+        fs->instructions[i].inst0 = R500_INST_TYPE_OUT |
+        R500_ALU_OMASK(dst->DstRegister.WriteMask);
+    } else {
+        fs->instructions[i].inst0 = R500_INST_TYPE_ALU |
+        R500_ALU_WMASK(dst->DstRegister.WriteMask);
+    }
+
+    fs->instructions[i].inst0 |= R500_INST_TEX_SEM_WAIT;
+
+    fs->instructions[i].inst4 =
+        R500_ALPHA_ADDRD(r300_fs_dst(assembler, &dst->DstRegister));
+    fs->instructions[i].inst5 =
+        R500_ALU_RGBA_ADDRD(r300_fs_dst(assembler, &dst->DstRegister));
+}
+
+static INLINE void r500_emit_maths(struct r500_fragment_shader* fs,
+                                   struct r300_fs_asm* assembler,
+                                   struct tgsi_full_src_register* src,
+                                   struct tgsi_full_dst_register* dst,
+                                   unsigned op,
+                                   unsigned count)
+{
+    int i = fs->instruction_count;
+
+    r500_emit_alu(fs, assembler, dst);
+
+    switch (count) {
+        case 3:
+            fs->instructions[i].inst1 =
+                R500_RGB_ADDR2(r300_fs_src(assembler, &src[2].SrcRegister));
+            fs->instructions[i].inst2 =
+                R500_ALPHA_ADDR2(r300_fs_src(assembler, &src[2].SrcRegister));
+            fs->instructions[i].inst5 |=
+                R500_ALU_RGBA_SEL_C_SRC2 |
+                R500_SWIZ_RGBA_C(r500_rgb_swiz(&src[2])) |
+                R500_ALU_RGBA_ALPHA_SEL_C_SRC2 |
+                R500_SWIZ_ALPHA_C(r500_alpha_swiz(&src[2]));
+        case 2:
+            fs->instructions[i].inst1 |=
+                R500_RGB_ADDR1(r300_fs_src(assembler, &src[1].SrcRegister));
+            fs->instructions[i].inst2 |=
+                R500_ALPHA_ADDR1(r300_fs_src(assembler, &src[1].SrcRegister));
+            fs->instructions[i].inst3 =
+                R500_ALU_RGB_SEL_B_SRC1 |
+                R500_SWIZ_RGB_B(r500_rgb_swiz(&src[1]));
+            fs->instructions[i].inst4 |=
+                R500_SWIZ_ALPHA_B(r500_alpha_swiz(&src[1])) |
+                R500_ALPHA_SEL_B_SRC1;
+        case 1:
+        case 0:
+        default:
+            fs->instructions[i].inst1 |=
+                R500_RGB_ADDR0(r300_fs_src(assembler, &src[0].SrcRegister));
+            fs->instructions[i].inst2 |=
+                R500_ALPHA_ADDR0(r300_fs_src(assembler, &src[0].SrcRegister));
+            fs->instructions[i].inst3 |=
+                R500_ALU_RGB_SEL_A_SRC0 |
+                R500_SWIZ_RGB_A(r500_rgb_swiz(&src[0]));
+            fs->instructions[i].inst4 |=
+                R500_SWIZ_ALPHA_A(r500_alpha_swiz(&src[0])) |
+                R500_ALPHA_SEL_A_SRC0;
+            break;
+    }
+
+    fs->instructions[i].inst4 |= r500_alpha_op(op);
+    fs->instructions[i].inst5 |= r500_rgba_op(op);
+
+    fs->instruction_count++;
+}
+
+static INLINE void r500_emit_tex(struct r500_fragment_shader* fs,
+                                 struct r300_fs_asm* assembler,
+                                 struct tgsi_full_src_register* src,
+                                 struct tgsi_full_dst_register* dst,
+                                 uint32_t op)
+{
+    int i = fs->instruction_count;
+
+    fs->instructions[i].inst0 = R500_INST_TYPE_TEX |
+        R500_TEX_WMASK(dst->DstRegister.WriteMask) |
+        R500_INST_TEX_SEM_WAIT;
+    fs->instructions[i].inst1 = R500_TEX_ID(0) |
+        R500_TEX_SEM_ACQUIRE | //R500_TEX_IGNORE_UNCOVERED |
+        r500_tex_op(op);
+    fs->instructions[i].inst2 =
+        R500_TEX_SRC_ADDR(r300_fs_src(assembler, &src->SrcRegister)) |
+        R500_SWIZ_TEX_STRQ(r500_strq_swiz(src)) |
+        R500_TEX_DST_ADDR(r300_fs_dst(assembler, &dst->DstRegister)) |
+        R500_TEX_DST_R_SWIZ_R | R500_TEX_DST_G_SWIZ_G |
+        R500_TEX_DST_B_SWIZ_B | R500_TEX_DST_A_SWIZ_A;
+
+    if (dst->DstRegister.File == TGSI_FILE_OUTPUT) {
+        fs->instructions[i].inst2 |=
+            R500_TEX_DST_ADDR(assembler->temp_count +
+                    assembler->temp_offset);
+
+        fs->instruction_count++;
+
+        /* Setup and emit a MOV. */
+        src[0].SrcRegister.Index = assembler->temp_count;
+        src[0].SrcRegister.File = TGSI_FILE_TEMPORARY;
+
+        src[1] = src[0];
+        src[2] = r500_constant_zero;
+        r500_emit_maths(fs, assembler, src, dst, TGSI_OPCODE_MOV, 3);
+    } else {
+        fs->instruction_count++;
+    }
+}
+
+static void r500_fs_instruction(struct r500_fragment_shader* fs,
+                                struct r300_fs_asm* assembler,
+                                struct tgsi_full_instruction* inst)
+{
+    int i;
+    /* Switch between opcodes. When possible, prefer using the official
+     * AMD/ATI names for opcodes, please, as it facilitates using the
+     * documentation. */
+    switch (inst->Instruction.Opcode) {
+        /* The simple scalar ops. */
+        case TGSI_OPCODE_EX2:
+        case TGSI_OPCODE_LG2:
+        case TGSI_OPCODE_RCP:
+        case TGSI_OPCODE_RSQ:
+            /* Copy red swizzle to alpha for src0 */
+            inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleW =
+                inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleX;
+            inst->FullSrcRegisters[0].SrcRegister.SwizzleW =
+                inst->FullSrcRegisters[0].SrcRegister.SwizzleX;
+            /* Fall through */
+        case TGSI_OPCODE_FRC:
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 1);
+            break;
+
+        /* The dot products. */
+        case TGSI_OPCODE_DPH:
+            /* Set alpha swizzle to one for src0 */
+            if (!inst->FullSrcRegisters[0].SrcRegister.Extended) {
+                inst->FullSrcRegisters[0].SrcRegister.Extended = TRUE;
+                inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleX =
+                    inst->FullSrcRegisters[0].SrcRegister.SwizzleX;
+                inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleY =
+                    inst->FullSrcRegisters[0].SrcRegister.SwizzleY;
+                inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleZ =
+                    inst->FullSrcRegisters[0].SrcRegister.SwizzleZ;
+            }
+            inst->FullSrcRegisters[0].SrcRegisterExtSwz.ExtSwizzleW =
+                TGSI_EXTSWIZZLE_ONE;
+            /* Fall through */
+        case TGSI_OPCODE_DP3:
+        case TGSI_OPCODE_DP4:
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 2);
+            break;
+
+        /* Simple three-source operations. */
+        case TGSI_OPCODE_CMP:
+            /* Swap src0 and src2 */
+            inst->FullSrcRegisters[3] = inst->FullSrcRegisters[2];
+            inst->FullSrcRegisters[2] = inst->FullSrcRegisters[0];
+            inst->FullSrcRegisters[0] = inst->FullSrcRegisters[3];
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 3);
+            break;
+
+        /* The MAD variants. */
+        case TGSI_OPCODE_SUB:
+            /* Just like ADD, but flip the negation on src1 first */
+            inst->FullSrcRegisters[1].SrcRegister.Negate =
+                !inst->FullSrcRegisters[1].SrcRegister.Negate;
+            /* Fall through */
+        case TGSI_OPCODE_ADD:
+            /* Force src0 to one, move all registers over */
+            inst->FullSrcRegisters[2] = inst->FullSrcRegisters[1];
+            inst->FullSrcRegisters[1] = inst->FullSrcRegisters[0];
+            inst->FullSrcRegisters[0] = r500_constant_one;
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 3);
+            break;
+        case TGSI_OPCODE_MUL:
+            /* Force our src2 to zero */
+            inst->FullSrcRegisters[2] = r500_constant_zero;
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 3);
+            break;
+        case TGSI_OPCODE_MAD:
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 3);
+            break;
+
+        /* The MOV variants. */
+        case TGSI_OPCODE_ABS:
+            /* Set absolute value modifiers. */
+            inst->FullSrcRegisters[0].SrcRegisterExtMod.Absolute = TRUE;
+            /* Fall through */
+        case TGSI_OPCODE_MOV:
+        case TGSI_OPCODE_SWZ:
+            /* src0 -> src1 and src2 forced to zero */
+            inst->FullSrcRegisters[1] = inst->FullSrcRegisters[0];
+            inst->FullSrcRegisters[2] = r500_constant_zero;
+            r500_emit_maths(fs, assembler, inst->FullSrcRegisters,
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode, 3);
+            break;
+
+        /* The texture instruction set. */
+        case TGSI_OPCODE_KIL:
+        case TGSI_OPCODE_TEX:
+        case TGSI_OPCODE_TXB:
+        case TGSI_OPCODE_TXP:
+            r500_emit_tex(fs, assembler, &inst->FullSrcRegisters[0],
+                    &inst->FullDstRegisters[0], inst->Instruction.Opcode);
+            break;
+
+        /* This is the end. My only friend, the end. */
+        case TGSI_OPCODE_END:
+            break;
+        default:
+            debug_printf("r300: fs: Bad opcode %d\n",
+                    inst->Instruction.Opcode);
+            break;
+    }
+
+    /* Clamp, if saturation flags are set. */
+    if (inst->Instruction.Saturate == TGSI_SAT_ZERO_ONE) {
+        fs->instructions[fs->instruction_count - 1].inst0 |=
+            R500_INST_RGB_CLAMP | R500_INST_ALPHA_CLAMP;
+    }
+}
+
+static void r500_fs_finalize(struct r500_fragment_shader* fs,
+                             struct r300_fs_asm* assembler)
+{
+    fs->shader.stack_size = assembler->temp_count + assembler->temp_offset;
+
+    /* XXX should this just go with OPCODE_END? */
+    fs->instructions[fs->instruction_count - 1].inst0 |=
+        R500_INST_LAST;
+}
+
+void r300_translate_fragment_shader(struct r300_context* r300,
+                                    struct r300_fragment_shader* fs)
+{
+    struct tgsi_parse_context parser;
+
+    tgsi_parse_init(&parser, fs->shader.state.tokens);
+
+    while (!tgsi_parse_end_of_tokens(&parser)) {
+        tgsi_parse_token(&parser);
+    }
+
+    r300_copy_passthrough_shader(fs);
+}
+
+void r500_translate_fragment_shader(struct r300_context* r300,
+                                    struct r500_fragment_shader* fs)
+{
+    struct tgsi_parse_context parser;
+    int i;
+    struct r300_constant_buffer* consts =
+        &r300->shader_constants[PIPE_SHADER_FRAGMENT];
+
+    struct r300_fs_asm* assembler = CALLOC_STRUCT(r300_fs_asm);
+    if (assembler == NULL) {
+        return;
+    }
+    /* Setup starting offset for immediates. */
+    assembler->imm_offset = consts->user_count;
+
+    tgsi_parse_init(&parser, fs->shader.state.tokens);
+
+    while (!tgsi_parse_end_of_tokens(&parser)) {
+        tgsi_parse_token(&parser);
+
+        /* This is seriously the lamest way to create fragment programs ever.
+         * I blame TGSI. */
+        switch (parser.FullToken.Token.Type) {
+            case TGSI_TOKEN_TYPE_DECLARATION:
+                /* Allocated registers sitting at the beginning
+                 * of the program. */
+                r300_fs_declare(assembler, &parser.FullToken.FullDeclaration);
+                break;
+            case TGSI_TOKEN_TYPE_IMMEDIATE:
+                debug_printf("r300: Emitting immediate to constant buffer, "
+                        "position %d\n",
+                        assembler->imm_offset + assembler->imm_count);
+                /* I am not amused by the length of these. */
+                for (i = 0; i < 4; i++) {
+                    consts->constants[assembler->imm_offset +
+                        assembler->imm_count][i] =
+                        parser.FullToken.FullImmediate.u.ImmediateFloat32[i]
+                        .Float;
+                }
+                assembler->imm_count++;
+                break;
+            case TGSI_TOKEN_TYPE_INSTRUCTION:
+                r500_fs_instruction(fs, assembler,
+                        &parser.FullToken.FullInstruction);
+                break;
+        }
+
+    }
+
+    debug_printf("r300: %d texs and %d colors, first free reg is %d\n",
+            assembler->tex_count, assembler->color_count,
+            assembler->tex_count + assembler->color_count);
+
+    consts->count = consts->user_count + assembler->imm_count;
+    debug_printf("r300: %d total constants, "
+            "%d from user and %d from immediates\n", consts->count,
+            consts->user_count, assembler->imm_count);
+    r500_fs_finalize(fs, assembler);
+
+    tgsi_dump(fs->shader.state.tokens);
+    r500_fs_dump(fs);
+
+    tgsi_parse_free(&parser);
+    FREE(assembler);
 }
diff --git a/src/gallium/drivers/r300/r300_state_shader.h b/src/gallium/drivers/r300/r300_state_shader.h
index a20bd4276c6..06c0bb73789 100644
--- a/src/gallium/drivers/r300/r300_state_shader.h
+++ b/src/gallium/drivers/r300/r300_state_shader.h
@@ -23,13 +23,142 @@
 #ifndef R300_STATE_SHADER_H
 #define R300_STATE_SHADER_H
 
+#include "tgsi/tgsi_parse.h"
+
 #include "r300_context.h"
+#include "r300_debug.h"
+#include "r300_reg.h"
 #include "r300_screen.h"
 
-void r300_translate_shader(struct r300_context* r300,
+/* XXX this all should find its way back to r300_reg */
+/* Swizzle tools */
+#define R500_SWIZZLE_ZERO 4
+#define R500_SWIZZLE_HALF 5
+#define R500_SWIZZLE_ONE 6
+#define R500_SWIZ_RGB_ZERO ((4 << 0) | (4 << 3) | (4 << 6))
+#define R500_SWIZ_RGB_ONE ((6 << 0) | (6 << 3) | (6 << 6))
+#define R500_SWIZ_RGB_RGB ((0 << 0) | (1 << 3) | (2 << 6))
+#define R500_SWIZ_MOD_NEG 1
+#define R500_SWIZ_MOD_ABS 2
+#define R500_SWIZ_MOD_NEG_ABS 3
+/* Swizzles for inst2 */
+#define R500_SWIZ_TEX_STRQ(x) ((x) << 8)
+#define R500_SWIZ_TEX_RGBA(x) ((x) << 24)
+/* Swizzles for inst3 */
+#define R500_SWIZ_RGB_A(x) ((x) << 2)
+#define R500_SWIZ_RGB_B(x) ((x) << 15)
+/* Swizzles for inst4 */
+#define R500_SWIZ_ALPHA_A(x) ((x) << 14)
+#define R500_SWIZ_ALPHA_B(x) ((x) << 21)
+/* Swizzle for inst5 */
+#define R500_SWIZ_RGBA_C(x) ((x) << 14)
+#define R500_SWIZ_ALPHA_C(x) ((x) << 27)
+/* Writemasks */
+#define R500_TEX_WMASK(x) ((x) << 11)
+#define R500_ALU_WMASK(x) ((x) << 11)
+#define R500_ALU_OMASK(x) ((x) << 15)
+
+/* TGSI constants. TGSI is like XML: If it can't solve your problems, you're
+ * not using enough of it. */
+static const struct tgsi_full_src_register r500_constant_zero = {
+    .SrcRegister.Extended = TRUE,
+    .SrcRegister.File = TGSI_FILE_NULL,
+    .SrcRegisterExtSwz.ExtSwizzleX = TGSI_EXTSWIZZLE_ZERO,
+    .SrcRegisterExtSwz.ExtSwizzleY = TGSI_EXTSWIZZLE_ZERO,
+    .SrcRegisterExtSwz.ExtSwizzleZ = TGSI_EXTSWIZZLE_ZERO,
+    .SrcRegisterExtSwz.ExtSwizzleW = TGSI_EXTSWIZZLE_ZERO,
+};
+
+static const struct tgsi_full_src_register r500_constant_one = {
+    .SrcRegister.Extended = TRUE,
+    .SrcRegister.File = TGSI_FILE_NULL,
+    .SrcRegisterExtSwz.ExtSwizzleX = TGSI_EXTSWIZZLE_ONE,
+    .SrcRegisterExtSwz.ExtSwizzleY = TGSI_EXTSWIZZLE_ONE,
+    .SrcRegisterExtSwz.ExtSwizzleZ = TGSI_EXTSWIZZLE_ONE,
+    .SrcRegisterExtSwz.ExtSwizzleW = TGSI_EXTSWIZZLE_ONE,
+};
+
+/* Temporary struct used to hold assembly state while putting together
+ * fragment programs. */
+struct r300_fs_asm {
+    /* Pipe context. */
+    struct r300_context* r300;
+    /* Number of colors. */
+    unsigned color_count;
+    /* Number of texcoords. */
+    unsigned tex_count;
+    /* Offset for temporary registers. Inputs and temporaries have no
+     * distinguishing markings, so inputs start at 0 and the first usable
+     * temporary register is after all inputs. */
+    unsigned temp_offset;
+    /* Number of requested temporary registers. */
+    unsigned temp_count;
+    /* Offset for immediate constants. Neither R300 nor R500 can do four
+     * inline constants per source, so instead we copy immediates into the
+     * constant buffer. */
+    unsigned imm_offset;
+    /* Number of immediate constants. */
+    unsigned imm_count;
+};
+
+void r300_translate_fragment_shader(struct r300_context* r300,
                            struct r300_fragment_shader* fs);
 
-void r500_translate_shader(struct r300_context* r300,
+void r500_translate_fragment_shader(struct r300_context* r300,
                            struct r500_fragment_shader* fs);
 
+static const struct r300_fragment_shader r300_passthrough_fragment_shader = {
+    /* XXX This is the emission code. TODO: decode
+    OUT_CS_REG(R300_US_CONFIG, 0);
+    OUT_CS_REG(R300_US_CODE_OFFSET, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_0, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_1, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_2, 0x0);
+    OUT_CS_REG(R300_US_CODE_ADDR_3, 0x400000);
+*/
+    .alu_instruction_count = 1,
+    .tex_instruction_count = 0,
+    .indirections = 1,
+    .shader.stack_size = 2,
+
+    .instructions[0].alu_rgb_inst = R300_RGB_SWIZA(R300_ALU_ARGC_SRC0C_XYZ) |
+        R300_RGB_SWIZB(R300_ALU_ARGC_ONE) |
+        R300_RGB_SWIZC(R300_ALU_ARGC_ZERO) |
+        R300_ALU_OUTC_MAD,
+    .instructions[0].alu_rgb_addr = R300_RGB_ADDR0(0) | R300_RGB_ADDR1(0) |
+        R300_RGB_ADDR2(0) | R300_ALU_DSTC_OUTPUT_XYZ,
+    .instructions[0].alu_alpha_inst = R300_ALPHA_SWIZA(R300_ALU_ARGA_SRC0A) |
+        R300_ALPHA_SWIZB(R300_ALU_ARGA_ONE) |
+        R300_ALPHA_SWIZC(R300_ALU_ARGA_ZERO) |
+        R300_ALU_OUTA_MAD,
+    .instructions[0].alu_alpha_addr = R300_ALPHA_ADDR0(0) |
+        R300_ALPHA_ADDR1(0) | R300_ALPHA_ADDR2(0) | R300_ALU_DSTA_OUTPUT,
+};
+
+static const struct r500_fragment_shader r500_passthrough_fragment_shader = {
+    .shader.stack_size = 0,
+    .instruction_count = 1,
+    .instructions[0].inst0 = R500_INST_TYPE_OUT |
+        R500_INST_TEX_SEM_WAIT | R500_INST_LAST |
+        R500_INST_RGB_OMASK_RGB | R500_INST_ALPHA_OMASK |
+        R500_INST_RGB_CLAMP | R500_INST_ALPHA_CLAMP,
+    .instructions[0].inst1 =
+        R500_RGB_ADDR0(0) | R500_RGB_ADDR1(0) | R500_RGB_ADDR1_CONST |
+        R500_RGB_ADDR2(0) | R500_RGB_ADDR2_CONST,
+    .instructions[0].inst2 =
+        R500_ALPHA_ADDR0(0) | R500_ALPHA_ADDR1(0) | R500_ALPHA_ADDR1_CONST |
+        R500_ALPHA_ADDR2(0) | R500_ALPHA_ADDR2_CONST,
+    .instructions[0].inst3 =
+        R500_ALU_RGB_SEL_A_SRC0 | R500_ALU_RGB_R_SWIZ_A_R |
+        R500_ALU_RGB_G_SWIZ_A_G | R500_ALU_RGB_B_SWIZ_A_B |
+        R500_ALU_RGB_SEL_B_SRC0 | R500_ALU_RGB_R_SWIZ_B_R |
+        R500_ALU_RGB_B_SWIZ_B_G | R500_ALU_RGB_G_SWIZ_B_B,
+    .instructions[0].inst4 =
+        R500_ALPHA_OP_CMP | R500_ALPHA_SWIZ_A_A | R500_ALPHA_SWIZ_B_A,
+    .instructions[0].inst5 =
+        R500_ALU_RGBA_OP_CMP | R500_ALU_RGBA_R_SWIZ_0 |
+        R500_ALU_RGBA_G_SWIZ_0 | R500_ALU_RGBA_B_SWIZ_0 |
+        R500_ALU_RGBA_A_SWIZ_0,
+};
+
 #endif /* R300_STATE_SHADER_H */
diff --git a/src/gallium/drivers/r300/r300_surface.c b/src/gallium/drivers/r300/r300_surface.c
index 1e1f96a7f96..2cc0677e52c 100644
--- a/src/gallium/drivers/r300/r300_surface.c
+++ b/src/gallium/drivers/r300/r300_surface.c
@@ -1,5 +1,6 @@
 /*
  * Copyright 2008 Corbin Simpson <[email protected]>
+ *                Joakim Sindholt <[email protected]>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -32,321 +33,161 @@ 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;
+    float r, g, b, a, depth;
+    unsigned pixpitch = tex->stride / tex->tex.block.size;
+
     r = (float)((color >> 16) & 0xff) / 255.0f;
     g = (float)((color >>  8) & 0xff) / 255.0f;
     b = (float)((color >>  0) & 0xff) / 255.0f;
     debug_printf("r300: Filling surface %p at (%d,%d),"
-        " dimensions %dx%d (stride %d), color 0x%x\n",
-        dest, x, y, w, h, dest->stride, color);
+        " dimensions %dx%d (pixel pitch %d), color 0x%x\n",
+        dest, x, y, w, h, pixpitch, color);
 
     /* Fallback? */
-    if (0) {
+    if (tex->tex.format != PIPE_FORMAT_A8R8G8B8_UNORM) {
         debug_printf("r300: Falling back on surface clear...");
-        void* map = pipe->screen->surface_map(pipe->screen, dest,
-            PIPE_BUFFER_USAGE_CPU_WRITE);
-        pipe_fill_rect(map, &dest->block, &dest->stride, x, y, w, h, color);
-        pipe->screen->surface_unmap(pipe->screen, dest);
+        util_surface_fill(pipe, dest, x, y, w, h, color);
         return;
     }
 
-BEGIN_CS((caps->is_r500) ? 309 : 280);
-R300_PACIFY;
-OUT_CS_REG(R300_TX_INVALTAGS, 0x0);
-R300_PACIFY;
-/* Flush PVS. */
-OUT_CS_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0x0);
-
-OUT_CS_REG(R300_SE_VTE_CNTL, R300_VPORT_X_SCALE_ENA |
-    R300_VPORT_X_OFFSET_ENA | R300_VPORT_Y_SCALE_ENA |
-    R300_VPORT_Y_OFFSET_ENA | R300_VPORT_Z_SCALE_ENA |
-    R300_VPORT_Z_OFFSET_ENA | R300_VTX_W0_FMT);
-/* Vertex size. */
-OUT_CS_REG(R300_VAP_VTX_SIZE, 0x8);
-/* Max and min vertex index clamp. */
-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);
-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);
-OUT_CS_REG(R300_VAP_CLIP_CNTL, 0x0);
-OUT_CS_REG_SEQ(R300_VAP_GB_VERT_CLIP_ADJ, 4);
-OUT_CS_32F(1.0);
-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);
-OUT_CS_REG_SEQ(R300_GA_POINT_S1, 1);
-OUT_CS_32F(1.0);
-OUT_CS_REG(R300_GA_TRIANGLE_STIPPLE, 0x5 |
-    (0x5 << R300_GA_TRIANGLE_STIPPLE_Y_SHIFT_SHIFT));
-/* XXX should this be related to the actual point size? */
-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);
-OUT_CS_REG(R300_GA_COLOR_CONTROL, 0x0003AAAA);
-OUT_CS_REG(R300_GA_SOLID_RG, 0x00000000);
-OUT_CS_REG(R300_GA_SOLID_BA, 0x00000000);
-OUT_CS_REG(R300_GA_POLY_MODE, 0x00000000);
-OUT_CS_REG(R300_GA_ROUND_MODE, 0x00000001);
-OUT_CS_REG(R300_GA_OFFSET, 0x00000000);
-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);
-OUT_CS_REG(R300_SC_EDGERULE, 0x2DA49525);
-OUT_CS_REG(R300_SC_SCREENDOOR, 0x00FFFFFF);
-OUT_CS_REG(R300_FG_FOG_BLEND, 0x00000002);
-OUT_CS_REG(R300_FG_FOG_COLOR_R, 0x00000000);
-OUT_CS_REG(R300_FG_FOG_COLOR_G, 0x00000000);
-OUT_CS_REG(R300_FG_FOG_COLOR_B, 0x00000000);
-OUT_CS_REG(R300_FG_DEPTH_SRC, 0x00000000);
-OUT_CS_REG(R300_FG_DEPTH_SRC, 0x00000000);
-OUT_CS_REG(R300_RB3D_CCTL, 0x00000000);
-OUT_CS_REG(RB3D_COLOR_CHANNEL_MASK, 0x0000000F);
-
-/* XXX: Oh the wonderful unknown */
-OUT_CS_REG_SEQ(0x4E54, 8);
-for (i = 0; i < 8; i++)
-    OUT_CS(0x00000000);
-OUT_CS_REG(R300_RB3D_AARESOLVE_CTL, 0x00000000);
-OUT_CS_REG(R500_RB3D_DISCARD_SRC_PIXEL_LTE_THRESHOLD, 0x00000000);
-OUT_CS_REG(R500_RB3D_DISCARD_SRC_PIXEL_GTE_THRESHOLD, 0xFFFFFFFF);
-OUT_CS_REG(R300_ZB_FORMAT, 0x00000002);
-OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT, 0x00000003);
-OUT_CS_REG(R300_ZB_BW_CNTL, 0x00000000);
-OUT_CS_REG(R300_ZB_DEPTHCLEARVALUE, 0x00000000);
-OUT_CS_REG(0x4F30, 0x00000000);
-OUT_CS_REG(0x4F34, 0x00000000);
-OUT_CS_REG(R300_ZB_HIZ_OFFSET, 0x00000000);
-OUT_CS_REG(R300_ZB_HIZ_PITCH, 0x00000000);
-R300_PACIFY;
-if (caps->has_tcl) {
-    OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_0,
-        (R300_DATA_TYPE_FLOAT_4 << R300_DATA_TYPE_0_SHIFT) |
-        ((R300_LAST_VEC | (1 << R300_DST_VEC_LOC_SHIFT) |
-            R300_DATA_TYPE_FLOAT_4) << R300_DATA_TYPE_1_SHIFT));
-} else {
-    OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_0,
-        (R300_DATA_TYPE_FLOAT_4 << R300_DATA_TYPE_0_SHIFT) |
-        ((R300_LAST_VEC | (2 << R300_DST_VEC_LOC_SHIFT) |
-            R300_DATA_TYPE_FLOAT_4) << R300_DATA_TYPE_1_SHIFT));
-}
-OUT_CS_REG(R300_FG_FOG_BLEND, 0x00000000);
-OUT_CS_REG(R300_VAP_PROG_STREAM_CNTL_EXT_0, 0xF688F688);
-OUT_CS_REG(R300_VAP_VTX_STATE_CNTL, 0x1);
-OUT_CS_REG(R300_VAP_VSM_VTX_ASSM, 0x405);
-OUT_CS_REG(R300_SE_VTE_CNTL, 0x0000043F);
-OUT_CS_REG(R300_VAP_VTX_SIZE, 0x00000008);
-OUT_CS_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0xAAAAAAAA);
-OUT_CS_REG(R300_VAP_OUTPUT_VTX_FMT_0, 0x00000003);
-OUT_CS_REG(R300_VAP_OUTPUT_VTX_FMT_1, 0x00000000);
-OUT_CS_REG(R300_TX_ENABLE, 0x0);
-/* XXX viewport setup */
-OUT_CS_REG_SEQ(R300_SE_VPORT_XSCALE, 6);
-OUT_CS_32F(1.0);
-OUT_CS_32F((float)x);
-OUT_CS_32F(1.0);
-OUT_CS_32F((float)y);
-OUT_CS_32F(1.0);
-OUT_CS_32F(0.0);
-
-if (caps->has_tcl) {
-    OUT_CS_REG(R300_VAP_CLIP_CNTL, R300_CLIP_DISABLE |
-        R300_PS_UCP_MODE_CLIP_AS_TRIFAN);
-}
-
-OUT_CS_REG(R300_GA_POINT_SIZE, ((h * 6) & R300_POINTSIZE_Y_MASK) |
-    ((w * 6) << R300_POINTSIZE_X_SHIFT));
-
-/* XXX RS block and fp setup */
-if (caps->is_r500) {
-    OUT_CS_REG_SEQ(R500_RS_IP_0, 8);
-    for (i = 0; i < 8; i++) {
-        /* I like the operator macros more than the shift macros... */
-        OUT_CS((R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_S_SHIFT) |
-            (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_T_SHIFT) |
-            (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT) |
-            (R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT));
+    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);
+
+    /* Fragment shader setup */
+    if (caps->is_r500) {
+        r500_emit_fragment_shader(r300, &r500_passthrough_fragment_shader);
+        r300_emit_rs_block_state(r300, &r500_rs_block_clear_state);
+    } else {
+        r300_emit_fragment_shader(r300, &r300_passthrough_fragment_shader);
+        r300_emit_rs_block_state(r300, &r300_rs_block_clear_state);
     }
-    /* XXX */
-    OUT_CS_REG_SEQ(R300_RS_COUNT, 2);
-    OUT_CS((1 << R300_IC_COUNT_SHIFT) | R300_HIRES_EN);
-    OUT_CS(0x0);
-    OUT_CS_REG(R500_RS_INST_0, R500_RS_INST_COL_CN_WRITE);
 
-    OUT_CS_REG(R500_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
-    OUT_CS_REG(R500_US_PIXSIZE, 0x00000000);
-    OUT_CS_REG(R500_US_CODE_ADDR, R500_US_CODE_START_ADDR(0) |
-        R500_US_CODE_END_ADDR(1));
-    OUT_CS_REG(R500_US_CODE_RANGE, R500_US_CODE_RANGE_ADDR(0) |
-        R500_US_CODE_RANGE_SIZE(1));
-    OUT_CS_REG(R500_US_CODE_OFFSET, R500_US_CODE_OFFSET_ADDR(0));
-    R300_PACIFY;
-    OUT_CS_REG(R500_GA_US_VECTOR_INDEX,
-        0 | R500_GA_US_VECTOR_INDEX_TYPE_INSTR);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_INST_TYPE_OUT | R500_INST_TEX_SEM_WAIT | R500_INST_LAST |
-        R500_INST_RGB_OMASK_R | R500_INST_RGB_OMASK_G | R500_INST_RGB_OMASK_B |
-        R500_INST_ALPHA_OMASK | R500_INST_RGB_CLAMP | R500_INST_ALPHA_CLAMP);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_RGB_ADDR0(0) | R500_RGB_ADDR1(0) | R500_RGB_ADDR1_CONST |
-        R500_RGB_ADDR2(0) | R500_RGB_ADDR2_CONST);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_ALPHA_ADDR0(0) | R500_ALPHA_ADDR1(0) | R500_ALPHA_ADDR1_CONST |
-        R500_ALPHA_ADDR2(0) | R500_ALPHA_ADDR2_CONST);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_ALU_RGB_SEL_A_SRC0 | R500_ALU_RGB_R_SWIZ_A_R |
-        R500_ALU_RGB_G_SWIZ_A_G | R500_ALU_RGB_B_SWIZ_A_B |
-        R500_ALU_RGB_SEL_B_SRC0 | R500_ALU_RGB_R_SWIZ_B_R |
-        R500_ALU_RGB_B_SWIZ_B_G | R500_ALU_RGB_G_SWIZ_B_B);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_ALPHA_OP_CMP | R500_ALPHA_SWIZ_A_A | R500_ALPHA_SWIZ_B_A);
-    OUT_CS_REG(R500_GA_US_VECTOR_DATA,
-        R500_ALU_RGBA_OP_CMP | R500_ALU_RGBA_R_SWIZ_0 |
-        R500_ALU_RGBA_G_SWIZ_0 | R500_ALU_RGBA_B_SWIZ_0 |
-        R500_ALU_RGBA_A_SWIZ_0);
-} else {
-    OUT_CS_REG_SEQ(R300_RS_IP_0, 8);
-    for (i = 0; i < 8; i++) {
-        OUT_CS(R300_RS_SEL_T(R300_RS_SEL_K0) |
-            R300_RS_SEL_R(R300_RS_SEL_K0) | R300_RS_SEL_Q(R300_RS_SEL_K1));
-    }
-    /* XXX */
-    OUT_CS_REG_SEQ(R300_RS_COUNT, 2);
-    OUT_CS((1 << R300_IC_COUNT_SHIFT) | R300_HIRES_EN);
-    OUT_CS(1);
-    OUT_CS_REG(R300_RS_INST_0, R300_RS_INST_COL_CN_WRITE);
-
-    /* XXX magic numbers */
-    OUT_CS_REG(R300_US_CONFIG, 0);
-    OUT_CS_REG(R300_US_PIXSIZE, 2);
-    OUT_CS_REG(R300_US_CODE_OFFSET, 0x0);
-    OUT_CS_REG(R300_US_CODE_ADDR_0, 0x0);
-    OUT_CS_REG(R300_US_CODE_ADDR_1, 0x0);
-    OUT_CS_REG(R300_US_CODE_ADDR_2, 0x0);
-    OUT_CS_REG(R300_US_CODE_ADDR_3, 0x400000);
-    OUT_CS_REG(R300_US_ALU_RGB_INST_0, 0x50A80);
-    OUT_CS_REG(R300_US_ALU_RGB_ADDR_0, 0x1C000000);
-    OUT_CS_REG(R300_US_ALU_ALPHA_INST_0, 0x40889);
-    OUT_CS_REG(R300_US_ALU_ALPHA_ADDR_0, 0x1000000);
-    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);
-    OUT_CS(R300_US_OUT_FMT_UNUSED);
-    OUT_CS(R300_US_OUT_FMT_UNUSED);
-    OUT_CS_REG(R300_US_W_FMT, R300_W_FMT_W0);
-}
-/* XXX these magic numbers should be explained when
- * this becomes a cached state object */
-if (caps->has_tcl) {
-    OUT_CS_REG(R300_VAP_CNTL, 0xA |
-        (0x5 << R300_PVS_NUM_CNTLRS_SHIFT) |
-        (0xB << R300_VF_MAX_VTX_NUM_SHIFT) |
-        (caps->num_vert_fpus << R300_PVS_NUM_FPUS_SHIFT));
-    OUT_CS_REG(R300_VAP_PVS_CODE_CNTL_0, 0x00100000);
-    OUT_CS_REG(R300_VAP_PVS_CONST_CNTL, 0x00000000);
-    OUT_CS_REG(R300_VAP_PVS_CODE_CNTL_1, 0x00000001);
-    R300_PACIFY;
-    /* XXX translate these back into normal instructions */
-    OUT_CS_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0x1);
-    OUT_CS_REG(R300_VAP_PVS_VECTOR_INDX_REG, 0x0);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0xF00203);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0xD10001);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0x1248001);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0x0);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0xF02203);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0xD10021);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0x1248021);
-    OUT_CS_REG(R300_VAP_PVS_UPLOAD_DATA, 0x0);
-} else {
-    OUT_CS_REG(R300_VAP_CNTL, 0xA |
-        (0x5 << R300_PVS_NUM_CNTLRS_SHIFT) |
-        (0x5 << R300_VF_MAX_VTX_NUM_SHIFT) |
-        (caps->num_vert_fpus << R300_PVS_NUM_FPUS_SHIFT));
+    BEGIN_CS(36);
+
+    /* Viewport setup */
+    OUT_CS_REG_SEQ(R300_SE_VPORT_XSCALE, 6);
+    OUT_CS_32F(1.0);
+    OUT_CS_32F((float)x);
+    OUT_CS_32F(1.0);
+    OUT_CS_32F((float)y);
+    OUT_CS_32F(1.0);
+    OUT_CS_32F(0.0);
+
+    /* Pixel scissors */
+    OUT_CS_REG_SEQ(R300_SC_SCISSORS_TL, 2);
+    OUT_CS((x << R300_SCISSORS_X_SHIFT) | (y << R300_SCISSORS_Y_SHIFT));
+    OUT_CS((w << R300_SCISSORS_X_SHIFT) | (h << R300_SCISSORS_Y_SHIFT));
+
+    /* 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));
+
+    /* Flush colorbuffer and blend caches. */
+    OUT_CS_REG(R300_RB3D_DSTCACHE_CTLSTAT,
+        R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D |
+        R300_RB3D_DSTCACHE_CTLSTAT_DC_FINISH_SIGNAL);
+    OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT,
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE);
+
+    OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0, 1);
+    OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
+    OUT_CS_REG(R300_RB3D_COLORPITCH0, pixpitch |
+        r300_translate_colorformat(tex->tex.format));
+    OUT_CS_REG(RB3D_COLOR_CHANNEL_MASK, 0x0000000F);
+    /* XXX Packet3 */
+    OUT_CS(CP_PACKET3(R200_3D_DRAW_IMMD_2, 8));
+    OUT_CS(R300_PRIM_TYPE_POINT | R300_PRIM_WALK_RING |
+    (1 << R300_PRIM_NUM_VERTICES_SHIFT));
+    OUT_CS_32F(w / 2.0);
+    OUT_CS_32F(h / 2.0);
+    /* XXX this should be the depth value to clear to */
+    OUT_CS_32F(1.0);
+    OUT_CS_32F(1.0);
+    OUT_CS_32F(r);
+    OUT_CS_32F(g);
+    OUT_CS_32F(b);
+    OUT_CS_32F(1.0);
+
+    /* XXX figure out why this is 0xA and not 0x2 */
+    OUT_CS_REG(R300_RB3D_DSTCACHE_CTLSTAT, 0xA);
+    /* XXX OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT,
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
+        R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE); */
+
+    END_CS;
+
+    r300->dirty_hw++;
 }
-R300_PACIFY;
-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);
-
-BEGIN_CS(36);
-R300_PACIFY;
-/* Flush colorbuffer and blend caches. */
-OUT_CS_REG(R300_RB3D_DSTCACHE_CTLSTAT,
-    R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D |
-    R300_RB3D_DSTCACHE_CTLSTAT_DC_FINISH_SIGNAL);
-OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT,
-    R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
-    R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE);
-
-OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0, 1);
-OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
-/* XXX this should not be so rigid and it still doesn't work right */
-OUT_CS_REG(R300_RB3D_COLORPITCH0, (dest->stride >> 2) | R300_COLOR_FORMAT_ARGB8888);
-OUT_CS_REG(RB3D_COLOR_CHANNEL_MASK, 0x0000000F);
-/* XXX Packet3 */
-OUT_CS(CP_PACKET3(R200_3D_DRAW_IMMD_2, 8));
-OUT_CS(R300_PRIM_TYPE_POINT | R300_PRIM_WALK_RING |
-(1 << R300_PRIM_NUM_VERTICES_SHIFT));
-OUT_CS_32F(w / 2.0);
-OUT_CS_32F(h / 2.0);
-/* XXX this should be the depth value to clear to */
-OUT_CS_32F(1.0);
-OUT_CS_32F(1.0);
-OUT_CS_32F(r);
-OUT_CS_32F(g);
-OUT_CS_32F(b);
-OUT_CS_32F(1.0);
-
-/* XXX figure out why this is 0xA and not 0x2 */
-OUT_CS_REG(R300_RB3D_DSTCACHE_CTLSTAT, 0xA);
-/* XXX OUT_CS_REG(R300_ZB_ZCACHE_CTLSTAT,
-    R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE |
-    R300_ZB_ZCACHE_CTLSTAT_ZC_FREE_FREE); */
-R300_PACIFY;
-
-END_CS;
-FLUSH_CS;
-
-    r300->dirty_state = R300_NEW_KITCHEN_SINK;
+static void r300_surface_copy(struct pipe_context* pipe,
+                              struct pipe_surface* dest,
+                              unsigned destx, unsigned desty,
+                              struct pipe_surface* src,
+                              unsigned srcx, unsigned srcy,
+                              unsigned w, unsigned h)
+{
+    struct r300_context* r300 = r300_context(pipe);
+    CS_LOCALS(r300);
+    struct r300_texture* srctex = (struct r300_texture*)src->texture;
+    struct r300_texture* desttex = (struct r300_texture*)dest->texture;
+
+    unsigned pixpitch = srctex->stride / srctex->tex.block.size;
+    debug_printf("r300: Copying surface %p at (%d,%d) to %p at (%d, %d),"
+        " dimensions %dx%d (pixel pitch %d)\n",
+        src, srcx, srcy, dest, destx, desty, w, h, pixpitch);
+
+    if (TRUE) {
+        debug_printf("r300: Falling back on surface_copy\n");
+        return util_surface_copy(pipe, FALSE, dest, destx, desty, src,
+                srcx, srcy, w, h);
+    }
+#if 0
+    BEGIN_CS();
+    OUT_CS_REG(RADEON_DEFAULT_SC_BOTTOM_RIGHT,(RADEON_DEFAULT_SC_RIGHT_MAX |
+                RADEON_DEFAULT_SC_BOTTOM_MAX));
+    OUT_ACCEL_REG(RADEON_DP_GUI_MASTER_CNTL, (RADEON_GMC_DST_PITCH_OFFSET_CNTL |
+					  RADEON_GMC_SRC_PITCH_OFFSET_CNTL |
+					  RADEON_GMC_BRUSH_NONE |
+					  (datatype << 8) |
+					  RADEON_GMC_SRC_DATATYPE_COLOR |
+					  RADEON_ROP[rop].rop |
+					  RADEON_DP_SRC_SOURCE_MEMORY |
+					  RADEON_GMC_CLR_CMP_CNTL_DIS));
+    OUT_CS_REG(RADEON_DP_BRUSH_FRGD_CLR, 0xffffffff);
+    OUT_CS_REG(RADEON_DP_BRUSH_BKGD_CLR, 0x0);
+    OUT_CS_REG(RADEON_DP_SRC_FRGD_CLR, 0xffffffff);
+    OUT_CS_REG(RADEON_DP_SRC_BKGD_CLR, 0x0);
+    OUT_ACCEL_REG(RADEON_DP_WRITE_MASK, planemask);
+    OUT_ACCEL_REG(RADEON_DP_CNTL, ((info->accel_state->xdir >= 0 ? RADEON_DST_X_LEFT_TO_RIGHT : 0) |
+			       (info->accel_state->ydir >= 0 ? RADEON_DST_Y_TOP_TO_BOTTOM : 0));
+);
+
+    OUT_CS_REG_SEQ(RADEON_DST_PITCH_OFFSET, 1);
+    OUT_CS_RELOC(desttex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
+
+    OUT_CS_REG_SEQ(RADEON_SRC_PITCH_OFFSET, 1);
+    OUT_CS_RELOC(srctex->buffer, 0,
+            RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0, 0);
+
+    OUT_CS_REG(RADEON_SRC_Y_X, (srcy << 16) | srcx);
+    OUT_CS_REG(RADEON_DST_Y_X, (desty << 16) | destx);
+    OUT_CS_REG(RADEON_DST_HEIGHT_WIDTH, (h << 16) | w);
+    OUT_CS_REG(RADEON_DSTCACHE_CTLSTAT, RADEON_RB2D_DC_FLUSH_ALL);
+    OUT_CS_REG(RADEON_WAIT_UNTIL,
+                  RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_DMA_GUI_IDLE);
+    END_CS;
+#endif
 }
 
 void r300_init_surface_functions(struct r300_context* r300)
 {
     r300->context.surface_fill = r300_surface_fill;
+    r300->context.surface_copy = r300_surface_copy;
 }
diff --git a/src/gallium/drivers/r300/r300_surface.h b/src/gallium/drivers/r300/r300_surface.h
index e1d53116a1f..b75b3ab84cf 100644
--- a/src/gallium/drivers/r300/r300_surface.h
+++ b/src/gallium/drivers/r300/r300_surface.h
@@ -31,6 +31,8 @@
 #include "r300_context.h"
 #include "r300_cs.h"
 #include "r300_emit.h"
+#include "r300_state_shader.h"
+#include "r300_state_inlines.h"
 
 const struct r300_blend_state blend_clear_state = {
     .blend_control = 0x0,
@@ -55,4 +57,38 @@ const struct r300_dsa_state dsa_clear_state = {
     .stencil_ref_bf = 0x0,
 };
 
+const struct r300_rs_state rs_clear_state = {
+    .point_minmax = 0x36000006,
+    .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,
+    .color_control = R300_SHADE_MODEL_FLAT,
+};
+
+const struct r300_rs_block r300_rs_block_clear_state = {
+    .ip[0] = R500_RS_SEL_S(R300_RS_SEL_K0) |
+        R500_RS_SEL_T(R300_RS_SEL_K0) |
+        R500_RS_SEL_R(R300_RS_SEL_K0) |
+        R500_RS_SEL_Q(R300_RS_SEL_K1),
+    .inst[0] = R300_RS_INST_COL_CN_WRITE,
+    .count = R300_IT_COUNT(0) | R300_IC_COUNT(1) | R300_HIRES_EN,
+    .inst_count = 0,
+};
+
+const struct r300_rs_block r500_rs_block_clear_state = {
+    .ip[0] = R500_RS_SEL_S(R500_RS_IP_PTR_K0) |
+        R500_RS_SEL_T(R500_RS_IP_PTR_K0) |
+        R500_RS_SEL_R(R500_RS_IP_PTR_K0) |
+        R500_RS_SEL_Q(R500_RS_IP_PTR_K1),
+    .inst[0] = R500_RS_INST_COL_CN_WRITE,
+    .count = R300_IT_COUNT(0) | R300_IC_COUNT(1) | R300_HIRES_EN,
+    .inst_count = 0,
+};
+
 #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 f6e98d23e98..3db09514c69 100644
--- a/src/gallium/drivers/r300/r300_swtcl_emit.c
+++ b/src/gallium/drivers/r300/r300_swtcl_emit.c
@@ -21,109 +21,315 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
 #include "draw/draw_pipe.h"
+#include "draw/draw_vbuf.h"
 #include "util/u_memory.h"
 
 #include "r300_cs.h"
 #include "r300_context.h"
 #include "r300_reg.h"
+#include "r300_state_derived.h"
 
-/* r300_swtcl_emit: Primitive vertex emission using an immediate
- * vertex buffer and no HW TCL. */
+/* r300_swtcl_emit: Vertex and index buffer primitive emission. No HW TCL. */
 
-struct swtcl_stage {
+struct r300_swtcl_render {
     /* Parent class */
-    struct draw_stage draw;
-
+    struct vbuf_render base;
+    
+    /* Pipe context */
     struct r300_context* r300;
+
+    /* Vertex information */
+    size_t vertex_size;
+    unsigned prim;
+    unsigned hwprim;
+
+    /* VBO */
+    struct pipe_buffer* vbo;
+    size_t vbo_size;
+    size_t vbo_offset;
+    void* vbo_map;
+    size_t vbo_alloc_size;
+    size_t vbo_max_used;
 };
 
-static INLINE struct swtcl_stage* swtcl_stage(struct draw_stage* draw) {
-    return (struct swtcl_stage*)draw;
+static INLINE struct r300_swtcl_render*
+r300_swtcl_render(struct vbuf_render* render)
+{
+    return (struct r300_swtcl_render*)render;
 }
 
-static void r300_emit_vertex(struct r300_context* r300,
-                             const struct vertex_header* vertex)
+static const struct vertex_info*
+r300_swtcl_render_get_vertex_info(struct vbuf_render* render)
 {
-    /* XXX */
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct r300_context* r300 = r300render->r300;
+
+    r300_update_derived_state(r300);
+
+    return &r300->vertex_info;
 }
 
-static INLINE void r300_emit_prim(struct draw_stage* draw,
-                                  struct prim_header* prim,
-                                  unsigned hwprim,
-                                  unsigned count)
+static boolean r300_swtcl_render_allocate_vertices(struct vbuf_render* render,
+                                                   ushort vertex_size,
+                                                   ushort count)
 {
-    struct r300_context* r300 = swtcl_stage(draw)->r300;
-    CS_LOCALS(r300);
-    int i;
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct r300_context* r300 = r300render->r300;
+    struct pipe_screen* screen = r300->context.screen;
+    size_t size = (size_t)vertex_size * (size_t)count;
 
-    r300_emit_dirty_state(r300);
+    if (r300render->vbo) {
+        pipe_buffer_reference(&r300render->vbo, NULL);
+    }
+
+    r300render->vbo_size = MAX2(size, r300render->vbo_alloc_size);
+    r300render->vbo_offset = 0;
+    r300render->vbo = pipe_buffer_create(screen,
+                                         64,
+                                         PIPE_BUFFER_USAGE_VERTEX,
+                                         r300render->vbo_size);
 
-    /* XXX should be count * vtx size */
-    BEGIN_CS(2 + count + 6);
-    OUT_CS(CP_PACKET3(R200_3D_DRAW_IMMD_2, count));
-    OUT_CS(hwprim | R300_PRIM_WALK_RING |
-        (count << R300_PRIM_NUM_VERTICES_SHIFT));
+    r300render->vertex_size = vertex_size;
 
-    for (i = 0; i < count; i++) {
-        r300_emit_vertex(r300, prim->v[i]);
+    if (r300render->vbo) {
+        return TRUE;
+    } else {
+        return FALSE;
     }
-    R300_PACIFY;
-    END_CS;
 }
 
-/* Just as an aside...
- *
- * Radeons can do many more primitives:
- * - Line strip
- * - Triangle fan
- * - Triangle strip
- * - Line loop
- * - Quads
- * - Quad strip
- * - Polygons
- *
- * The following were just the only ones in Draw. */
+static void* r300_swtcl_render_map_vertices(struct vbuf_render* render)
+{
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct pipe_screen* screen = r300render->r300->context.screen;
 
-static void r300_emit_point(struct draw_stage* draw, struct prim_header* prim)
+    r300render->vbo_map = pipe_buffer_map(screen, r300render->vbo,
+                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+
+    return (unsigned char*)r300render->vbo_map + r300render->vbo_offset;
+}
+
+static void r300_swtcl_render_unmap_vertices(struct vbuf_render* render,
+                                             ushort min,
+                                             ushort max)
 {
-    r300_emit_prim(draw, prim, R300_PRIM_TYPE_POINT, 1);
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct pipe_screen* screen = r300render->r300->context.screen;
+
+    r300render->vbo_max_used = MAX2(r300render->vbo_max_used,
+             r300render->vertex_size * (max + 1));
+
+    pipe_buffer_unmap(screen, r300render->vbo);
 }
 
-static void r300_emit_line(struct draw_stage* draw, struct prim_header* prim)
+static void r300_swtcl_render_release_vertices(struct vbuf_render* render)
 {
-    r300_emit_prim(draw, prim, R300_PRIM_TYPE_LINE, 2);
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+
+    pipe_buffer_reference(&r300render->vbo, NULL);
 }
 
-static void r300_emit_tri(struct draw_stage* draw, struct prim_header* prim)
+static boolean r300_swtcl_render_set_primitive(struct vbuf_render* render,
+                                               unsigned prim)
 {
-    r300_emit_prim(draw, prim, R300_PRIM_TYPE_TRI_LIST, 3);
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    r300render->prim = prim;
+
+    switch (prim) {
+        case PIPE_PRIM_POINTS:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_POINTS;
+            break;
+        case PIPE_PRIM_LINES:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_LINES;
+            break;
+        case PIPE_PRIM_LINE_LOOP:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_LINE_LOOP;
+            break;
+        case PIPE_PRIM_LINE_STRIP:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_LINE_STRIP;
+            break;
+        case PIPE_PRIM_TRIANGLES:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_TRIANGLES;
+            break;
+        case PIPE_PRIM_TRIANGLE_STRIP:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP;
+            break;
+        case PIPE_PRIM_TRIANGLE_FAN:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN;
+            break;
+        case PIPE_PRIM_QUADS:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_QUADS;
+            break;
+        case PIPE_PRIM_QUAD_STRIP:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_QUAD_STRIP;
+            break;
+        case PIPE_PRIM_POLYGON:
+            r300render->hwprim = R300_VAP_VF_CNTL__PRIM_POLYGON;
+            break;
+        default:
+            return FALSE;
+            break;
+    }
+
+    return TRUE;
 }
 
-static void r300_swtcl_flush(struct draw_stage* draw, unsigned flags)
+static void prepare_render(struct r300_swtcl_render* render, unsigned count)
 {
+    struct r300_context* r300 = render->r300;
+    int i;
+
+    CS_LOCALS(r300);
+
+    /* Make sure that all possible state is emitted. */
+    r300_emit_dirty_state(r300);
+
+    debug_printf("r300: Preparing vertex buffer %p for render, "
+            "vertex size %d, vertex count %d\n", render->vbo,
+            r300->vertex_info.vinfo.size, count);
+    /* Set the pointer to our vertex buffer. The emitted values are this:
+     * PACKET3 [3D_LOAD_VBPNTR]
+     * COUNT   [1]
+     * FORMAT  [size | stride << 8]
+     * OFFSET  [0]
+     * VBPNTR  [relocated BO]
+     */
+    BEGIN_CS(7);
+    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(render->vbo_offset);
+    OUT_CS_RELOC(render->vbo, 0, RADEON_GEM_DOMAIN_GTT, 0, 0);
+    END_CS;
 }
 
-static void r300_reset_stipple(struct draw_stage* draw)
+static void r300_swtcl_render_draw_arrays(struct vbuf_render* render,
+                                          unsigned start,
+                                          unsigned count)
 {
-    /* XXX */
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct r300_context* r300 = r300render->r300;
+    struct pipe_screen* screen = r300->context.screen;
+
+    CS_LOCALS(r300);
+
+    r300render->vbo_offset = start;
+
+    prepare_render(r300render, count);
+
+    debug_printf("r300: Doing vbuf render, count %d\n", count);
+
+    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);
+    END_CS;
+}
+
+static void r300_swtcl_render_draw(struct vbuf_render* render,
+                                   const ushort* indices,
+                                   uint count)
+{
+    struct r300_swtcl_render* r300render = r300_swtcl_render(render);
+    struct r300_context* r300 = r300render->r300;
+    struct pipe_screen* screen = r300->context.screen;
+    struct pipe_buffer* index_buffer;
+    void* index_map;
+
+    CS_LOCALS(r300);
+
+    count /= 4;
+
+    prepare_render(r300render, count);
+
+    /* Send our indices into an index buffer. */
+    index_buffer = pipe_buffer_create(screen, 64, PIPE_BUFFER_USAGE_VERTEX,
+                                      count * 4);
+    if (!index_buffer) {
+        return;
+    }
+
+    index_map = pipe_buffer_map(screen, index_buffer,
+                                PIPE_BUFFER_USAGE_CPU_WRITE);
+    memcpy(index_map, indices, count * 4);
+    pipe_buffer_unmap(screen, index_buffer);
+
+    debug_printf("r300: Doing indexbuf render, count %d\n", count);
+#if 0
+    BEGIN_CS(5);
+    OUT_CS(CP_PACKET3(R300_PACKET3_3D_DRAW_INDX_2, 0));
+    OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
+           r300render->hwprim | R300_VAP_VF_CNTL__INDEX_SIZE_32bit);
+
+    OUT_CS(CP_PACKET3(R300_PACKET3_INDX_BUFFER, 2));
+    OUT_CS(R300_INDX_BUFFER_ONE_REG_WR | (R300_VAP_PORT_IDX0 >> 2));
+    OUT_CS_RELOC(index_buffer, 0, RADEON_GEM_DOMAIN_GTT, 0, 0);
+    END_CS;
+#endif
+}
+
+static void r300_swtcl_render_destroy(struct vbuf_render* render)
+{
+    FREE(render);
 }
 
-static void r300_swtcl_destroy(struct draw_stage* draw)
+static struct vbuf_render* r300_swtcl_render_create(struct r300_context* r300)
 {
-    FREE(draw);
+    struct r300_swtcl_render* r300render = CALLOC_STRUCT(r300_swtcl_render);
+    struct pipe_screen* screen = r300->context.screen;
+
+    r300render->r300 = r300;
+
+    /* XXX find real numbers plz */
+    r300render->base.max_vertex_buffer_bytes = 128 * 1024;
+    r300render->base.max_indices = 16 * 1024;
+
+    r300render->base.get_vertex_info = r300_swtcl_render_get_vertex_info;
+    r300render->base.allocate_vertices = r300_swtcl_render_allocate_vertices;
+    r300render->base.map_vertices = r300_swtcl_render_map_vertices;
+    r300render->base.unmap_vertices = r300_swtcl_render_unmap_vertices;
+    r300render->base.set_primitive = r300_swtcl_render_set_primitive;
+    r300render->base.draw = r300_swtcl_render_draw;
+    r300render->base.draw_arrays = r300_swtcl_render_draw_arrays;
+    r300render->base.release_vertices = r300_swtcl_render_release_vertices;
+    r300render->base.destroy = r300_swtcl_render_destroy;
+
+    /* XXX bonghits ahead
+    r300render->vbo_alloc_size = 128 * 4096;
+    r300render->vbo_size = r300render->vbo_alloc_size;
+    r300render->vbo_offset = 0;
+    r300render->vbo = pipe_buffer_create(screen,
+                                         64,
+                                         PIPE_BUFFER_USAGE_VERTEX,
+                                         r300render->vbo_size);
+    r300render->vbo_map = pipe_buffer_map(screen,
+                                          r300render->vbo,
+                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+    pipe_buffer_unmap(screen, r300render->vbo); */
+
+    return &r300render->base;
 }
 
 struct draw_stage* r300_draw_swtcl_stage(struct r300_context* r300)
 {
-    struct swtcl_stage* swtcl = CALLOC_STRUCT(swtcl_stage);
+    struct vbuf_render* render;
+    struct draw_stage* stage;
+
+    render = r300_swtcl_render_create(r300);
+
+    if (!render) {
+        return NULL;
+    }
+
+    stage = draw_vbuf_stage(r300->draw, render);
+
+    if (!stage) {
+        render->destroy(render);
+        return NULL;
+    }
 
-    swtcl->r300 = r300;
-    swtcl->draw.point = r300_emit_point;
-    swtcl->draw.line = r300_emit_line;
-    swtcl->draw.tri = r300_emit_tri;
-    swtcl->draw.flush = r300_swtcl_flush;
-    swtcl->draw.reset_stipple_counter = r300_reset_stipple;
-    swtcl->draw.destroy = r300_swtcl_destroy;
+    draw_set_render(r300->draw, render);
 
-    return &swtcl->draw;
+    return stage;
 }
diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index ff812c09f80..6cdea3d2854 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -27,12 +27,37 @@ static int minify(int i)
     return MAX2(1, i >> 1);
 }
 
+static void r300_setup_texture_state(struct r300_texture* tex,
+                                     unsigned width,
+                                     unsigned height,
+                                     unsigned pitch)
+{
+    struct r300_texture_state* state = &tex->state;
+
+    state->format0 = R300_TX_WIDTH((width - 1) & 0x7ff) |
+        R300_TX_HEIGHT((height - 1) & 0x7ff) | R300_TX_PITCH_EN;
+
+    /* XXX */
+    state->format1 = R300_TX_FORMAT_A8R8G8B8;
+
+    state->format2 = pitch - 1;
+
+    /* XXX
+    if (width > 2048) {
+        state->pitch |= R300_TXWIDTH_11;
+    }
+    if (height > 2048) {
+        state->pitch |= R300_TXHEIGHT_11;
+    } */
+}
+
 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]);
@@ -43,13 +68,16 @@ static void r300_setup_miptree(struct r300_texture* tex)
         base->nblocksy[i] = pf_get_nblocksy(&base->block, base->width[i]);
 
         /* Radeons enjoy things in multiples of 32. */
-        /* XXX NPOT -> 64, not 32 */
+        /* XXX this can be 32 when POT */
         stride = (base->nblocksx[i] * base->block.size + 63) & ~63;
         size = stride * base->nblocksy[i] * base->depth[i];
 
-        /* XXX 64 for NPOT */
         tex->offset[i] = (tex->size + 63) & ~63;
         tex->size = tex->offset[i] + size;
+
+        if (i == 0) {
+            tex->stride = stride;
+        }
     }
 }
 
@@ -67,12 +95,16 @@ static struct pipe_texture*
     }
 
     tex->tex = *template;
-    tex->tex.refcount = 1;
+    pipe_reference_init(&tex->tex.reference, 1);
     tex->tex.screen = screen;
 
     r300_setup_miptree(tex);
 
-    tex->buffer = screen->buffer_create(screen, 63,
+    /* XXX */
+    r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0],
+            tex->tex.width[0]);
+
+    tex->buffer = screen->buffer_create(screen, 64,
                                         PIPE_BUFFER_USAGE_PIXEL,
                                         tex->size);
 
@@ -84,24 +116,13 @@ static struct pipe_texture*
     return (struct pipe_texture*)tex;
 }
 
-static void r300_texture_release(struct pipe_screen* screen,
-                                 struct pipe_texture** texture)
+static void r300_texture_destroy(struct pipe_texture* texture)
 {
-    if (!*texture) {
-        return;
-    }
-
-    (*texture)->refcount--;
-
-    if ((*texture)->refcount <= 0) {
-        struct r300_texture* tex = (struct r300_texture*)*texture;
+    struct r300_texture* tex = (struct r300_texture*)texture;
 
-        pipe_buffer_reference(screen, &tex->buffer, NULL);
+    pipe_buffer_reference(&tex->buffer, NULL);
 
-        FREE(tex);
-    }
-
-    *texture = NULL;
+    FREE(tex);
 }
 
 static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
@@ -119,17 +140,11 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
     offset = tex->offset[level];
 
     if (surface) {
-        surface->refcount = 1;
+        pipe_reference_init(&surface->reference, 1);
         pipe_texture_reference(&surface->texture, texture);
         surface->format = texture->format;
         surface->width = texture->width[level];
         surface->height = texture->height[level];
-        surface->block = texture->block;
-        surface->nblocksx = texture->nblocksx[level];
-        surface->nblocksy = texture->nblocksy[level];
-        /* XXX save the actual stride instead plz kthnxbai */
-        surface->stride =
-            (texture->nblocksx[level] * texture->block.size + 63) & ~63;
         surface->offset = offset;
         surface->usage = flags;
         surface->status = PIPE_SURFACE_STATUS_DEFINED;
@@ -138,19 +153,10 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
     return surface;
 }
 
-static void r300_tex_surface_release(struct pipe_screen* screen,
-                                     struct pipe_surface** surface)
+static void r300_tex_surface_destroy(struct pipe_surface* s)
 {
-    struct pipe_surface* s = *surface;
-
-    s->refcount--;
-
-    if (s->refcount <= 0) {
-        pipe_texture_reference(&s->texture, NULL);
-        FREE(s);
-    }
-
-    *surface = NULL;
+    pipe_texture_reference(&s->texture, NULL);
+    FREE(s);
 }
 
 static struct pipe_texture*
@@ -173,12 +179,15 @@ static struct pipe_texture*
     }
 
     tex->tex = *base;
-    tex->tex.refcount = 1;
+    pipe_reference_init(&tex->tex.reference, 1);
     tex->tex.screen = screen;
 
-    /* XXX tex->stride = *stride; */
+    tex->stride = *stride;
+
+    r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0],
+            tex->stride);
 
-    pipe_buffer_reference(screen, &tex->buffer, buffer);
+    pipe_buffer_reference(&tex->buffer, buffer);
 
     return (struct pipe_texture*)tex;
 }
@@ -186,8 +195,26 @@ static struct pipe_texture*
 void r300_init_screen_texture_functions(struct pipe_screen* screen)
 {
     screen->texture_create = r300_texture_create;
-    screen->texture_release = r300_texture_release;
+    screen->texture_destroy = r300_texture_destroy;
     screen->get_tex_surface = r300_get_tex_surface;
-    screen->tex_surface_release = r300_tex_surface_release;
+    screen->tex_surface_destroy = r300_tex_surface_destroy;
     screen->texture_blanket = r300_texture_blanket;
 }
+
+boolean r300_get_texture_buffer(struct pipe_texture* texture,
+                                struct pipe_buffer** buffer,
+                                unsigned* stride)
+{
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    if (!tex) {
+        return FALSE;
+    }
+
+    pipe_buffer_reference(buffer, tex->buffer);
+
+    if (stride) {
+        *stride = tex->stride;
+    }
+
+    return TRUE;
+}
diff --git a/src/gallium/drivers/r300/r300_texture.h b/src/gallium/drivers/r300/r300_texture.h
index 7964229a94f..98fb5c9a08f 100644
--- a/src/gallium/drivers/r300/r300_texture.h
+++ b/src/gallium/drivers/r300/r300_texture.h
@@ -28,7 +28,16 @@
 #include "util/u_math.h"
 
 #include "r300_context.h"
+#include "r300_reg.h"
 
 void r300_init_screen_texture_functions(struct pipe_screen* screen);
 
+#ifndef R300_WINSYS_H
+
+boolean r300_get_texture_buffer(struct pipe_texture* texture,
+                                struct pipe_buffer** buffer,
+                                unsigned* stride);
+
+#endif /* R300_WINSYS_H */
+
 #endif /* R300_TEXTURE_H */
diff --git a/src/gallium/drivers/r300/r300_winsys.h b/src/gallium/drivers/r300/r300_winsys.h
index 5a3a2128927..baa95282c33 100644
--- a/src/gallium/drivers/r300/r300_winsys.h
+++ b/src/gallium/drivers/r300/r300_winsys.h
@@ -33,10 +33,16 @@ extern "C" {
 
 #include "pipe/p_defines.h"
 #include "pipe/p_state.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 struct radeon_cs;
 
 struct r300_winsys {
+    /* Parent class */
+    struct pipe_winsys base;
+
+    /* Opaque Radeon-specific winsys object. */
+    void* radeon_winsys;
 
     /* PCI ID */
     uint32_t pci_id;
@@ -47,10 +53,6 @@ struct r300_winsys {
     /* CS object. This is very much like Intel's batchbuffer.
      * Fill it full of dwords and relocs and then submit.
      * Repeat as needed. */
-    /* Note: Unlike Mesa's version of this, we don't keep a copy of the CSM
-     * that was used to create this CS. Is this a good idea? */
-    /* Note: The pipe driver doesn't know how to use this. This is purely
-     * for the winsys. */
     struct radeon_cs* cs;
 
     /* Check to see if there's room for commands. */
@@ -84,9 +86,12 @@ struct r300_winsys {
 };
 
 struct pipe_context* r300_create_context(struct pipe_screen* screen,
-                                         struct pipe_winsys* winsys,
                                          struct r300_winsys* r300_winsys);
 
+boolean r300_get_texture_buffer(struct pipe_texture* texture,
+                                struct pipe_buffer** buffer,
+                                unsigned* stride);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/gallium/drivers/softpipe/Makefile b/src/gallium/drivers/softpipe/Makefile
index 120bdfd9dd2..516e3992fdd 100644
--- a/src/gallium/drivers/softpipe/Makefile
+++ b/src/gallium/drivers/softpipe/Makefile
@@ -14,7 +14,7 @@ C_SOURCES = \
 	sp_draw_arrays.c \
 	sp_prim_setup.c \
 	sp_prim_vbuf.c \
-	sp_quad.c \
+	sp_quad_pipe.c \
 	sp_quad_alpha_test.c \
 	sp_quad_blend.c \
 	sp_quad_colormask.c \
@@ -42,6 +42,3 @@ C_SOURCES = \
 	sp_surface.c 
 
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/softpipe/SConscript b/src/gallium/drivers/softpipe/SConscript
index c1f7daa8ab3..f8720638a76 100644
--- a/src/gallium/drivers/softpipe/SConscript
+++ b/src/gallium/drivers/softpipe/SConscript
@@ -17,7 +17,7 @@ softpipe = env.ConvenienceLibrary(
 		'sp_setup.c',
 		'sp_quad_alpha_test.c',
 		'sp_quad_blend.c',
-		'sp_quad.c',
+		'sp_quad_pipe.c',
 		'sp_quad_colormask.c',
 		'sp_quad_coverage.c',
 		'sp_quad_depth_test.c',
diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c
index c2d882a8197..06ace27d14b 100644
--- a/src/gallium/drivers/softpipe/sp_context.c
+++ b/src/gallium/drivers/softpipe/sp_context.c
@@ -32,7 +32,6 @@
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_inlines.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include "sp_clear.h"
@@ -53,15 +52,15 @@
  * Map any drawing surfaces which aren't already mapped
  */
 void
-softpipe_map_surfaces(struct softpipe_context *sp)
+softpipe_map_transfers(struct softpipe_context *sp)
 {
    unsigned i;
 
    for (i = 0; i < sp->framebuffer.nr_cbufs; i++) {
-      sp_tile_cache_map_surfaces(sp->cbuf_cache[i]);
+      sp_tile_cache_map_transfers(sp->cbuf_cache[i]);
    }
 
-   sp_tile_cache_map_surfaces(sp->zsbuf_cache);
+   sp_tile_cache_map_transfers(sp->zsbuf_cache);
 }
 
 
@@ -69,7 +68,7 @@ softpipe_map_surfaces(struct softpipe_context *sp)
  * Unmap any mapped drawing surfaces
  */
 void
-softpipe_unmap_surfaces(struct softpipe_context *sp)
+softpipe_unmap_transfers(struct softpipe_context *sp)
 {
    uint i;
 
@@ -78,16 +77,15 @@ softpipe_unmap_surfaces(struct softpipe_context *sp)
    sp_flush_tile_cache(sp, sp->zsbuf_cache);
 
    for (i = 0; i < sp->framebuffer.nr_cbufs; i++) {
-      sp_tile_cache_unmap_surfaces(sp->cbuf_cache[i]);
+      sp_tile_cache_unmap_transfers(sp->cbuf_cache[i]);
    }
-   sp_tile_cache_unmap_surfaces(sp->zsbuf_cache);
+   sp_tile_cache_unmap_transfers(sp->zsbuf_cache);
 }
 
 
 static void softpipe_destroy( struct pipe_context *pipe )
 {
    struct softpipe_context *softpipe = softpipe_context( pipe );
-   struct pipe_screen *screen = pipe->screen;
    uint i;
 
    if (softpipe->draw)
@@ -116,7 +114,7 @@ static void softpipe_destroy( struct pipe_context *pipe )
 
    for (i = 0; i < Elements(softpipe->constants); i++) {
       if (softpipe->constants[i].buffer) {
-         pipe_buffer_reference(screen, &softpipe->constants[i].buffer, NULL);
+         pipe_buffer_reference(&softpipe->constants[i].buffer, NULL);
       }
    }
 
diff --git a/src/gallium/drivers/softpipe/sp_context.h b/src/gallium/drivers/softpipe/sp_context.h
index e2451c6ecb5..59d6df8f2dd 100644
--- a/src/gallium/drivers/softpipe/sp_context.h
+++ b/src/gallium/drivers/softpipe/sp_context.h
@@ -32,11 +32,10 @@
 #define SP_CONTEXT_H
 
 #include "pipe/p_context.h"
-#include "pipe/p_defines.h"
 
 #include "draw/draw_vertex.h"
 
-#include "sp_quad.h"
+#include "sp_quad_pipe.h"
 #include "sp_tex_sample.h"
 
 
@@ -51,7 +50,6 @@
  */
 #define SP_NUM_QUAD_THREADS 1
 
-struct softpipe_winsys;
 struct softpipe_vbuf_render;
 struct draw_context;
 struct draw_stage;
@@ -63,15 +61,15 @@ struct sp_vertex_shader;
 struct softpipe_context {
    struct pipe_context pipe;  /**< base class */
 
-   /* The most recent drawing state as set by the driver:
-    */
-   const struct pipe_blend_state   *blend;
+   /** Constant state objects */
+   const struct pipe_blend_state *blend;
    const struct pipe_sampler_state *sampler[PIPE_MAX_SAMPLERS];
-   const struct pipe_depth_stencil_alpha_state   *depth_stencil;
+   const struct pipe_depth_stencil_alpha_state *depth_stencil;
    const struct pipe_rasterizer_state *rasterizer;
    const struct sp_fragment_shader *fs;
    const struct sp_vertex_shader *vs;
 
+   /** Other rendering state */
    struct pipe_blend_color blend_color;
    struct pipe_clip_state clip;
    struct pipe_constant_buffer constants[PIPE_SHADER_TYPES];
@@ -82,23 +80,20 @@ struct softpipe_context {
    struct pipe_viewport_state viewport;
    struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS];
    struct pipe_vertex_element vertex_element[PIPE_MAX_ATTRIBS];
-   unsigned dirty;
 
    unsigned num_samplers;
    unsigned num_textures;
    unsigned num_vertex_elements;
    unsigned num_vertex_buffers;
 
-   boolean no_rast;
+   unsigned dirty; /**< Mask of SP_NEW_x flags */
 
    /* Counter for occlusion queries.  Note this supports overlapping
     * queries.
     */
    uint64_t occlusion_count;
 
-   /*
-    * Mapped vertex buffers
-    */
+   /** Mapped vertex buffers */
    ubyte *mapped_vbuffer[PIPE_MAX_ATTRIBS];
    
    /** Mapped constant buffers */
@@ -108,16 +103,11 @@ struct softpipe_context {
    struct vertex_info vertex_info;
    struct vertex_info vertex_info_vbuf;
 
+   /** Which vertex shader output slot contains point size */
    int psize_slot;
 
    unsigned reduced_api_prim;  /**< PIPE_PRIM_POINTS, _LINES or _TRIANGLES */
 
-#if 0
-   /* Stipple derived state:
-    */
-   ubyte stipple_masks[16][16];
-#endif
-
    /** Derived from scissor and surface bounds: */
    struct pipe_scissor_state cliprect;
 
@@ -159,8 +149,9 @@ struct softpipe_context {
 
    struct softpipe_tile_cache *tex_cache[PIPE_MAX_SAMPLERS];
 
-   int use_sse : 1;
-   int dump_fs : 1;
+   unsigned use_sse : 1;
+   unsigned dump_fs : 1;
+   unsigned no_rast : 1;
 };
 
 
diff --git a/src/gallium/drivers/softpipe/sp_draw_arrays.c b/src/gallium/drivers/softpipe/sp_draw_arrays.c
index 7e3a25e34b1..f117096bf73 100644
--- a/src/gallium/drivers/softpipe/sp_draw_arrays.c
+++ b/src/gallium/drivers/softpipe/sp_draw_arrays.c
@@ -134,7 +134,7 @@ softpipe_draw_range_elements(struct pipe_context *pipe,
    if (sp->dirty)
       softpipe_update_derived( sp );
 
-   softpipe_map_surfaces(sp);
+   softpipe_map_transfers(sp);
    softpipe_map_constant_buffers(sp);
 
    /*
diff --git a/src/gallium/drivers/softpipe/sp_flush.c b/src/gallium/drivers/softpipe/sp_flush.c
index c21faf57f3e..035f4b963eb 100644
--- a/src/gallium/drivers/softpipe/sp_flush.c
+++ b/src/gallium/drivers/softpipe/sp_flush.c
@@ -70,7 +70,7 @@ softpipe_flush( struct pipe_context *pipe,
        * that's called before swapbuffers because we don't always want
        * to unmap surfaces when flushing.
        */
-      softpipe_unmap_surfaces(softpipe);
+      softpipe_unmap_transfers(softpipe);
    }
 
    /* Enable to dump BMPs of the color/depth buffers each frame */
diff --git a/src/gallium/drivers/softpipe/sp_fs_exec.c b/src/gallium/drivers/softpipe/sp_fs_exec.c
index 453b0373f0f..0c14d92864f 100644
--- a/src/gallium/drivers/softpipe/sp_fs_exec.c
+++ b/src/gallium/drivers/softpipe/sp_fs_exec.c
@@ -29,13 +29,12 @@
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_fs.h"
-#include "sp_headers.h"
+#include "sp_quad.h"
 
 
 #include "pipe/p_state.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
-#include "pipe/p_inlines.h"
 #include "tgsi/tgsi_exec.h"
 #include "tgsi/tgsi_parse.h"
 
diff --git a/src/gallium/drivers/softpipe/sp_fs_llvm.c b/src/gallium/drivers/softpipe/sp_fs_llvm.c
index 34adac5226c..f33b3e32854 100644
--- a/src/gallium/drivers/softpipe/sp_fs_llvm.c
+++ b/src/gallium/drivers/softpipe/sp_fs_llvm.c
@@ -37,7 +37,6 @@
 #include "pipe/p_state.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
-#include "pipe/p_inlines.h"
 #include "tgsi/tgsi_sse2.h"
 
 #if 0
diff --git a/src/gallium/drivers/softpipe/sp_fs_sse.c b/src/gallium/drivers/softpipe/sp_fs_sse.c
index 9a273c87643..366abe2ed49 100644
--- a/src/gallium/drivers/softpipe/sp_fs_sse.c
+++ b/src/gallium/drivers/softpipe/sp_fs_sse.c
@@ -29,13 +29,12 @@
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_fs.h"
-#include "sp_headers.h"
+#include "sp_quad.h"
 
 
 #include "pipe/p_state.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
-#include "pipe/p_inlines.h"
 #include "tgsi/tgsi_exec.h"
 #include "tgsi/tgsi_sse2.h"
 
@@ -146,7 +145,7 @@ softpipe_create_fs_sse(struct softpipe_context *softpipe,
       return NULL;
    }
 
-   shader->base.shader = *templ;
+   shader->base.shader.tokens = NULL; /* don't hold reference to templ->tokens */
    shader->base.prepare = fs_sse_prepare;
    shader->base.run = fs_sse_run;
    shader->base.delete = fs_sse_delete;
diff --git a/src/gallium/drivers/softpipe/sp_headers.h b/src/gallium/drivers/softpipe/sp_headers.h
deleted file mode 100644
index 4a42cb3c192..00000000000
--- a/src/gallium/drivers/softpipe/sp_headers.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * 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 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-/* Authors:  Keith Whitwell <[email protected]>
- */
-
-#ifndef SP_HEADERS_H
-#define SP_HEADERS_H
-
-#include "pipe/p_state.h"
-#include "tgsi/tgsi_exec.h"
-
-#define PRIM_POINT 1
-#define PRIM_LINE  2
-#define PRIM_TRI   3
-
-
-/* The rasterizer generates 2x2 quads of fragment and feeds them to
- * the current fp_machine (see below).
- * Remember that Y=0=top with Y increasing down the window.
- */
-#define QUAD_TOP_LEFT     0
-#define QUAD_TOP_RIGHT    1
-#define QUAD_BOTTOM_LEFT  2
-#define QUAD_BOTTOM_RIGHT 3
-
-#define MASK_TOP_LEFT     (1 << QUAD_TOP_LEFT)
-#define MASK_TOP_RIGHT    (1 << QUAD_TOP_RIGHT)
-#define MASK_BOTTOM_LEFT  (1 << QUAD_BOTTOM_LEFT)
-#define MASK_BOTTOM_RIGHT (1 << QUAD_BOTTOM_RIGHT)
-#define MASK_ALL          0xf
-
-
-/**
- * Encodes everything we need to know about a 2x2 pixel block.  Uses
- * "Channel-Serial" or "SoA" layout.  
- */
-struct quad_header_input
-{
-   int x0;
-   int y0;
-   float coverage[QUAD_SIZE];    /** fragment coverage for antialiasing */
-   unsigned facing:1;   /**< Front (0) or back (1) facing? */
-   unsigned prim:2;     /**< PRIM_POINT, LINE, TRI */
-};
-
-struct quad_header_inout
-{
-   unsigned mask:4;
-};
-
-struct quad_header_output
-{
-   /** colors in SOA format (rrrr, gggg, bbbb, aaaa) */
-   float color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][QUAD_SIZE];
-   float depth[QUAD_SIZE];
-};
-
-struct quad_header {
-   struct quad_header_input input;
-   struct quad_header_inout inout;
-   struct quad_header_output output;
-
-   const struct tgsi_interp_coef *coef;
-   const struct tgsi_interp_coef *posCoef;
-
-   unsigned nr_attrs;
-};
-
-#endif /* SP_HEADERS_H */
-
diff --git a/src/gallium/drivers/softpipe/sp_prim_vbuf.c b/src/gallium/drivers/softpipe/sp_prim_vbuf.c
index 9cd5784e5bc..eef6e5806c9 100644
--- a/src/gallium/drivers/softpipe/sp_prim_vbuf.c
+++ b/src/gallium/drivers/softpipe/sp_prim_vbuf.c
@@ -60,6 +60,8 @@ struct softpipe_vbuf_render
    struct softpipe_context *softpipe;
    uint prim;
    uint vertex_size;
+   uint nr_vertices;
+   uint vertex_buffer_size;
    void *vertex_buffer;
 };
 
@@ -80,26 +82,76 @@ sp_vbuf_get_vertex_info(struct vbuf_render *vbr)
 }
 
 
-static void *
+static boolean
 sp_vbuf_allocate_vertices(struct vbuf_render *vbr,
-                            ushort vertex_size, ushort nr_vertices)
+                          ushort vertex_size, ushort nr_vertices)
 {
    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
-   assert(!cvbr->vertex_buffer);
-   cvbr->vertex_buffer = align_malloc(vertex_size * nr_vertices, 16);
+   unsigned size = vertex_size * nr_vertices;
+
+   if (cvbr->vertex_buffer_size < size) {
+      align_free(cvbr->vertex_buffer);
+      cvbr->vertex_buffer = align_malloc(size, 16);
+      cvbr->vertex_buffer_size = size;
+   }
+
    cvbr->vertex_size = vertex_size;
-   return cvbr->vertex_buffer;
+   cvbr->nr_vertices = nr_vertices;
+   
+   return cvbr->vertex_buffer != NULL;
 }
 
-
 static void
-sp_vbuf_release_vertices(struct vbuf_render *vbr, void *vertices,
-                           unsigned vertex_size, unsigned vertices_used)
+sp_vbuf_release_vertices(struct vbuf_render *vbr)
+{
+#if 0
+   {
+      struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
+      const struct vertex_info *info = 
+         softpipe_get_vbuf_vertex_info(cvbr->softpipe);
+      const float *vtx = (const float *) cvbr->vertex_buffer;
+      uint i, j;
+      debug_printf("%s (vtx_size = %u,  vtx_used = %u)\n",
+             __FUNCTION__, cvbr->vertex_size, cvbr->nr_vertices);
+      for (i = 0; i < cvbr->nr_vertices; i++) {
+         for (j = 0; j < info->num_attribs; j++) {
+            uint k;
+            switch (info->attrib[j].emit) {
+            case EMIT_4F:  k = 4;   break;
+            case EMIT_3F:  k = 3;   break;
+            case EMIT_2F:  k = 2;   break;
+            case EMIT_1F:  k = 1;   break;
+            default: assert(0);
+            }
+            debug_printf("Vert %u attr %u: ", i, j);
+            while (k-- > 0) {
+               debug_printf("%g ", vtx[0]);
+               vtx++;
+            }
+            debug_printf("\n");
+         }
+      }
+   }
+#endif
+
+   /* keep the old allocation for next time */
+}
+
+static void *
+sp_vbuf_map_vertices(struct vbuf_render *vbr)
 {
    struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
-   align_free(vertices);
-   assert(vertices == cvbr->vertex_buffer);
-   cvbr->vertex_buffer = NULL;
+   return cvbr->vertex_buffer;
+}
+
+static void 
+sp_vbuf_unmap_vertices(struct vbuf_render *vbr, 
+                       ushort min_index,
+                       ushort max_index )
+{
+   struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
+   assert( cvbr->vertex_buffer_size >= (max_index+1) * cvbr->vertex_size );
+   /* do nothing */
 }
 
 
@@ -115,8 +167,6 @@ sp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim)
    
    setup_prepare( setup_ctx );
 
-
-
    cvbr->prim = prim;
    return TRUE;
 
@@ -394,6 +444,8 @@ sp_init_vbuf(struct softpipe_context *sp)
 
    sp->vbuf_render->base.get_vertex_info = sp_vbuf_get_vertex_info;
    sp->vbuf_render->base.allocate_vertices = sp_vbuf_allocate_vertices;
+   sp->vbuf_render->base.map_vertices = sp_vbuf_map_vertices;
+   sp->vbuf_render->base.unmap_vertices = sp_vbuf_unmap_vertices;
    sp->vbuf_render->base.set_primitive = sp_vbuf_set_primitive;
    sp->vbuf_render->base.draw = sp_vbuf_draw;
    sp->vbuf_render->base.draw_arrays = sp_vbuf_draw_arrays;
diff --git a/src/gallium/drivers/softpipe/sp_quad.h b/src/gallium/drivers/softpipe/sp_quad.h
index 08513cb95f1..bd6c6cb9123 100644
--- a/src/gallium/drivers/softpipe/sp_quad.h
+++ b/src/gallium/drivers/softpipe/sp_quad.h
@@ -31,39 +31,76 @@
 #ifndef SP_QUAD_H
 #define SP_QUAD_H
 
+#include "pipe/p_state.h"
+#include "tgsi/tgsi_exec.h"
 
-struct softpipe_context;
-struct quad_header;
 
+#define QUAD_PRIM_POINT 1
+#define QUAD_PRIM_LINE  2
+#define QUAD_PRIM_TRI   3
 
-struct quad_stage {
-   struct softpipe_context *softpipe;
 
-   struct quad_stage *next;
+/* The rasterizer generates 2x2 quads of fragment and feeds them to
+ * the current fp_machine (see below).
+ * Remember that Y=0=top with Y increasing down the window.
+ */
+#define QUAD_TOP_LEFT     0
+#define QUAD_TOP_RIGHT    1
+#define QUAD_BOTTOM_LEFT  2
+#define QUAD_BOTTOM_RIGHT 3
+
+#define MASK_TOP_LEFT     (1 << QUAD_TOP_LEFT)
+#define MASK_TOP_RIGHT    (1 << QUAD_TOP_RIGHT)
+#define MASK_BOTTOM_LEFT  (1 << QUAD_BOTTOM_LEFT)
+#define MASK_BOTTOM_RIGHT (1 << QUAD_BOTTOM_RIGHT)
+#define MASK_ALL          0xf
+
+
+/**
+ * Quad stage inputs (pos, coverage, front/back face, etc)
+ */
+struct quad_header_input
+{
+   int x0, y0;                /**< quad window pos, always even */
+   float coverage[QUAD_SIZE]; /**< fragment coverage for antialiasing */
+   unsigned facing:1;         /**< Front (0) or back (1) facing? */
+   unsigned prim:2;           /**< QUAD_PRIM_POINT, LINE, TRI */
+};
 
-   void (*begin)(struct quad_stage *qs);
 
-   /** the stage action */
-   void (*run)(struct quad_stage *qs, struct quad_header *quad);
+/**
+ * Quad stage inputs/outputs.
+ */
+struct quad_header_inout
+{
+   unsigned mask:4;
+};
+
 
-   void (*destroy)(struct quad_stage *qs);
+/**
+ * Quad stage outputs (color & depth).
+ */
+struct quad_header_output
+{
+   /** colors in SOA format (rrrr, gggg, bbbb, aaaa) */
+   float color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][QUAD_SIZE];
+   float depth[QUAD_SIZE];
 };
 
 
-struct quad_stage *sp_quad_polygon_stipple_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_earlyz_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_shade_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_alpha_test_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_stencil_test_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_depth_test_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_occlusion_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_coverage_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_blend_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_colormask_stage( struct softpipe_context *softpipe );
-struct quad_stage *sp_quad_output_stage( struct softpipe_context *softpipe );
+/**
+ * Encodes everything we need to know about a 2x2 pixel block.  Uses
+ * "Channel-Serial" or "SoA" layout.  
+ */
+struct quad_header {
+   struct quad_header_input input;
+   struct quad_header_inout inout;
+   struct quad_header_output output;
 
-void sp_build_quad_pipeline(struct softpipe_context *sp);
+   const struct tgsi_interp_coef *coef;
+   const struct tgsi_interp_coef *posCoef;
 
-void sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad);
+   unsigned nr_attrs;
+};
 
 #endif /* SP_QUAD_H */
diff --git a/src/gallium/drivers/softpipe/sp_quad_alpha_test.c b/src/gallium/drivers/softpipe/sp_quad_alpha_test.c
index 85c9f037a3c..0845bae0e68 100644
--- a/src/gallium/drivers/softpipe/sp_quad_alpha_test.c
+++ b/src/gallium/drivers/softpipe/sp_quad_alpha_test.c
@@ -4,8 +4,8 @@
  */
 
 #include "sp_context.h"
-#include "sp_headers.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 
diff --git a/src/gallium/drivers/softpipe/sp_quad_blend.c b/src/gallium/drivers/softpipe/sp_quad_blend.c
index fb1d430a4f2..e134e443374 100644
--- a/src/gallium/drivers/softpipe/sp_quad_blend.c
+++ b/src/gallium/drivers/softpipe/sp_quad_blend.c
@@ -34,10 +34,10 @@
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
+#include "sp_quad.h"
 #include "sp_surface.h"
 #include "sp_tile_cache.h"
-#include "sp_quad.h"
+#include "sp_quad_pipe.h"
 
 
 #define VEC4_COPY(DST, SRC) \
diff --git a/src/gallium/drivers/softpipe/sp_quad_bufloop.c b/src/gallium/drivers/softpipe/sp_quad_bufloop.c
index d7d6a6974d3..953d8516b90 100644
--- a/src/gallium/drivers/softpipe/sp_quad_bufloop.c
+++ b/src/gallium/drivers/softpipe/sp_quad_bufloop.c
@@ -1,9 +1,9 @@
 
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
-#include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_surface.h"
+#include "sp_quad_pipe.h"
 
 
 /**
diff --git a/src/gallium/drivers/softpipe/sp_quad_colormask.c b/src/gallium/drivers/softpipe/sp_quad_colormask.c
index 563c2fc739d..dc90e5d5e99 100644
--- a/src/gallium/drivers/softpipe/sp_quad_colormask.c
+++ b/src/gallium/drivers/softpipe/sp_quad_colormask.c
@@ -34,9 +34,9 @@
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
-#include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_surface.h"
+#include "sp_quad_pipe.h"
 #include "sp_tile_cache.h"
 
 
diff --git a/src/gallium/drivers/softpipe/sp_quad_coverage.c b/src/gallium/drivers/softpipe/sp_quad_coverage.c
index c27fd1482da..4aeee858705 100644
--- a/src/gallium/drivers/softpipe/sp_quad_coverage.c
+++ b/src/gallium/drivers/softpipe/sp_quad_coverage.c
@@ -35,8 +35,8 @@
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
 
 
 /**
@@ -46,10 +46,11 @@ static void
 coverage_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
+   const uint prim = quad->input.prim;
 
-   if ((softpipe->rasterizer->poly_smooth && quad->input.prim == PRIM_TRI) ||
-       (softpipe->rasterizer->line_smooth && quad->input.prim == PRIM_LINE) ||
-       (softpipe->rasterizer->point_smooth && quad->input.prim == PRIM_POINT)) {
+   if ((softpipe->rasterizer->poly_smooth && prim == QUAD_PRIM_TRI) ||
+       (softpipe->rasterizer->line_smooth && prim == QUAD_PRIM_LINE) ||
+       (softpipe->rasterizer->point_smooth && prim == QUAD_PRIM_POINT)) {
       uint cbuf;
 
       /* loop over colorbuffer outputs */
diff --git a/src/gallium/drivers/softpipe/sp_quad_depth_test.c b/src/gallium/drivers/softpipe/sp_quad_depth_test.c
index 523bd3e0801..d463930bae1 100644
--- a/src/gallium/drivers/softpipe/sp_quad_depth_test.c
+++ b/src/gallium/drivers/softpipe/sp_quad_depth_test.c
@@ -32,9 +32,9 @@
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
-#include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_surface.h"
+#include "sp_quad_pipe.h"
 #include "sp_tile_cache.h"
 
 
diff --git a/src/gallium/drivers/softpipe/sp_quad_earlyz.c b/src/gallium/drivers/softpipe/sp_quad_earlyz.c
index 6e2dde304ea..496fd39ed1a 100644
--- a/src/gallium/drivers/softpipe/sp_quad_earlyz.c
+++ b/src/gallium/drivers/softpipe/sp_quad_earlyz.c
@@ -31,8 +31,8 @@
 
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
-#include "sp_headers.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
 
 
 /**
diff --git a/src/gallium/drivers/softpipe/sp_quad_fs.c b/src/gallium/drivers/softpipe/sp_quad_fs.c
index 5dacbbe55f8..adca5df73d8 100644
--- a/src/gallium/drivers/softpipe/sp_quad_fs.c
+++ b/src/gallium/drivers/softpipe/sp_quad_fs.c
@@ -43,8 +43,8 @@
 
 #include "sp_context.h"
 #include "sp_state.h"
-#include "sp_headers.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
 #include "sp_texture.h"
 #include "sp_tex_sample.h"
 
diff --git a/src/gallium/drivers/softpipe/sp_quad_occlusion.c b/src/gallium/drivers/softpipe/sp_quad_occlusion.c
index 169bd82876d..dfa7ff3b1d1 100644
--- a/src/gallium/drivers/softpipe/sp_quad_occlusion.c
+++ b/src/gallium/drivers/softpipe/sp_quad_occlusion.c
@@ -35,9 +35,9 @@
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
-#include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_surface.h"
+#include "sp_quad_pipe.h"
 
 static unsigned count_bits( unsigned val )
 {
diff --git a/src/gallium/drivers/softpipe/sp_quad_output.c b/src/gallium/drivers/softpipe/sp_quad_output.c
index a37c8b4c397..92d5f9f3c1a 100644
--- a/src/gallium/drivers/softpipe/sp_quad_output.c
+++ b/src/gallium/drivers/softpipe/sp_quad_output.c
@@ -27,9 +27,9 @@
 
 #include "util/u_memory.h"
 #include "sp_context.h"
-#include "sp_headers.h"
-#include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_surface.h"
+#include "sp_quad_pipe.h"
 #include "sp_tile_cache.h"
 
 
diff --git a/src/gallium/drivers/softpipe/sp_quad.c b/src/gallium/drivers/softpipe/sp_quad_pipe.c
index 892ef87ee9f..892ef87ee9f 100644
--- a/src/gallium/drivers/softpipe/sp_quad.c
+++ b/src/gallium/drivers/softpipe/sp_quad_pipe.c
diff --git a/src/gallium/drivers/softpipe/sp_quad_pipe.h b/src/gallium/drivers/softpipe/sp_quad_pipe.h
new file mode 100644
index 00000000000..0e40586ffc8
--- /dev/null
+++ b/src/gallium/drivers/softpipe/sp_quad_pipe.h
@@ -0,0 +1,74 @@
+/**************************************************************************
+ * 
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ * 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 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
+ * 
+ **************************************************************************/
+
+/* Authors:  Keith Whitwell <[email protected]>
+ */
+
+#ifndef SP_QUAD_PIPE_H
+#define SP_QUAD_PIPE_H
+
+
+struct softpipe_context;
+struct quad_header;
+
+
+/**
+ * Fragment processing is performed on 2x2 blocks of pixels called "quads".
+ * Quad processing is performed with a pipeline of stages represented by
+ * this type.
+ */
+struct quad_stage {
+   struct softpipe_context *softpipe;
+
+   struct quad_stage *next;
+
+   void (*begin)(struct quad_stage *qs);
+
+   /** the stage action */
+   void (*run)(struct quad_stage *qs, struct quad_header *quad);
+
+   void (*destroy)(struct quad_stage *qs);
+};
+
+
+struct quad_stage *sp_quad_polygon_stipple_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_earlyz_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_shade_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_alpha_test_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_stencil_test_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_depth_test_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_occlusion_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_coverage_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_blend_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_colormask_stage( struct softpipe_context *softpipe );
+struct quad_stage *sp_quad_output_stage( struct softpipe_context *softpipe );
+
+void sp_build_quad_pipeline(struct softpipe_context *sp);
+
+void sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad);
+
+#endif /* SP_QUAD_PIPE_H */
diff --git a/src/gallium/drivers/softpipe/sp_quad_stencil.c b/src/gallium/drivers/softpipe/sp_quad_stencil.c
index 7495515764a..5e9d447737d 100644
--- a/src/gallium/drivers/softpipe/sp_quad_stencil.c
+++ b/src/gallium/drivers/softpipe/sp_quad_stencil.c
@@ -5,10 +5,10 @@
 
 
 #include "sp_context.h"
-#include "sp_headers.h"
+#include "sp_quad.h"
 #include "sp_surface.h"
 #include "sp_tile_cache.h"
-#include "sp_quad.h"
+#include "sp_quad_pipe.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 
diff --git a/src/gallium/drivers/softpipe/sp_quad_stipple.c b/src/gallium/drivers/softpipe/sp_quad_stipple.c
index ccf37f6be59..05e862f0977 100644
--- a/src/gallium/drivers/softpipe/sp_quad_stipple.c
+++ b/src/gallium/drivers/softpipe/sp_quad_stipple.c
@@ -4,8 +4,8 @@
  */
 
 #include "sp_context.h"
-#include "sp_headers.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 
@@ -19,11 +19,13 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
    static const uint bit31 = 1 << 31;
    static const uint bit30 = 1 << 30;
 
-   if (quad->input.prim == PRIM_TRI) {
+   if (quad->input.prim == QUAD_PRIM_TRI) {
       struct softpipe_context *softpipe = qs->softpipe;
       /* need to invert Y to index into OpenGL's stipple pattern */
       int y0, y1;
       uint stipple0, stipple1;
+      const int col0 = quad->input.x0 % 32;
+
       if (softpipe->rasterizer->origin_lower_left) {
          y0 = softpipe->framebuffer.height - 1 - quad->input.y0;
          y1 = y0 - 1;
@@ -32,12 +34,11 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
          y0 = quad->input.y0;
          y1 = y0 + 1;
       }
+
       stipple0 = softpipe->poly_stipple.stipple[y0 % 32];
       stipple1 = softpipe->poly_stipple.stipple[y1 % 32];
 
-#if 1
-      {
-      const int col0 = quad->input.x0 % 32;
+      /* turn off quad mask bits that fail the stipple test */
       if ((stipple0 & (bit31 >> col0)) == 0)
          quad->inout.mask &= ~MASK_TOP_LEFT;
 
@@ -49,19 +50,11 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
 
       if ((stipple1 & (bit30 >> col0)) == 0)
          quad->inout.mask &= ~MASK_BOTTOM_RIGHT;
-      }
-#else
-      /* We'd like to use this code, but we'd need to redefine
-       * MASK_TOP_LEFT to be (1 << 1) and MASK_TOP_RIGHT to be (1 << 0),
-       * and similarly for the BOTTOM bits.  But that may have undesirable
-       * side effects elsewhere.
-       */
-      const int col0 = 30 - (quad->input.x0 % 32);
-      quad->inout.mask &= (((stipple0 >> col0) & 0x3) | 
-                     (((stipple1 >> col0) & 0x3) << 2));
-#endif
-      if (!quad->inout.mask)
+
+      if (!quad->inout.mask) {
+         /* all fragments failed stipple test, end of quad pipeline */
          return;
+      }
    }
 
    qs->next->run(qs->next, quad);
diff --git a/src/gallium/drivers/softpipe/sp_query.c b/src/gallium/drivers/softpipe/sp_query.c
index b0d8e01426d..93dab236d66 100644
--- a/src/gallium/drivers/softpipe/sp_query.c
+++ b/src/gallium/drivers/softpipe/sp_query.c
@@ -31,7 +31,6 @@
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_inlines.h"
 #include "util/u_memory.h"
 #include "sp_context.h"
 #include "sp_query.h"
diff --git a/src/gallium/drivers/softpipe/sp_setup.c b/src/gallium/drivers/softpipe/sp_setup.c
index b1adb9cb7a2..0925653b5d5 100644
--- a/src/gallium/drivers/softpipe/sp_setup.c
+++ b/src/gallium/drivers/softpipe/sp_setup.c
@@ -32,13 +32,12 @@
  * \author  Brian Paul
  */
 
-#include "sp_setup.h"
-
 #include "sp_context.h"
-#include "sp_headers.h"
+#include "sp_prim_setup.h"
 #include "sp_quad.h"
+#include "sp_quad_pipe.h"
+#include "sp_setup.h"
 #include "sp_state.h"
-#include "sp_prim_setup.h"
 #include "draw/draw_context.h"
 #include "draw/draw_private.h"
 #include "draw/draw_vertex.h"
@@ -265,17 +264,20 @@ is_inf_or_nan(float x)
 }
 
 
-static boolean cull_tri( struct setup_context *setup,
-		      float det )
+/**
+ * Do triangle cull test using tri determinant (sign indicates orientation)
+ * \return true if triangle is to be culled.
+ */
+static INLINE boolean
+cull_tri(const struct setup_context *setup, float det)
 {
-   if (det != 0) 
-   {   
+   if (det != 0) {   
       /* if (det < 0 then Z points toward camera and triangle is 
        * counter-clockwise winding.
        */
       unsigned winding = (det < 0) ? PIPE_WINDING_CCW : PIPE_WINDING_CW;
-      
-      if ((winding & setup->winding) == 0) 
+
+      if ((winding & setup->winding) == 0)
 	 return FALSE;
    }
 
@@ -968,7 +970,7 @@ void setup_tri( struct setup_context *setup,
    setup_tri_coefficients( setup );
    setup_tri_edges( setup );
 
-   setup->quad.input.prim = PRIM_TRI;
+   setup->quad.input.prim = QUAD_PRIM_TRI;
 
    setup->span.y = 0;
    setup->span.y_flags = 0;
@@ -1009,7 +1011,7 @@ void setup_tri( struct setup_context *setup,
  * for a line.
  */
 static void
-line_linear_coeff(struct setup_context *setup,
+line_linear_coeff(const struct setup_context *setup,
                   struct tgsi_interp_coef *coef,
                   uint vertSlot, uint i)
 {
@@ -1029,9 +1031,9 @@ line_linear_coeff(struct setup_context *setup,
  * for a line.
  */
 static void
-line_persp_coeff(struct setup_context *setup,
-                  struct tgsi_interp_coef *coef,
-                  uint vertSlot, uint i)
+line_persp_coeff(const struct setup_context *setup,
+                 struct tgsi_interp_coef *coef,
+                 uint vertSlot, uint i)
 {
    /* XXX double-check/verify this arithmetic */
    const float a0 = setup->vmin[vertSlot][i] * setup->vmin[0][3];
@@ -1206,7 +1208,7 @@ setup_line(struct setup_context *setup,
 
    setup->quad.input.x0 = setup->quad.input.y0 = -1;
    setup->quad.inout.mask = 0x0;
-   setup->quad.input.prim = PRIM_LINE;
+   setup->quad.input.prim = QUAD_PRIM_LINE;
    /* XXX temporary: set coverage to 1.0 so the line appears
     * if AA mode happens to be enabled.
     */
@@ -1266,7 +1268,7 @@ setup_line(struct setup_context *setup,
 
 
 static void
-point_persp_coeff(struct setup_context *setup,
+point_persp_coeff(const struct setup_context *setup,
                   const float (*vert)[4],
                   struct tgsi_interp_coef *coef,
                   uint vertSlot, uint i)
@@ -1361,7 +1363,7 @@ setup_point( struct setup_context *setup,
       }
    }
 
-   setup->quad.input.prim = PRIM_POINT;
+   setup->quad.input.prim = QUAD_PRIM_POINT;
 
    if (halfSize <= 0.5 && !round) {
       /* special case for 1-pixel points */
diff --git a/src/gallium/drivers/softpipe/sp_state.h b/src/gallium/drivers/softpipe/sp_state.h
index 3eff41ffa5f..9776e978e3e 100644
--- a/src/gallium/drivers/softpipe/sp_state.h
+++ b/src/gallium/drivers/softpipe/sp_state.h
@@ -85,7 +85,7 @@ struct sp_fragment_shader {
 
 /** Subclass of pipe_shader_state */
 struct sp_vertex_shader {
-   struct pipe_shader_state shader;  /* Note: this field not actually used */
+   struct pipe_shader_state shader;
    struct draw_vertex_shader *draw_data;
 };
 
@@ -184,10 +184,10 @@ softpipe_set_edgeflags(struct pipe_context *pipe, const unsigned *edgeflags);
 
 
 void
-softpipe_map_surfaces(struct softpipe_context *sp);
+softpipe_map_transfers(struct softpipe_context *sp);
 
 void
-softpipe_unmap_surfaces(struct softpipe_context *sp);
+softpipe_unmap_transfers(struct softpipe_context *sp);
 
 void
 softpipe_map_texture_surfaces(struct softpipe_context *sp);
diff --git a/src/gallium/drivers/softpipe/sp_state_fs.c b/src/gallium/drivers/softpipe/sp_state_fs.c
index 4d01a9dbe15..4330c203935 100644
--- a/src/gallium/drivers/softpipe/sp_state_fs.c
+++ b/src/gallium/drivers/softpipe/sp_state_fs.c
@@ -31,12 +31,12 @@
 
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
-#include "pipe/p_inlines.h"
 #include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_shader_tokens.h"
 #include "draw/draw_context.h"
 #include "tgsi/tgsi_dump.h"
 #include "tgsi/tgsi_scan.h"
+#include "tgsi/tgsi_parse.h"
 
 
 void *
@@ -98,17 +98,28 @@ softpipe_create_vs_state(struct pipe_context *pipe,
    struct sp_vertex_shader *state;
 
    state = CALLOC_STRUCT(sp_vertex_shader);
-   if (state == NULL ) {
-      return NULL;
-   }
+   if (state == NULL ) 
+      goto fail;
+
+   /* copy shader tokens, the ones passed in will go away.
+    */
+   state->shader.tokens = tgsi_dup_tokens(templ->tokens);
+   if (state->shader.tokens == NULL)
+      goto fail;
 
    state->draw_data = draw_create_vertex_shader(softpipe->draw, templ);
-   if (state->draw_data == NULL) {
-      FREE( state );
-      return NULL;
-   }
+   if (state->draw_data == NULL) 
+      goto fail;
 
    return state;
+
+fail:
+   if (state) {
+      FREE( (void *)state->shader.tokens );
+      FREE( state->draw_data );
+      FREE( state );
+   }
+   return NULL;
 }
 
 
@@ -146,14 +157,12 @@ softpipe_set_constant_buffer(struct pipe_context *pipe,
                              const struct pipe_constant_buffer *buf)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
-   struct pipe_screen *screen = pipe->screen;
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
 
    /* note: reference counting */
-   pipe_buffer_reference(screen,
-			 &softpipe->constants[shader].buffer,
+   pipe_buffer_reference(&softpipe->constants[shader].buffer,
 			 buf ? buf->buffer : NULL);
 
    softpipe->dirty |= SP_NEW_CONSTANTS;
diff --git a/src/gallium/drivers/softpipe/sp_state_sampler.c b/src/gallium/drivers/softpipe/sp_state_sampler.c
index 99a28c0d7e0..cb517b02e44 100644
--- a/src/gallium/drivers/softpipe/sp_state_sampler.c
+++ b/src/gallium/drivers/softpipe/sp_state_sampler.c
@@ -30,7 +30,6 @@
  */
 
 #include "util/u_memory.h"
-#include "pipe/p_inlines.h"
 
 #include "draw/draw_context.h"
 
diff --git a/src/gallium/drivers/softpipe/sp_state_surface.c b/src/gallium/drivers/softpipe/sp_state_surface.c
index 1493c658841..7c06d864a75 100644
--- a/src/gallium/drivers/softpipe/sp_state_surface.c
+++ b/src/gallium/drivers/softpipe/sp_state_surface.c
@@ -27,7 +27,6 @@
 
 /* Authors:  Keith Whitwell <[email protected]>
  */
-#include "pipe/p_inlines.h"
 
 #include "sp_context.h"
 #include "sp_state.h"
diff --git a/src/gallium/drivers/softpipe/sp_surface.c b/src/gallium/drivers/softpipe/sp_surface.c
index 6ade7326982..ef04843f172 100644
--- a/src/gallium/drivers/softpipe/sp_surface.c
+++ b/src/gallium/drivers/softpipe/sp_surface.c
@@ -29,10 +29,21 @@
 #include "sp_context.h"
 
 
+static void
+sp_surface_copy(struct pipe_context *pipe,
+                struct pipe_surface *dest, unsigned destx, unsigned desty,
+                struct pipe_surface *src, unsigned srcx, unsigned srcy,
+                unsigned width, unsigned height)
+{
+   util_surface_copy(pipe, FALSE,
+                     dest, destx, desty,
+                     src, srcx, srcy,
+                     width, height);
+}
 
 void
 sp_init_surface_functions(struct softpipe_context *sp)
 {
-   sp->pipe.surface_copy = util_surface_copy;
+   sp->pipe.surface_copy = sp_surface_copy;
    sp->pipe.surface_fill = util_surface_fill;
 }
diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.c b/src/gallium/drivers/softpipe/sp_tex_sample.c
index 32aa5025e43..adbd0cb7f0c 100644
--- a/src/gallium/drivers/softpipe/sp_tex_sample.c
+++ b/src/gallium/drivers/softpipe/sp_tex_sample.c
@@ -34,7 +34,7 @@
  */
 
 #include "sp_context.h"
-#include "sp_headers.h"
+#include "sp_quad.h"
 #include "sp_surface.h"
 #include "sp_texture.h"
 #include "sp_tex_sample.h"
diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c
index 3eed0d0d293..48b2c22af45 100644
--- a/src/gallium/drivers/softpipe/sp_texture.c
+++ b/src/gallium/drivers/softpipe/sp_texture.c
@@ -59,7 +59,6 @@ static boolean
 softpipe_texture_layout(struct pipe_screen *screen,
                         struct softpipe_texture * spt)
 {
-   struct pipe_winsys *ws = screen->winsys;
    struct pipe_texture *pt = &spt->base;
    unsigned level;
    unsigned width = pt->width[0];
@@ -87,9 +86,9 @@ softpipe_texture_layout(struct pipe_screen *screen,
       depth = minify(depth);
    }
 
-   spt->buffer = ws->buffer_create(ws, 32,
-                                   PIPE_BUFFER_USAGE_PIXEL,
-                                   buffer_size);
+   spt->buffer = screen->buffer_create(screen, 32,
+                                       PIPE_BUFFER_USAGE_PIXEL,
+                                       buffer_size);
 
    return spt->buffer != NULL;
 }
@@ -98,19 +97,18 @@ static boolean
 softpipe_displaytarget_layout(struct pipe_screen *screen,
                               struct softpipe_texture * spt)
 {
-   struct pipe_winsys *ws = screen->winsys;
    unsigned usage = (PIPE_BUFFER_USAGE_CPU_READ_WRITE |
                      PIPE_BUFFER_USAGE_GPU_READ_WRITE);
 
    spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);  
    spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);  
 
-   spt->buffer = ws->surface_buffer_create( ws, 
-                                            spt->base.width[0], 
-                                            spt->base.height[0],
-                                            spt->base.format,
-                                            usage,
-                                            &spt->stride[0]);
+   spt->buffer = screen->surface_buffer_create( screen, 
+                                                spt->base.width[0], 
+                                                spt->base.height[0],
+                                                spt->base.format,
+                                                usage,
+                                                &spt->stride[0]);
 
    return spt->buffer != NULL;
 }
@@ -128,7 +126,7 @@ softpipe_texture_create(struct pipe_screen *screen,
       return NULL;
 
    spt->base = *templat;
-   spt->base.refcount = 1;
+   pipe_reference_init(&spt->base.reference, 1);
    spt->base.screen = screen;
 
    if (spt->base.tex_usage & PIPE_TEXTURE_USAGE_DISPLAY_TARGET) {
@@ -140,7 +138,7 @@ softpipe_texture_create(struct pipe_screen *screen,
          goto fail;
    }
     
-   assert(spt->base.refcount == 1);
+   assert(p_atomic_read(&spt->base.reference.count) == 1);
    return &spt->base;
 
  fail:
@@ -170,32 +168,25 @@ softpipe_texture_blanket(struct pipe_screen * screen,
       return NULL;
 
    spt->base = *base;
-   spt->base.refcount = 1;
+   pipe_reference_init(&spt->base.reference, 1);
    spt->base.screen = screen;
    spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);  
    spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);  
    spt->stride[0] = stride[0];
 
-   pipe_buffer_reference(screen, &spt->buffer, buffer);
+   pipe_buffer_reference(&spt->buffer, buffer);
 
    return &spt->base;
 }
 
 
 static void
-softpipe_texture_release(struct pipe_screen *screen,
-                         struct pipe_texture **pt)
+softpipe_texture_destroy(struct pipe_texture *pt)
 {
-   if (!*pt)
-      return;
-
-   if (--(*pt)->refcount <= 0) {
-      struct softpipe_texture *spt = softpipe_texture(*pt);
+   struct softpipe_texture *spt = softpipe_texture(pt);
 
-      pipe_buffer_reference(screen, &spt->buffer, NULL);
-      FREE(spt);
-   }
-   *pt = NULL;
+   pipe_buffer_reference(&spt->buffer, NULL);
+   FREE(spt);
 }
 
 
@@ -212,15 +203,11 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
 
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
-      ps->refcount = 1;
+      pipe_reference_init(&ps->reference, 1);
       pipe_texture_reference(&ps->texture, pt);
       ps->format = pt->format;
-      ps->block = pt->block;
       ps->width = pt->width[level];
       ps->height = pt->height[level];
-      ps->nblocksx = pt->nblocksx[level];
-      ps->nblocksy = pt->nblocksy[level];
-      ps->stride = spt->stride[level];
       ps->offset = spt->level_offset[level];
       ps->usage = usage;
 
@@ -247,10 +234,11 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
       ps->level = level;
       ps->zslice = zslice;
 
-      if (pt->target == PIPE_TEXTURE_CUBE || pt->target == PIPE_TEXTURE_3D) {
-         ps->offset += ((pt->target == PIPE_TEXTURE_CUBE) ? face : zslice) *
-            ps->nblocksy *
-            ps->stride;
+      if (pt->target == PIPE_TEXTURE_CUBE) {
+         ps->offset += face * pt->nblocksy[level] * spt->stride[level];
+      }
+      else if (pt->target == PIPE_TEXTURE_3D) {
+         ps->offset += zslice * pt->nblocksy[level] * spt->stride[level];
       }
       else {
          assert(face == 0);
@@ -262,38 +250,99 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
 
 
 static void 
-softpipe_tex_surface_release(struct pipe_screen *screen, 
-                             struct pipe_surface **s)
+softpipe_tex_surface_destroy(struct pipe_surface *surf)
 {
-   struct pipe_surface *surf = *s;
    /* Effectively do the texture_update work here - if texture images
     * needed post-processing to put them into hardware layout, this is
     * where it would happen.  For softpipe, nothing to do.
     */
    assert(surf->texture);
-   if (--surf->refcount == 0) {
-      pipe_texture_reference(&surf->texture, NULL);
-      FREE(surf);
+   pipe_texture_reference(&surf->texture, NULL);
+   FREE(surf);
+}
+
+
+static struct pipe_transfer *
+softpipe_get_tex_transfer(struct pipe_screen *screen,
+                          struct pipe_texture *texture,
+                          unsigned face, unsigned level, unsigned zslice,
+                          enum pipe_transfer_usage usage,
+                          unsigned x, unsigned y, unsigned w, unsigned h)
+{
+   struct softpipe_texture *sptex = softpipe_texture(texture);
+   struct softpipe_transfer *spt;
+
+   assert(texture);
+   assert(level <= texture->last_level);
+
+   spt = CALLOC_STRUCT(softpipe_transfer);
+   if (spt) {
+      struct pipe_transfer *pt = &spt->base;
+      pipe_texture_reference(&pt->texture, texture);
+      pt->format = texture->format;
+      pt->block = texture->block;
+      pt->x = x;
+      pt->y = y;
+      pt->width = w;
+      pt->height = h;
+      pt->nblocksx = texture->nblocksx[level];
+      pt->nblocksy = texture->nblocksy[level];
+      pt->stride = sptex->stride[level];
+      pt->usage = usage;
+      pt->face = face;
+      pt->level = level;
+      pt->zslice = zslice;
+
+      spt->offset = sptex->level_offset[level];
+
+      if (texture->target == PIPE_TEXTURE_CUBE) {
+         spt->offset += face * pt->nblocksy * pt->stride;
+      }
+      else if (texture->target == PIPE_TEXTURE_3D) {
+         spt->offset += zslice * pt->nblocksy * pt->stride;
+      }
+      else {
+         assert(face == 0);
+         assert(zslice == 0);
+      }
+      return pt;
    }
-   *s = NULL;
+   return NULL;
+}
+
+
+static void 
+softpipe_tex_transfer_destroy(struct pipe_transfer *transfer)
+{
+   /* Effectively do the texture_update work here - if texture images
+    * needed post-processing to put them into hardware layout, this is
+    * where it would happen.  For softpipe, nothing to do.
+    */
+   assert (transfer->texture);
+   pipe_texture_reference(&transfer->texture, NULL);
+   FREE(transfer);
 }
 
 
 static void *
-softpipe_surface_map( struct pipe_screen *screen,
-                      struct pipe_surface *surface,
-                      unsigned flags )
+softpipe_transfer_map( struct pipe_screen *screen,
+                       struct pipe_transfer *transfer )
 {
    ubyte *map;
    struct softpipe_texture *spt;
+   unsigned flags = 0;
 
-   if (flags & ~surface->usage) {
-      assert(0);
-      return NULL;
+   assert(transfer->texture);
+   spt = softpipe_texture(transfer->texture);
+
+   if (transfer->usage != PIPE_TRANSFER_READ) {
+      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+   }
+
+   if (transfer->usage != PIPE_TRANSFER_WRITE) {
+      flags |= PIPE_BUFFER_USAGE_CPU_READ;
    }
 
-   assert(surface->texture);
-   spt = softpipe_texture(surface->texture);
    map = pipe_buffer_map(screen, spt->buffer, flags);
    if (map == NULL)
       return NULL;
@@ -301,8 +350,7 @@ softpipe_surface_map( struct pipe_screen *screen,
    /* May want to different things here depending on read/write nature
     * of the map:
     */
-   if (surface->texture &&
-       (flags & PIPE_BUFFER_USAGE_CPU_WRITE)) 
+   if (transfer->texture && transfer->usage != PIPE_TRANSFER_READ) 
    {
       /* Do something to notify sharing contexts of a texture change.
        * In softpipe, that would mean flushing the texture cache.
@@ -310,18 +358,20 @@ softpipe_surface_map( struct pipe_screen *screen,
       softpipe_screen(screen)->timestamp++;
    }
    
-   return map + surface->offset;
+   return map + softpipe_transfer(transfer)->offset +
+      transfer->y / transfer->block.height * transfer->stride +
+      transfer->x / transfer->block.width * transfer->block.size;
 }
 
 
 static void
-softpipe_surface_unmap(struct pipe_screen *screen,
-                       struct pipe_surface *surface)
+softpipe_transfer_unmap(struct pipe_screen *screen,
+                       struct pipe_transfer *transfer)
 {
    struct softpipe_texture *spt;
 
-   assert(surface->texture);
-   spt = softpipe_texture(surface->texture);
+   assert(transfer->texture);
+   spt = softpipe_texture(transfer->texture);
 
    pipe_buffer_unmap( screen, spt->buffer );
 }
@@ -338,11 +388,13 @@ softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
 {
    screen->texture_create = softpipe_texture_create;
    screen->texture_blanket = softpipe_texture_blanket;
-   screen->texture_release = softpipe_texture_release;
+   screen->texture_destroy = softpipe_texture_destroy;
 
    screen->get_tex_surface = softpipe_get_tex_surface;
-   screen->tex_surface_release = softpipe_tex_surface_release;
+   screen->tex_surface_destroy = softpipe_tex_surface_destroy;
 
-   screen->surface_map = softpipe_surface_map;
-   screen->surface_unmap = softpipe_surface_unmap;
+   screen->get_tex_transfer = softpipe_get_tex_transfer;
+   screen->tex_transfer_destroy = softpipe_tex_transfer_destroy;
+   screen->transfer_map = softpipe_transfer_map;
+   screen->transfer_unmap = softpipe_transfer_unmap;
 }
diff --git a/src/gallium/drivers/softpipe/sp_texture.h b/src/gallium/drivers/softpipe/sp_texture.h
index c1636920cd6..893aa7d11d8 100644
--- a/src/gallium/drivers/softpipe/sp_texture.h
+++ b/src/gallium/drivers/softpipe/sp_texture.h
@@ -51,14 +51,27 @@ struct softpipe_texture
    boolean modified;
 };
 
+struct softpipe_transfer
+{
+   struct pipe_transfer base;
+
+   unsigned long offset;
+};
+
 
-/** cast wrapper */
+/** cast wrappers */
 static INLINE struct softpipe_texture *
 softpipe_texture(struct pipe_texture *pt)
 {
    return (struct softpipe_texture *) pt;
 }
 
+static INLINE struct softpipe_transfer *
+softpipe_transfer(struct pipe_transfer *pt)
+{
+   return (struct softpipe_transfer *) pt;
+}
+
 
 extern void
 softpipe_init_texture_funcs( struct softpipe_context *softpipe );
diff --git a/src/gallium/drivers/softpipe/sp_tile_cache.c b/src/gallium/drivers/softpipe/sp_tile_cache.c
index ab76009375c..69292753f13 100644
--- a/src/gallium/drivers/softpipe/sp_tile_cache.c
+++ b/src/gallium/drivers/softpipe/sp_tile_cache.c
@@ -26,7 +26,7 @@
  **************************************************************************/
 
 /**
- * Framebuffer/surface tile caching.
+ * Texture tile caching.
  *
  * Author:
  *    Brian Paul
@@ -40,7 +40,7 @@
 #include "sp_texture.h"
 #include "sp_tile_cache.h"
 
-#define NUM_ENTRIES 32
+#define NUM_ENTRIES 50
 
 
 /** XXX move these */
@@ -52,7 +52,8 @@ struct softpipe_tile_cache
 {
    struct pipe_screen *screen;
    struct pipe_surface *surface;  /**< the surface we're caching */
-   void *surface_map;
+   struct pipe_transfer *transfer;
+   void *transfer_map;
    struct pipe_texture *texture;  /**< if caching a texture */
    struct softpipe_cached_tile entries[NUM_ENTRIES];
    uint clear_flags[(MAX_WIDTH / TILE_SIZE) * (MAX_HEIGHT / TILE_SIZE) / 32];
@@ -60,8 +61,8 @@ struct softpipe_tile_cache
    uint clear_val;
    boolean depth_stencil; /** Is the surface a depth/stencil format? */
 
-   struct pipe_surface *tex_surf;
-   void *tex_surf_map;
+   struct pipe_transfer *tex_trans;
+   void *tex_trans_map;
    int tex_face, tex_level, tex_z;
 
    struct softpipe_cached_tile tile;  /**< scratch tile for clears */
@@ -131,16 +132,19 @@ sp_create_tile_cache( struct pipe_screen *screen )
 void
 sp_destroy_tile_cache(struct softpipe_tile_cache *tc)
 {
+   struct pipe_screen *screen;
    uint pos;
 
    for (pos = 0; pos < NUM_ENTRIES; pos++) {
       /*assert(tc->entries[pos].x < 0);*/
    }
-   if (tc->surface) {
-      pipe_surface_reference(&tc->surface, NULL);
+   if (tc->transfer) {
+      screen = tc->transfer->texture->screen;
+      screen->tex_transfer_destroy(tc->transfer);
    }
-   if (tc->tex_surf) {
-      pipe_surface_reference(&tc->tex_surf, NULL);
+   if (tc->tex_trans) {
+      screen = tc->tex_trans->texture->screen;
+      screen->tex_transfer_destroy(tc->tex_trans);
    }
 
    FREE( tc );
@@ -156,18 +160,30 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
 {
    assert(!tc->texture);
 
-   if (tc->surface_map) {
-      tc->screen->surface_unmap(tc->screen, tc->surface);
-      tc->surface_map = NULL;
+   if (tc->transfer) {
+      struct pipe_screen *screen = tc->transfer->texture->screen;
+
+      if (ps == tc->surface)
+         return;
+
+      if (tc->transfer_map) {
+         screen->transfer_unmap(screen, tc->transfer);
+         tc->transfer_map = NULL;
+      }
+
+      screen->tex_transfer_destroy(tc->transfer);
+      tc->transfer = NULL;
    }
 
-   pipe_surface_reference(&tc->surface, ps);
+   tc->surface = ps;
 
-   if (tc->surface) {
-      if (tc->surface_map) /* XXX: this is always NULL!? */
-	 tc->surface_map = tc->screen->surface_map(tc->screen, tc->surface,
-                                                   PIPE_BUFFER_USAGE_CPU_READ | 
-                                                   PIPE_BUFFER_USAGE_CPU_WRITE);
+   if (ps) {
+      struct pipe_screen *screen = ps->texture->screen;
+
+      tc->transfer = screen->get_tex_transfer(screen, ps->texture, ps->face,
+                                              ps->level, ps->zslice,
+                                              PIPE_TRANSFER_READ_WRITE,
+                                              0, 0, ps->width, ps->height);
 
       tc->depth_stencil = (ps->format == PIPE_FORMAT_S8Z24_UNORM ||
                            ps->format == PIPE_FORMAT_X8Z24_UNORM ||
@@ -181,7 +197,7 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
 
 
 /**
- * Return the surface being cached.
+ * Return the transfer being cached.
  */
 struct pipe_surface *
 sp_tile_cache_get_surface(struct softpipe_tile_cache *tc)
@@ -191,30 +207,27 @@ sp_tile_cache_get_surface(struct softpipe_tile_cache *tc)
 
 
 void
-sp_tile_cache_map_surfaces(struct softpipe_tile_cache *tc)
+sp_tile_cache_map_transfers(struct softpipe_tile_cache *tc)
 {
-   if (tc->surface && !tc->surface_map)
-      tc->surface_map = tc->screen->surface_map(tc->screen, tc->surface,
-                                                PIPE_BUFFER_USAGE_CPU_WRITE |
-                                                PIPE_BUFFER_USAGE_CPU_READ);
-
-   if (tc->tex_surf && !tc->tex_surf_map)
-      tc->tex_surf_map = tc->screen->surface_map(tc->screen, tc->tex_surf,
-                                                 PIPE_BUFFER_USAGE_CPU_READ);
+   if (tc->transfer && !tc->transfer_map)
+      tc->transfer_map = tc->screen->transfer_map(tc->screen, tc->transfer);
+
+   if (tc->tex_trans && !tc->tex_trans_map)
+      tc->tex_trans_map = tc->screen->transfer_map(tc->screen, tc->tex_trans);
 }
 
 
 void
-sp_tile_cache_unmap_surfaces(struct softpipe_tile_cache *tc)
+sp_tile_cache_unmap_transfers(struct softpipe_tile_cache *tc)
 {
-   if (tc->surface_map) {
-      tc->screen->surface_unmap(tc->screen, tc->surface);
-      tc->surface_map = NULL;
+   if (tc->transfer_map) {
+      tc->screen->transfer_unmap(tc->screen, tc->transfer);
+      tc->transfer_map = NULL;
    }
 
-   if (tc->tex_surf_map) {
-      tc->screen->surface_unmap(tc->screen, tc->tex_surf);
-      tc->tex_surf_map = NULL;
+   if (tc->tex_trans_map) {
+      tc->screen->transfer_unmap(tc->screen, tc->tex_trans);
+      tc->tex_trans_map = NULL;
    }
 }
 
@@ -229,15 +242,21 @@ sp_tile_cache_set_texture(struct pipe_context *pipe,
 {
    uint i;
 
-   assert(!tc->surface);
+   assert(!tc->transfer);
 
    pipe_texture_reference(&tc->texture, texture);
 
-   if (tc->tex_surf_map) {
-      tc->screen->surface_unmap(tc->screen, tc->tex_surf);
-      tc->tex_surf_map = NULL;
+   if (tc->tex_trans) {
+      struct pipe_screen *screen = tc->tex_trans->texture->screen;
+
+      if (tc->tex_trans_map) {
+         screen->transfer_unmap(screen, tc->tex_trans);
+         tc->tex_trans_map = NULL;
+      }
+
+      screen->tex_transfer_destroy(tc->tex_trans);
+      tc->tex_trans = NULL;
    }
-   pipe_surface_reference(&tc->tex_surf, NULL);
 
    /* mark as entries as invalid/empty */
    /* XXX we should try to avoid this when the teximage hasn't changed */
@@ -328,20 +347,20 @@ static void
 sp_tile_cache_flush_clear(struct pipe_context *pipe,
                           struct softpipe_tile_cache *tc)
 {
-   struct pipe_surface *ps = tc->surface;
-   const uint w = tc->surface->width;
-   const uint h = tc->surface->height;
+   struct pipe_transfer *pt = tc->transfer;
+   const uint w = tc->transfer->width;
+   const uint h = tc->transfer->height;
    uint x, y;
    uint numCleared = 0;
 
    /* clear the scratch tile to the clear value */
-   clear_tile(&tc->tile, ps->format, tc->clear_val);
+   clear_tile(&tc->tile, pt->format, tc->clear_val);
 
    /* push the tile to all positions marked as clear */
    for (y = 0; y < h; y += TILE_SIZE) {
       for (x = 0; x < w; x += TILE_SIZE) {
          if (is_clear_flag_set(tc->clear_flags, x, y)) {
-            pipe_put_tile_raw(ps,
+            pipe_put_tile_raw(pt,
                               x, y, TILE_SIZE, TILE_SIZE,
                               tc->tile.data.color32, 0/*STRIDE*/);
 
@@ -359,28 +378,28 @@ sp_tile_cache_flush_clear(struct pipe_context *pipe,
 
 
 /**
- * Flush the tile cache: write all dirty tiles back to the surface.
+ * Flush the tile cache: write all dirty tiles back to the transfer.
  * any tiles "flagged" as cleared will be "really" cleared.
  */
 void
 sp_flush_tile_cache(struct softpipe_context *softpipe,
                     struct softpipe_tile_cache *tc)
 {
-   struct pipe_surface *ps = tc->surface;
+   struct pipe_transfer *pt = tc->transfer;
    int inuse = 0, pos;
 
-   if (ps) {
-      /* caching a drawing surface */
+   if (pt) {
+      /* caching a drawing transfer */
       for (pos = 0; pos < NUM_ENTRIES; pos++) {
          struct softpipe_cached_tile *tile = tc->entries + pos;
          if (tile->x >= 0) {
             if (tc->depth_stencil) {
-               pipe_put_tile_raw(ps,
+               pipe_put_tile_raw(pt,
                                  tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                  tile->data.depth32, 0/*STRIDE*/);
             }
             else {
-               pipe_put_tile_rgba(ps,
+               pipe_put_tile_rgba(pt,
                                   tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                   (float *) tile->data.color);
             }
@@ -415,7 +434,7 @@ struct softpipe_cached_tile *
 sp_get_cached_tile(struct softpipe_context *softpipe,
                    struct softpipe_tile_cache *tc, int x, int y)
 {
-   struct pipe_surface *ps = tc->surface;
+   struct pipe_transfer *pt = tc->transfer;
 
    /* tile pos in framebuffer: */
    const int tile_x = x & ~(TILE_SIZE - 1);
@@ -431,12 +450,12 @@ sp_get_cached_tile(struct softpipe_context *softpipe,
       if (tile->x != -1) {
          /* put dirty tile back in framebuffer */
          if (tc->depth_stencil) {
-            pipe_put_tile_raw(ps,
+            pipe_put_tile_raw(pt,
                               tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                               tile->data.depth32, 0/*STRIDE*/);
          }
          else {
-            pipe_put_tile_rgba(ps,
+            pipe_put_tile_rgba(pt,
                                tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                (float *) tile->data.color);
          }
@@ -448,22 +467,22 @@ sp_get_cached_tile(struct softpipe_context *softpipe,
       if (is_clear_flag_set(tc->clear_flags, x, y)) {
          /* don't get tile from framebuffer, just clear it */
          if (tc->depth_stencil) {
-            clear_tile(tile, ps->format, tc->clear_val);
+            clear_tile(tile, pt->format, tc->clear_val);
          }
          else {
-            clear_tile_rgba(tile, ps->format, tc->clear_color);
+            clear_tile_rgba(tile, pt->format, tc->clear_color);
          }
          clear_clear_flag(tc->clear_flags, x, y);
       }
       else {
-         /* get new tile data from surface */
+         /* get new tile data from transfer */
          if (tc->depth_stencil) {
-            pipe_get_tile_raw(ps,
+            pipe_get_tile_raw(pt,
                               tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                               tile->data.depth32, 0/*STRIDE*/);
          }
          else {
-            pipe_get_tile_rgba(ps,
+            pipe_get_tile_rgba(pt,
                                tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                (float *) tile->data.color);
          }
@@ -484,7 +503,7 @@ sp_get_cached_tile(struct softpipe_context *softpipe,
 static INLINE uint
 tex_cache_pos(int x, int y, int z, int face, int level)
 {
-   uint entry = x + y * 5 + z * 4 + face + level;
+   uint entry = x + y * 9 + z * 3 + face + level * 7;
    return entry % NUM_ENTRIES;
 }
 
@@ -510,8 +529,12 @@ sp_get_cached_tile_tex(struct softpipe_context *sp,
    if (tc->texture) {
       struct softpipe_texture *spt = softpipe_texture(tc->texture);
       if (spt->modified) {
-         /* texture was modified, force a cache reload */
-         tile->x = -1;
+         /* texture was modified, invalidate all cached tiles */
+         uint p;
+         for (p = 0; p < NUM_ENTRIES; p++) {
+            tile = tc->entries + p;
+            tile->x = -1;
+         }
          spt->modified = FALSE;
       }
    }
@@ -523,28 +546,40 @@ sp_get_cached_tile_tex(struct softpipe_context *sp,
        level != tile->level) {
       /* cache miss */
 
-      /* check if we need to get a new surface */
-      if (!tc->tex_surf ||
+#if 0
+      printf("miss at %u  x=%d y=%d z=%d face=%d level=%d\n", pos,
+             x/TILE_SIZE, y/TILE_SIZE, z, face, level);
+#endif
+      /* check if we need to get a new transfer */
+      if (!tc->tex_trans ||
           tc->tex_face != face ||
           tc->tex_level != level ||
           tc->tex_z != z) {
-         /* get new surface (view into texture) */
+         /* get new transfer (view into texture) */
+
+         if (tc->tex_trans) {
+            if (tc->tex_trans_map) {
+               tc->screen->transfer_unmap(tc->screen, tc->tex_trans);
+               tc->tex_trans_map = NULL;
+            }
 
-	 if (tc->tex_surf_map)
-            tc->screen->surface_unmap(tc->screen, tc->tex_surf);
+            screen->tex_transfer_destroy(tc->tex_trans);
+            tc->tex_trans = NULL;
+         }
 
-         tc->tex_surf = screen->get_tex_surface(screen, tc->texture, face, level, z, 
-                                                PIPE_BUFFER_USAGE_CPU_READ);
-         tc->tex_surf_map = screen->surface_map(screen, tc->tex_surf,
-                                                PIPE_BUFFER_USAGE_CPU_READ);
+         tc->tex_trans = screen->get_tex_transfer(screen, tc->texture, face, level, z, 
+                                                  PIPE_TRANSFER_READ, 0, 0,
+                                                  tc->texture->width[level],
+                                                  tc->texture->height[level]);
+         tc->tex_trans_map = screen->transfer_map(screen, tc->tex_trans);
 
          tc->tex_face = face;
          tc->tex_level = level;
          tc->tex_z = z;
       }
 
-      /* get tile from the surface (view into texture) */
-      pipe_get_tile_rgba(tc->tex_surf,
+      /* get tile from the transfer (view into texture) */
+      pipe_get_tile_rgba(tc->tex_trans,
                          tile_x, tile_y, TILE_SIZE, TILE_SIZE,
                          (float *) tile->data.color);
       tile->x = tile_x;
@@ -571,7 +606,7 @@ sp_tile_cache_clear(struct softpipe_tile_cache *tc, uint clearValue)
 
    tc->clear_val = clearValue;
 
-   switch (tc->surface->format) {
+   switch (tc->transfer->format) {
    case PIPE_FORMAT_R8G8B8A8_UNORM:
       r = (clearValue >> 24) & 0xff;
       g = (clearValue >> 16) & 0xff;
diff --git a/src/gallium/drivers/softpipe/sp_tile_cache.h b/src/gallium/drivers/softpipe/sp_tile_cache.h
index a66bb50bcc1..9ac3fdda948 100644
--- a/src/gallium/drivers/softpipe/sp_tile_cache.h
+++ b/src/gallium/drivers/softpipe/sp_tile_cache.h
@@ -74,10 +74,10 @@ extern struct pipe_surface *
 sp_tile_cache_get_surface(struct softpipe_tile_cache *tc);
 
 extern void
-sp_tile_cache_map_surfaces(struct softpipe_tile_cache *tc);
+sp_tile_cache_map_transfers(struct softpipe_tile_cache *tc);
 
 extern void
-sp_tile_cache_unmap_surfaces(struct softpipe_tile_cache *tc);
+sp_tile_cache_unmap_transfers(struct softpipe_tile_cache *tc);
 
 extern void
 sp_tile_cache_set_texture(struct pipe_context *pipe,
diff --git a/src/gallium/drivers/trace/Makefile b/src/gallium/drivers/trace/Makefile
index 3859b8acb06..e087db169aa 100644
--- a/src/gallium/drivers/trace/Makefile
+++ b/src/gallium/drivers/trace/Makefile
@@ -4,15 +4,11 @@ include $(TOP)/configs/current
 LIBNAME = trace
 
 C_SOURCES = \
+	tr_buffer.c \
 	tr_context.c \
 	tr_dump.c \
 	tr_screen.c \
 	tr_state.c \
-	tr_texture.c \
-	tr_winsys.c 
-
+	tr_texture.c
 
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/drivers/trace/SConscript b/src/gallium/drivers/trace/SConscript
index 0a6bfb8f4c7..4215215d1a1 100644
--- a/src/gallium/drivers/trace/SConscript
+++ b/src/gallium/drivers/trace/SConscript
@@ -5,12 +5,12 @@ env = env.Clone()
 trace = env.ConvenienceLibrary(
     target = 'trace',
     source = [
+        'tr_buffer.c',
         'tr_context.c',
         'tr_dump.c',
         'tr_screen.c',
         'tr_state.c',
         'tr_texture.c',
-        'tr_winsys.c',
     ])
 
-Export('trace')
\ No newline at end of file
+Export('trace')
diff --git a/src/gallium/drivers/trace/tr_buffer.c b/src/gallium/drivers/trace/tr_buffer.c
new file mode 100644
index 00000000000..6ffce1660ec
--- /dev/null
+++ b/src/gallium/drivers/trace/tr_buffer.c
@@ -0,0 +1,70 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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 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 TUNGSTEN GRAPHICS AND/OR ITS 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 "util/u_memory.h"
+
+#include "tr_buffer.h"
+
+
+struct pipe_buffer *
+trace_buffer_create(struct trace_screen *tr_scr,
+                    struct pipe_buffer *buffer)
+{
+   struct trace_buffer *tr_buf;
+
+   if(!buffer)
+      goto error;
+
+   assert(buffer->screen == tr_scr->screen);
+
+   tr_buf = CALLOC_STRUCT(trace_buffer);
+   if(!tr_buf)
+      goto error;
+
+   memcpy(&tr_buf->base, buffer, sizeof(struct pipe_buffer));
+
+   pipe_reference_init(&tr_buf->base.reference, 1);
+   tr_buf->base.screen = &tr_scr->base;
+   tr_buf->buffer = buffer;
+
+   return &tr_buf->base;
+
+error:
+   pipe_buffer_reference(&buffer, NULL);
+   return NULL;
+}
+
+
+void
+trace_buffer_destroy(struct trace_screen *tr_scr,
+                     struct pipe_buffer *buffer)
+{
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, buffer);
+   pipe_buffer_reference(&tr_buf->buffer, NULL);
+   FREE(tr_buf);
+}
diff --git a/src/gallium/drivers/trace/tr_winsys.h b/src/gallium/drivers/trace/tr_buffer.h
index 0fd2a405569..e9e4d354dad 100644
--- a/src/gallium/drivers/trace/tr_winsys.h
+++ b/src/gallium/drivers/trace/tr_buffer.h
@@ -1,6 +1,6 @@
 /**************************************************************************
  *
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2009 VMware, Inc.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -25,52 +25,46 @@
  *
  **************************************************************************/
 
-#ifndef TR_WINSYS_H_
-#define TR_WINSYS_H_
+#ifndef TR_BUFFER_H_
+#define TR_BUFFER_H_
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
-#include "pipe/internal/p_winsys_screen.h"
+#include "pipe/p_state.h"
 
+#include "tr_screen.h"
 
-/**
- * It often happens that new data is written directly to the user buffers 
- * without mapping/unmapping. This flag marks user buffers, so that their 
- * contents can be dumpped before being used by the pipe context.
- */
-#define TRACE_BUFFER_USAGE_USER  (1 << 31)
 
+struct trace_buffer
+{
+   struct pipe_buffer base;
 
-struct hash_table;
-
+   struct pipe_buffer *buffer;
 
-struct trace_winsys
-{
-   struct pipe_winsys base;
-   
-   struct pipe_winsys *winsys;
-   
-   struct hash_table *buffer_maps;
+   void *map;
+   boolean range_flushed;
 };
 
 
-static INLINE struct trace_winsys *
-trace_winsys(struct pipe_winsys *winsys)
+static INLINE struct trace_buffer *
+trace_buffer(struct trace_screen *tr_scr,
+             struct pipe_buffer *buffer)
 {
-   assert(winsys);
-   return (struct trace_winsys *)winsys;
+   if(!buffer)
+      return NULL;
+   assert(tr_scr);
+   assert(buffer->screen == &tr_scr->base);
+   return (struct trace_buffer *)buffer;
 }
 
 
-
-struct pipe_winsys *
-trace_winsys_create(struct pipe_winsys *winsys);
-
+struct pipe_buffer *
+trace_buffer_create(struct trace_screen *tr_scr,
+                    struct pipe_buffer *buffer);
 
 void
-trace_winsys_user_buffer_update(struct pipe_winsys *winsys, 
-                                struct pipe_buffer *buffer);
+trace_buffer_destroy(struct trace_screen *tr_scr,
+                     struct pipe_buffer *buffer);
 
 
-#endif /* TR_WINSYS_H_ */
+#endif
diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c
index ec8be27077f..c8949729047 100644
--- a/src/gallium/drivers/trace/tr_context.c
+++ b/src/gallium/drivers/trace/tr_context.c
@@ -30,48 +30,66 @@
 
 #include "tr_dump.h"
 #include "tr_state.h"
+#include "tr_buffer.h"
 #include "tr_screen.h"
 #include "tr_texture.h"
-#include "tr_winsys.h"
 #include "tr_context.h"
 
 
-static INLINE struct pipe_texture * 
+static INLINE struct pipe_buffer *
+trace_buffer_unwrap(struct trace_context *tr_ctx,
+                     struct pipe_buffer *buffer)
+{
+   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
+   struct trace_buffer *tr_buf;
+
+   if(!buffer)
+      return NULL;
+
+   tr_buf = trace_buffer(tr_scr, buffer);
+
+   assert(tr_buf->buffer);
+   assert(tr_buf->buffer->screen == tr_scr->screen);
+   return tr_buf->buffer;
+}
+
+
+static INLINE struct pipe_texture *
 trace_texture_unwrap(struct trace_context *tr_ctx,
                      struct pipe_texture *texture)
 {
-   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen); 
+   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
    struct trace_texture *tr_tex;
-   
+
    if(!texture)
       return NULL;
-   
+
    tr_tex = trace_texture(tr_scr, texture);
-   
+
    assert(tr_tex->texture);
    assert(tr_tex->texture->screen == tr_scr->screen);
    return tr_tex->texture;
 }
 
 
-static INLINE struct pipe_surface * 
+static INLINE struct pipe_surface *
 trace_surface_unwrap(struct trace_context *tr_ctx,
                      struct pipe_surface *surface)
 {
-   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen); 
+   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
    struct trace_texture *tr_tex;
    struct trace_surface *tr_surf;
-   
+
    if(!surface)
       return NULL;
 
    assert(surface->texture);
    if(!surface->texture)
       return surface;
-   
+
    tr_tex = trace_texture(tr_scr, surface->texture);
    tr_surf = trace_surface(tr_tex, surface);
-   
+
    assert(tr_surf->surface);
    assert(tr_surf->surface->texture->screen == tr_scr->screen);
    return tr_surf->surface;
@@ -86,7 +104,7 @@ trace_context_set_edgeflags(struct pipe_context *_pipe,
    struct pipe_context *pipe = tr_ctx->pipe;
 
    trace_dump_call_begin("pipe_context", "set_edgeflags");
-   
+
    trace_dump_arg(ptr, pipe);
    /* FIXME: we don't know how big this array is */
    trace_dump_arg(ptr, bitfield);
@@ -115,24 +133,27 @@ trace_context_draw_arrays(struct pipe_context *_pipe,
    result = pipe->draw_arrays(pipe, mode, start, count);;
 
    trace_dump_ret(bool, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE boolean
 trace_context_draw_elements(struct pipe_context *_pipe,
-                          struct pipe_buffer *indexBuffer,
+                          struct pipe_buffer *_indexBuffer,
                           unsigned indexSize,
                           unsigned mode, unsigned start, unsigned count)
 {
+   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
    struct trace_context *tr_ctx = trace_context(_pipe);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _indexBuffer);
    struct pipe_context *pipe = tr_ctx->pipe;
+   struct pipe_buffer *indexBuffer = tr_buf->buffer;
    boolean result;
 
-   trace_winsys_user_buffer_update(_pipe->winsys, indexBuffer);
+   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
 
    trace_dump_call_begin("pipe_context", "draw_elements");
 
@@ -146,28 +167,31 @@ trace_context_draw_elements(struct pipe_context *_pipe,
    result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);;
 
    trace_dump_ret(bool, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE boolean
 trace_context_draw_range_elements(struct pipe_context *_pipe,
-                                  struct pipe_buffer *indexBuffer,
+                                  struct pipe_buffer *_indexBuffer,
                                   unsigned indexSize,
                                   unsigned minIndex,
                                   unsigned maxIndex,
-                                  unsigned mode, 
-                                  unsigned start, 
+                                  unsigned mode,
+                                  unsigned start,
                                   unsigned count)
 {
+   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
    struct trace_context *tr_ctx = trace_context(_pipe);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _indexBuffer);
    struct pipe_context *pipe = tr_ctx->pipe;
+   struct pipe_buffer *indexBuffer = tr_buf->buffer;
    boolean result;
 
-   trace_winsys_user_buffer_update(_pipe->winsys, indexBuffer);
+   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
 
    trace_dump_call_begin("pipe_context", "draw_range_elements");
 
@@ -180,15 +204,15 @@ trace_context_draw_range_elements(struct pipe_context *_pipe,
    trace_dump_arg(uint, start);
    trace_dump_arg(uint, count);
 
-   result = pipe->draw_range_elements(pipe, 
-                                      indexBuffer, 
-                                      indexSize, minIndex, maxIndex, 
+   result = pipe->draw_range_elements(pipe,
+                                      indexBuffer,
+                                      indexSize, minIndex, maxIndex,
                                       mode, start, count);
-   
+
    trace_dump_ret(bool, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
@@ -209,9 +233,9 @@ trace_context_create_query(struct pipe_context *_pipe,
    result = pipe->create_query(pipe, query_type);;
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
@@ -235,7 +259,7 @@ trace_context_destroy_query(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_begin_query(struct pipe_context *_pipe, 
+trace_context_begin_query(struct pipe_context *_pipe,
                           struct pipe_query *query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -253,7 +277,7 @@ trace_context_begin_query(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_end_query(struct pipe_context *_pipe, 
+trace_context_end_query(struct pipe_context *_pipe,
                         struct pipe_query *query)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -271,7 +295,7 @@ trace_context_end_query(struct pipe_context *_pipe,
 
 
 static INLINE boolean
-trace_context_get_query_result(struct pipe_context *_pipe, 
+trace_context_get_query_result(struct pipe_context *_pipe,
                                struct pipe_query *query,
                                boolean wait,
                                uint64_t *presult)
@@ -290,9 +314,9 @@ trace_context_get_query_result(struct pipe_context *_pipe,
 
    trace_dump_arg(uint, result);
    trace_dump_ret(bool, _result);
-   
+
    trace_dump_call_end();
-   
+
    return _result;
 }
 
@@ -315,13 +339,13 @@ trace_context_create_blend_state(struct pipe_context *_pipe,
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_blend_state(struct pipe_context *_pipe, 
+trace_context_bind_blend_state(struct pipe_context *_pipe,
                                void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -339,7 +363,7 @@ trace_context_bind_blend_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_blend_state(struct pipe_context *_pipe, 
+trace_context_delete_blend_state(struct pipe_context *_pipe,
                                  void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -372,15 +396,15 @@ trace_context_create_sampler_state(struct pipe_context *_pipe,
    result = pipe->create_sampler_state(pipe, state);;
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_sampler_states(struct pipe_context *_pipe, 
+trace_context_bind_sampler_states(struct pipe_context *_pipe,
                                   unsigned num_states, void **states)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -399,7 +423,7 @@ trace_context_bind_sampler_states(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_sampler_state(struct pipe_context *_pipe, 
+trace_context_delete_sampler_state(struct pipe_context *_pipe,
                                    void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -432,15 +456,15 @@ trace_context_create_rasterizer_state(struct pipe_context *_pipe,
    result = pipe->create_rasterizer_state(pipe, state);;
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_rasterizer_state(struct pipe_context *_pipe, 
+trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
                                     void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -458,7 +482,7 @@ trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_rasterizer_state(struct pipe_context *_pipe, 
+trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
                                       void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -489,17 +513,17 @@ trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(depth_stencil_alpha_state, state);
-   
+
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, 
+trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
                                              void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -517,7 +541,7 @@ trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, 
+trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
                                                void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -550,15 +574,15 @@ trace_context_create_fs_state(struct pipe_context *_pipe,
    result = pipe->create_fs_state(pipe, state);;
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_fs_state(struct pipe_context *_pipe, 
+trace_context_bind_fs_state(struct pipe_context *_pipe,
                             void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -576,7 +600,7 @@ trace_context_bind_fs_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_fs_state(struct pipe_context *_pipe, 
+trace_context_delete_fs_state(struct pipe_context *_pipe,
                               void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -609,15 +633,15 @@ trace_context_create_vs_state(struct pipe_context *_pipe,
    result = pipe->create_vs_state(pipe, state);;
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
 static INLINE void
-trace_context_bind_vs_state(struct pipe_context *_pipe, 
+trace_context_bind_vs_state(struct pipe_context *_pipe,
                             void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -635,7 +659,7 @@ trace_context_bind_vs_state(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_delete_vs_state(struct pipe_context *_pipe, 
+trace_context_delete_vs_state(struct pipe_context *_pipe,
                               void *state)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -696,8 +720,9 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe,
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
-   trace_winsys_user_buffer_update(_pipe->winsys, (struct pipe_buffer *)buffer);
-   
+   if (buffer)
+      trace_screen_user_buffer_update(_pipe->screen, buffer->buffer);
+
    trace_dump_call_begin("pipe_context", "set_constant_buffer");
 
    trace_dump_arg(ptr, pipe);
@@ -705,7 +730,13 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe,
    trace_dump_arg(uint, index);
    trace_dump_arg(constant_buffer, buffer);
 
-   pipe->set_constant_buffer(pipe, shader, index, buffer);;
+   if (buffer) {
+      struct pipe_constant_buffer _buffer;
+      _buffer.buffer = trace_buffer_unwrap(tr_ctx, buffer->buffer);
+      pipe->set_constant_buffer(pipe, shader, index, &_buffer);
+   } else {
+      pipe->set_constant_buffer(pipe, shader, index, buffer);
+   }
 
    trace_dump_call_end();
 }
@@ -719,7 +750,7 @@ trace_context_set_framebuffer_state(struct pipe_context *_pipe,
    struct pipe_context *pipe = tr_ctx->pipe;
    struct pipe_framebuffer_state unwrapped_state;
    unsigned i;
-   
+
    /* Unwrap the input state */
    memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
    for(i = 0; i < state->nr_cbufs; ++i)
@@ -728,7 +759,7 @@ trace_context_set_framebuffer_state(struct pipe_context *_pipe,
       unwrapped_state.cbufs[i] = NULL;
    unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
    state = &unwrapped_state;
-   
+
    trace_dump_call_begin("pipe_context", "set_framebuffer_state");
 
    trace_dump_arg(ptr, pipe);
@@ -803,7 +834,7 @@ trace_context_set_sampler_textures(struct pipe_context *_pipe,
    struct pipe_context *pipe = tr_ctx->pipe;
    struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
    unsigned i;
-   
+
    for(i = 0; i < num_textures; ++i)
       unwrapped_textures[i] = trace_texture_unwrap(tr_ctx, textures[i]);
    textures = unwrapped_textures;
@@ -830,18 +861,27 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
    unsigned i;
 
    for(i = 0; i < num_buffers; ++i)
-      trace_winsys_user_buffer_update(_pipe->winsys, buffers[i].buffer);
+      trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
 
    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
 
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(uint, num_buffers);
-   
+
    trace_dump_arg_begin("buffers");
    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
    trace_dump_arg_end();
 
-   pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
+   if (num_buffers) {
+      struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
+      memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
+      for (i = 0; i < num_buffers; i++)
+         _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
+      pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
+      free(_buffers);
+   } else {
+      pipe->set_vertex_buffers(pipe, num_buffers, NULL);
+   }
 
    trace_dump_call_end();
 }
@@ -872,7 +912,6 @@ trace_context_set_vertex_elements(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_surface_copy(struct pipe_context *_pipe,
-                           boolean do_flip,
                            struct pipe_surface *dest,
                            unsigned destx, unsigned desty,
                            struct pipe_surface *src,
@@ -884,11 +923,10 @@ trace_context_surface_copy(struct pipe_context *_pipe,
 
    dest = trace_surface_unwrap(tr_ctx, dest);
    src = trace_surface_unwrap(tr_ctx, src);
-   
+
    trace_dump_call_begin("pipe_context", "surface_copy");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(bool, do_flip);
    trace_dump_arg(ptr, dest);
    trace_dump_arg(uint, destx);
    trace_dump_arg(uint, desty);
@@ -898,10 +936,10 @@ trace_context_surface_copy(struct pipe_context *_pipe,
    trace_dump_arg(uint, width);
    trace_dump_arg(uint, height);
 
-   pipe->surface_copy(pipe, do_flip, 
-                      dest, destx, desty, 
+   pipe->surface_copy(pipe,
+                      dest, destx, desty,
                       src, srcx, srcy, width, height);
-   
+
    trace_dump_call_end();
 }
 
@@ -934,7 +972,7 @@ trace_context_surface_fill(struct pipe_context *_pipe,
 
 
 static INLINE void
-trace_context_clear(struct pipe_context *_pipe, 
+trace_context_clear(struct pipe_context *_pipe,
                     struct pipe_surface *surface,
                     unsigned clearValue)
 {
@@ -988,7 +1026,7 @@ trace_context_destroy(struct pipe_context *_pipe)
    trace_dump_arg(ptr, pipe);
 
    pipe->destroy(pipe);
-   
+
    trace_dump_call_end();
 
    FREE(tr_ctx);
@@ -996,23 +1034,25 @@ trace_context_destroy(struct pipe_context *_pipe)
 
 
 struct pipe_context *
-trace_context_create(struct pipe_screen *screen, 
+trace_context_create(struct pipe_screen *_screen,
                      struct pipe_context *pipe)
 {
+   struct trace_screen *tr_scr = trace_screen(_screen);
    struct trace_context *tr_ctx;
-   
+   struct pipe_screen *screen = tr_scr->screen;
+
    if(!pipe)
       goto error1;
-   
+
    if(!trace_dump_enabled())
       goto error1;
-   
+
    tr_ctx = CALLOC_STRUCT(trace_context);
    if(!tr_ctx)
       goto error1;
 
-   tr_ctx->base.winsys = screen->winsys;
-   tr_ctx->base.screen = screen;
+   tr_ctx->base.winsys = _screen->winsys;
+   tr_ctx->base.screen = _screen;
    tr_ctx->base.destroy = trace_context_destroy;
    tr_ctx->base.set_edgeflags = trace_context_set_edgeflags;
    tr_ctx->base.draw_arrays = trace_context_draw_arrays;
@@ -1057,16 +1097,14 @@ trace_context_create(struct pipe_screen *screen,
    tr_ctx->base.flush = trace_context_flush;
 
    tr_ctx->pipe = pipe;
-   
+
    trace_dump_call_begin("", "pipe_context_create");
-   trace_dump_arg_begin("screen");
-   trace_dump_ptr(pipe->screen);
-   trace_dump_arg_end();
+   trace_dump_arg(ptr, screen);
    trace_dump_ret(ptr, pipe);
    trace_dump_call_end();
 
    return &tr_ctx->base;
-   
+
 error1:
    return pipe;
 }
diff --git a/src/gallium/drivers/trace/tr_context.h b/src/gallium/drivers/trace/tr_context.h
index 7831900ec29..d02b22a069b 100644
--- a/src/gallium/drivers/trace/tr_context.h
+++ b/src/gallium/drivers/trace/tr_context.h
@@ -30,7 +30,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_context.h"
 
 
@@ -38,11 +38,11 @@
 extern "C" {
 #endif
 
-   
+
 struct trace_context
 {
    struct pipe_context base;
-   
+
    struct pipe_context *pipe;
 };
 
diff --git a/src/gallium/drivers/trace/tr_dump.c b/src/gallium/drivers/trace/tr_dump.c
index a0ead0ded33..6837c94542d 100644
--- a/src/gallium/drivers/trace/tr_dump.c
+++ b/src/gallium/drivers/trace/tr_dump.c
@@ -29,35 +29,38 @@
 /**
  * @file
  * Trace dumping functions.
- * 
+ *
  * For now we just use standard XML for dumping the trace calls, as this is
- * simple to write, parse, and visually inspect, but the actual representation 
- * is abstracted out of this file, so that we can switch to a binary 
+ * simple to write, parse, and visually inspect, but the actual representation
+ * is abstracted out of this file, so that we can switch to a binary
  * representation if/when it becomes justified.
- * 
- * @author Jose Fonseca <[email protected]>   
+ *
+ * @author Jose Fonseca <[email protected]>
  */
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
 #include <stdlib.h>
 #endif
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "util/u_memory.h"
 #include "util/u_string.h"
 #include "util/u_stream.h"
 
 #include "tr_dump.h"
+#include "tr_screen.h"
+#include "tr_texture.h"
+#include "tr_buffer.h"
 
 
 static struct util_stream *stream = NULL;
 static unsigned refcount = 0;
 
 
-static INLINE void 
+static INLINE void
 trace_dump_write(const char *buf, size_t size)
 {
    if(stream)
@@ -65,14 +68,14 @@ trace_dump_write(const char *buf, size_t size)
 }
 
 
-static INLINE void 
+static INLINE void
 trace_dump_writes(const char *s)
 {
    trace_dump_write(s, strlen(s));
 }
 
 
-static INLINE void 
+static INLINE void
 trace_dump_writef(const char *format, ...)
 {
    static char buf[1024];
@@ -85,8 +88,8 @@ trace_dump_writef(const char *format, ...)
 }
 
 
-static INLINE void 
-trace_dump_escape(const char *str) 
+static INLINE void
+trace_dump_escape(const char *str)
 {
    const unsigned char *p = (const unsigned char *)str;
    unsigned char c;
@@ -109,7 +112,7 @@ trace_dump_escape(const char *str)
 }
 
 
-static INLINE void 
+static INLINE void
 trace_dump_indent(unsigned level)
 {
    unsigned i;
@@ -118,14 +121,14 @@ trace_dump_indent(unsigned level)
 }
 
 
-static INLINE void 
-trace_dump_newline(void) 
+static INLINE void
+trace_dump_newline(void)
 {
    trace_dump_writes("\n");
 }
 
 
-static INLINE void 
+static INLINE void
 trace_dump_tag(const char *name)
 {
    trace_dump_writes("<");
@@ -134,7 +137,7 @@ trace_dump_tag(const char *name)
 }
 
 
-static INLINE void 
+static INLINE void
 trace_dump_tag_begin(const char *name)
 {
    trace_dump_writes("<");
@@ -142,8 +145,8 @@ trace_dump_tag_begin(const char *name)
    trace_dump_writes(">");
 }
 
-static INLINE void 
-trace_dump_tag_begin1(const char *name, 
+static INLINE void
+trace_dump_tag_begin1(const char *name,
                       const char *attr1, const char *value1)
 {
    trace_dump_writes("<");
@@ -156,8 +159,8 @@ trace_dump_tag_begin1(const char *name,
 }
 
 
-static INLINE void 
-trace_dump_tag_begin2(const char *name, 
+static INLINE void
+trace_dump_tag_begin2(const char *name,
                       const char *attr1, const char *value1,
                       const char *attr2, const char *value2)
 {
@@ -175,8 +178,8 @@ trace_dump_tag_begin2(const char *name,
 }
 
 
-static INLINE void 
-trace_dump_tag_begin3(const char *name, 
+static INLINE void
+trace_dump_tag_begin3(const char *name,
                       const char *attr1, const char *value1,
                       const char *attr2, const char *value2,
                       const char *attr3, const char *value3)
@@ -207,7 +210,7 @@ trace_dump_tag_end(const char *name)
    trace_dump_writes(">");
 }
 
-static void 
+static void
 trace_dump_trace_close(void)
 {
    if(stream) {
@@ -221,30 +224,30 @@ trace_dump_trace_close(void)
 boolean trace_dump_trace_begin()
 {
    const char *filename;
-   
+
    filename = debug_get_option("GALLIUM_TRACE", NULL);
    if(!filename)
       return FALSE;
-   
+
    if(!stream) {
-   
+
       stream = util_stream_create(filename, 0);
       if(!stream)
          return FALSE;
-      
+
       trace_dump_writes("<?xml version='1.0' encoding='UTF-8'?>\n");
       trace_dump_writes("<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
       trace_dump_writes("<trace version='0.1'>\n");
-      
-#if defined(PIPE_OS_LINUX)
-      /* Linux applications rarely cleanup GL / Gallium resources so catch 
-       * application exit here */ 
+
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
+      /* Linux applications rarely cleanup GL / Gallium resources so catch
+       * application exit here */
       atexit(trace_dump_trace_close);
 #endif
    }
-   
+
    ++refcount;
-   
+
    return TRUE;
 }
 
@@ -402,3 +405,49 @@ void trace_dump_ptr(const void *value)
    else
       trace_dump_null();
 }
+
+void trace_dump_buffer_ptr(struct pipe_buffer *_buffer)
+{
+   if (_buffer) {
+      struct trace_screen *tr_scr = trace_screen(_buffer->screen);
+      struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+      trace_dump_ptr(tr_buf->buffer);
+   } else {
+      trace_dump_null();
+   }
+}
+
+void trace_dump_texture_ptr(struct pipe_texture *_texture)
+{
+   if (_texture) {
+      struct trace_screen *tr_scr = trace_screen(_texture->screen);
+      struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
+      trace_dump_ptr(tr_tex->texture);
+   } else {
+      trace_dump_null();
+   }
+}
+
+void trace_dump_surface_ptr(struct pipe_surface *_surface)
+{
+   if (_surface) {
+      struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
+      struct trace_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
+      struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
+      trace_dump_ptr(tr_surf->surface);
+   } else {
+      trace_dump_null();
+   }
+}
+
+void trace_dump_transfer_ptr(struct pipe_transfer *_transfer)
+{
+   if (_transfer) {
+      struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
+      struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+      struct trace_transfer *tr_tran = trace_transfer(tr_tex, _transfer);
+      trace_dump_ptr(tr_tran->transfer);
+   } else {
+      trace_dump_null();
+   }
+}
diff --git a/src/gallium/drivers/trace/tr_dump.h b/src/gallium/drivers/trace/tr_dump.h
index 76a53731b31..26409f26c66 100644
--- a/src/gallium/drivers/trace/tr_dump.h
+++ b/src/gallium/drivers/trace/tr_dump.h
@@ -37,6 +37,11 @@
 #include "pipe/p_compiler.h"
 
 
+struct pipe_buffer;
+struct pipe_texture;
+struct pipe_surface;
+struct pipe_transfer;
+
 boolean trace_dump_trace_begin(void);
 boolean trace_dump_enabled(void);
 void trace_dump_trace_end(void);
@@ -63,10 +68,14 @@ void trace_dump_member_begin(const char *name);
 void trace_dump_member_end(void);
 void trace_dump_null(void);
 void trace_dump_ptr(const void *value);
-
+/* will turn a wrapped object into the real one and dump ptr */
+void trace_dump_buffer_ptr(struct pipe_buffer *_buffer);
+void trace_dump_texture_ptr(struct pipe_texture *_texture);
+void trace_dump_surface_ptr(struct pipe_surface *_surface);
+void trace_dump_transfer_ptr(struct pipe_transfer *_transfer);
 
 /*
- * Code saving macros. 
+ * Code saving macros.
  */
 
 #define trace_dump_arg(_type, _arg) \
diff --git a/src/gallium/drivers/trace/tr_screen.c b/src/gallium/drivers/trace/tr_screen.c
index 8789f86b1a8..954576d7217 100644
--- a/src/gallium/drivers/trace/tr_screen.c
+++ b/src/gallium/drivers/trace/tr_screen.c
@@ -27,12 +27,14 @@
 
 #include "util/u_memory.h"
 
+#include "tr_buffer.h"
 #include "tr_dump.h"
 #include "tr_state.h"
-#include "tr_winsys.h"
 #include "tr_texture.h"
 #include "tr_screen.h"
 
+#include "pipe/p_inlines.h"
+
 
 static const char *
 trace_screen_get_name(struct pipe_screen *_screen)
@@ -40,17 +42,17 @@ trace_screen_get_name(struct pipe_screen *_screen)
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_name");
-   
+
    trace_dump_arg(ptr, screen);
 
    result = screen->get_name(screen);
-   
+
    trace_dump_ret(string, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
@@ -61,80 +63,80 @@ trace_screen_get_vendor(struct pipe_screen *_screen)
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_vendor");
-   
+
    trace_dump_arg(ptr, screen);
-  
+
    result = screen->get_vendor(screen);
-   
+
    trace_dump_ret(string, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static int 
-trace_screen_get_param(struct pipe_screen *_screen, 
+static int
+trace_screen_get_param(struct pipe_screen *_screen,
                        int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    int result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_param");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(int, param);
 
    result = screen->get_param(screen, param);
-   
+
    trace_dump_ret(int, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static float 
-trace_screen_get_paramf(struct pipe_screen *_screen, 
+static float
+trace_screen_get_paramf(struct pipe_screen *_screen,
                         int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    float result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_paramf");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(int, param);
 
    result = screen->get_paramf(screen, param);
-   
+
    trace_dump_ret(float, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static boolean 
+static boolean
 trace_screen_is_format_supported(struct pipe_screen *_screen,
                                  enum pipe_format format,
                                  enum pipe_texture_target target,
-                                 unsigned tex_usage, 
+                                 unsigned tex_usage,
                                  unsigned geom_flags)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    boolean result;
-   
+
    trace_dump_call_begin("pipe_screen", "is_format_supported");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(format, format);
    trace_dump_arg(int, target);
@@ -142,15 +144,45 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
    trace_dump_arg(uint, geom_flags);
 
    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
-   
+
    trace_dump_ret(bool, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
+static void
+trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
+                               struct pipe_surface *_surface,
+                               void *context_private)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
+   struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_surface *surface = tr_surf->surface;
+
+   trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
+   /* XXX: hide, as there is nothing we can do with this
+   trace_dump_arg(ptr, context_private);
+   */
+
+   screen->flush_frontbuffer(screen, surface, context_private);
+
+   trace_dump_call_end();
+}
+
+
+/********************************************************************
+ * texture
+ */
+
+
 static struct pipe_texture *
 trace_screen_texture_create(struct pipe_screen *_screen,
                             const struct pipe_texture *templat)
@@ -158,20 +190,20 @@ trace_screen_texture_create(struct pipe_screen *_screen,
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_texture *result;
-   
+
    trace_dump_call_begin("pipe_screen", "texture_create");
 
    trace_dump_arg(ptr, screen);
    trace_dump_arg(template, templat);
 
    result = screen->texture_create(screen, templat);
-   
+
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_texture_create(tr_scr, result);
-   
+
    return result;
 }
 
@@ -195,71 +227,60 @@ trace_screen_texture_blanket(struct pipe_screen *_screen,
    trace_dump_arg(ptr, buffer);
 
    result = screen->texture_blanket(screen, templat, ppitch, buffer);
-   
+
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_texture_create(tr_scr, result);
-   
+
    return result;
 }
 
 
-static void 
-trace_screen_texture_release(struct pipe_screen *_screen,
-                             struct pipe_texture **ptexture)
+static void
+trace_screen_texture_destroy(struct pipe_texture *_texture)
 {
-   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_screen *tr_scr = trace_screen(_texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct pipe_texture *texture;
-   
-   assert(ptexture);
-   if(*ptexture) {
-      tr_tex = trace_texture(tr_scr, *ptexture);
-      texture = tr_tex->texture;
-      assert(texture->screen == screen);
-   }
-   else
-      texture = NULL;
-   
-   if (*ptexture) {
-      if (!--(*ptexture)->refcount) {
-         trace_dump_call_begin("pipe_screen", "texture_destroy");
-         
-         trace_dump_arg(ptr, screen);
-         trace_dump_arg(ptr, texture);
-         
-         trace_texture_destroy(tr_scr, *ptexture);
-         
-         trace_dump_call_end();
-      }
-   
-      *ptexture = NULL;
-   }
+   struct pipe_texture *texture = tr_tex->texture;
+
+   assert(texture->screen == screen);
+
+   trace_dump_call_begin("pipe_screen", "texture_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
+
+   trace_dump_call_end();
+
+   trace_texture_destroy(tr_scr, _texture);
 }
 
 
+/********************************************************************
+ * surface
+ */
+
+
 static struct pipe_surface *
 trace_screen_get_tex_surface(struct pipe_screen *_screen,
-                             struct pipe_texture *texture,
+                             struct pipe_texture *_texture,
                              unsigned face, unsigned level,
                              unsigned zslice,
                              unsigned usage)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct pipe_surface *result;
-   
-   assert(texture);
-   tr_tex = trace_texture(tr_scr, texture);
-   texture = tr_tex->texture;
+   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_surface *result = NULL;
+
    assert(texture->screen == screen);
-   
+
    trace_dump_call_begin("pipe_screen", "get_tex_surface");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(ptr, texture);
    trace_dump_arg(uint, face);
@@ -270,133 +291,538 @@ trace_screen_get_tex_surface(struct pipe_screen *_screen,
    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_surface_create(tr_tex, result);
 
    return result;
 }
 
 
-static void 
-trace_screen_tex_surface_release(struct pipe_screen *_screen,
-                                 struct pipe_surface **psurface)
+static void
+trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
+{
+   struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
+   struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_surface *surface = tr_surf->surface;
+
+   trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
+
+   trace_dump_call_end();
+
+   trace_surface_destroy(tr_tex, _surface);
+}
+
+
+/********************************************************************
+ * transfer
+ */
+
+
+static struct pipe_transfer *
+trace_screen_get_tex_transfer(struct pipe_screen *_screen,
+                              struct pipe_texture *_texture,
+                              unsigned face, unsigned level,
+                              unsigned zslice,
+                              enum pipe_transfer_usage usage,
+                              unsigned x, unsigned y, unsigned w, unsigned h)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
-   struct pipe_surface *surface;
-   
-   assert(psurface);
-   if(*psurface) {
-      tr_tex = trace_texture(tr_scr, (*psurface)->texture);
-      tr_surf = trace_surface(tr_tex, *psurface);
-      surface = tr_surf->surface;
-   }
-   else
-      surface = NULL;
-   
-   if (*psurface) {
-      if (!--(*psurface)->refcount) {
-         trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
-         
-         trace_dump_arg(ptr, screen);
-         trace_dump_arg(ptr, surface);
+   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_transfer *result = NULL;
 
-         trace_surface_destroy(tr_tex, *psurface);
+   assert(texture->screen == screen);
 
-         trace_dump_call_end();
-      }
-   
-      *psurface = NULL;
-   }
+   trace_dump_call_begin("pipe_screen", "get_tex_transfer");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
+   trace_dump_arg(uint, face);
+   trace_dump_arg(uint, level);
+   trace_dump_arg(uint, zslice);
+   trace_dump_arg(uint, usage);
+
+   trace_dump_arg(uint, x);
+   trace_dump_arg(uint, y);
+   trace_dump_arg(uint, w);
+   trace_dump_arg(uint, h);
+
+   result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
+                                     x, y, w, h);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   result = trace_transfer_create(tr_tex, result);
+
+   return result;
+}
+
+
+static void
+trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
+{
+   struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_tran = trace_transfer(tr_tex, _transfer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_transfer *transfer = tr_tran->transfer;
+
+   trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, transfer);
+
+   trace_dump_call_end();
+
+   trace_transfer_destroy(tr_tex, _transfer);
 }
 
 
 static void *
-trace_screen_surface_map(struct pipe_screen *_screen,
-                         struct pipe_surface *surface,
-                         unsigned flags)
+trace_screen_transfer_map(struct pipe_screen *_screen,
+                          struct pipe_transfer *_transfer)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_trans = trace_transfer(tr_tex, _transfer);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
+   struct pipe_transfer *transfer = tr_trans->transfer;
    void *map;
-   
-   tr_tex = trace_texture(tr_scr, surface->texture);
-   tr_surf = trace_surface(tr_tex, surface);
-   surface = tr_surf->surface;
 
-   map = screen->surface_map(screen, surface, flags);
+   map = screen->transfer_map(screen, transfer);
    if(map) {
-      if(flags & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         assert(!tr_surf->map);
-         tr_surf->map = map;
+      if(transfer->usage != PIPE_TRANSFER_READ) {
+         assert(!tr_trans->map);
+         tr_trans->map = map;
       }
    }
-   
+
    return map;
 }
 
 
-static void 
-trace_screen_surface_unmap(struct pipe_screen *_screen,
-                           struct pipe_surface *surface)
+static void
+trace_screen_transfer_unmap(struct pipe_screen *_screen,
+                           struct pipe_transfer *_transfer)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_trans = trace_transfer(tr_tex, _transfer);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
-   
-   tr_tex = trace_texture(tr_scr, surface->texture);
-   tr_surf = trace_surface(tr_tex, surface);
-   surface = tr_surf->surface;
-   
-   if(tr_surf->map) {
-      size_t size = surface->nblocksy * surface->stride;
-      
-      trace_dump_call_begin("pipe_winsys", "surface_write");
-      
+   struct pipe_transfer *transfer = tr_trans->transfer;
+
+   if(tr_trans->map) {
+      size_t size = transfer->nblocksy * transfer->stride;
+
+      trace_dump_call_begin("pipe_screen", "transfer_write");
+
       trace_dump_arg(ptr, screen);
-      
-      trace_dump_arg(ptr, surface);
-      
-      trace_dump_arg_begin("data");
-      trace_dump_bytes(tr_surf->map, size);
-      trace_dump_arg_end();
+
+      trace_dump_arg(ptr, transfer);
 
       trace_dump_arg_begin("stride");
-      trace_dump_uint(surface->stride);
+      trace_dump_uint(transfer->stride);
+      trace_dump_arg_end();
+
+      trace_dump_arg_begin("data");
+      trace_dump_bytes(tr_trans->map, size);
       trace_dump_arg_end();
 
       trace_dump_arg_begin("size");
       trace_dump_uint(size);
       trace_dump_arg_end();
-   
+
       trace_dump_call_end();
 
-      tr_surf->map = NULL;
+      tr_trans->map = NULL;
+   }
+
+   screen->transfer_unmap(screen, transfer);
+}
+
+
+/********************************************************************
+ * buffer
+ */
+
+
+static struct pipe_buffer *
+trace_screen_surface_buffer_create(struct pipe_screen *_screen,
+                                   unsigned width, unsigned height,
+                                   enum pipe_format format,
+                                   unsigned usage,
+                                   unsigned *pstride)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   unsigned stride;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "surface_buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(uint, width);
+   trace_dump_arg(uint, height);
+   trace_dump_arg(format, format);
+   trace_dump_arg(uint, usage);
+
+   result = screen->surface_buffer_create(screen,
+                                          width, height,
+                                          format,
+                                          usage,
+                                          pstride);
+
+   stride = *pstride;
+
+   trace_dump_arg(uint, stride);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+static struct pipe_buffer *
+trace_screen_buffer_create(struct pipe_screen *_screen,
+                           unsigned alignment,
+                           unsigned usage,
+                           unsigned size)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(uint, alignment);
+   trace_dump_arg(uint, usage);
+   trace_dump_arg(uint, size);
+
+   result = screen->buffer_create(screen, alignment, usage, size);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   /* Zero the buffer to avoid dumping uninitialized memory */
+   if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+      void *map;
+      map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
+      if(map) {
+         memset(map, 0, result->size);
+         screen->buffer_unmap(screen, result);
+      }
+   }
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+static struct pipe_buffer *
+trace_screen_user_buffer_create(struct pipe_screen *_screen,
+                                void *data,
+                                unsigned size)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "user_buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg_begin("data");
+   trace_dump_bytes(data, size);
+   trace_dump_arg_end();
+   trace_dump_arg(uint, size);
+
+   result = screen->user_buffer_create(screen, data, size);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   if(result) {
+      assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
+      result->usage |= TRACE_BUFFER_USAGE_USER;
+   }
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+/**
+ * This function is used to track if data has been changed on a user buffer
+ * without map/unmap being called.
+ */
+void
+trace_screen_user_buffer_update(struct pipe_screen *_screen,
+                                struct pipe_buffer *_buffer)
+{
+#if 0
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   const void *map;
+
+   if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
+      map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
+      if(map) {
+         trace_dump_call_begin("pipe_winsys", "buffer_write");
+
+         trace_dump_arg(ptr, screen);
+
+         trace_dump_arg(ptr, buffer);
+
+         trace_dump_arg_begin("data");
+         trace_dump_bytes(map, buffer->size);
+         trace_dump_arg_end();
+
+         trace_dump_arg_begin("size");
+         trace_dump_uint(buffer->size);
+         trace_dump_arg_end();
+
+         trace_dump_call_end();
+
+         screen->buffer_unmap(screen, buffer);
+      }
+   }
+#endif
+}
+
+
+static void *
+trace_screen_buffer_map(struct pipe_screen *_screen,
+                        struct pipe_buffer *_buffer,
+                        unsigned usage)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+   void *map;
+
+   assert(screen->buffer_map);
+   map = screen->buffer_map(screen, buffer, usage);
+   if(map) {
+      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+         tr_buf->map = map;
+      }
+   }
+
+   return map;
+}
+
+
+static void *
+trace_screen_buffer_map_range(struct pipe_screen *_screen,
+                              struct pipe_buffer *_buffer,
+                              unsigned offset,
+                              unsigned length,
+                              unsigned usage)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+   void *map;
+
+   assert(screen->buffer_map_range);
+   map = screen->buffer_map_range(screen, buffer, offset, length, usage);
+   if(map) {
+      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+         tr_buf->map = map;
+      }
    }
 
-   screen->surface_unmap(screen, surface);
+   return map;
+}
+
+
+static void
+buffer_write(struct pipe_screen *screen,
+             struct pipe_buffer *buffer,
+             unsigned offset,
+             const char *map,
+             unsigned size)
+{
+   assert(map);
+
+   trace_dump_call_begin("pipe_screen", "buffer_write");
+
+   trace_dump_arg(ptr, screen);
+
+   trace_dump_arg(ptr, buffer);
+
+   trace_dump_arg(uint, offset);
+
+   trace_dump_arg_begin("data");
+   trace_dump_bytes(map + offset, size);
+   trace_dump_arg_end();
+
+   trace_dump_arg(uint, size);
+
+   trace_dump_call_end();
+
+}
+
+
+static void
+trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
+                                       struct pipe_buffer *_buffer,
+                                       unsigned offset,
+                                       unsigned length)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   assert(tr_buf->map);
+   buffer_write(screen, buffer, offset, tr_buf->map, length);
+   tr_buf->range_flushed = TRUE;
+   screen->buffer_flush_mapped_range(screen, buffer, offset, length);
+}
+
+
+static void
+trace_screen_buffer_unmap(struct pipe_screen *_screen,
+                          struct pipe_buffer *_buffer)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   if (tr_buf->map && !tr_buf->range_flushed)
+      buffer_write(screen, buffer, tr_buf->map, 0, buffer->size);
+   tr_buf->map = NULL;
+   tr_buf->range_flushed = FALSE;
+   screen->buffer_unmap(screen, buffer);
+}
+
+
+static void
+trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
+{
+   struct trace_screen *tr_scr = trace_screen(_buffer->screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   trace_dump_call_begin("pipe_screen", "buffer_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, buffer);
+
+   trace_dump_call_end();
+
+   trace_buffer_destroy(tr_scr, _buffer);
+}
+
+
+/********************************************************************
+ * fence
+ */
+
+
+static void
+trace_screen_fence_reference(struct pipe_screen *_screen,
+                             struct pipe_fence_handle **dst,
+                             struct pipe_fence_handle *src)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+
+   trace_dump_call_begin("pipe_screen", "fence_reference");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, dst);
+   trace_dump_arg(ptr, src);
+
+   screen->fence_reference(screen, dst, src);
+
+   trace_dump_call_end();
+}
+
+
+static int
+trace_screen_fence_signalled(struct pipe_screen *_screen,
+                             struct pipe_fence_handle *fence,
+                             unsigned flag)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   int result;
+
+   trace_dump_call_begin("pipe_screen", "fence_signalled");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
+
+   result = screen->fence_signalled(screen, fence, flag);
+
+   trace_dump_ret(int, result);
+
+   trace_dump_call_end();
+
+   return result;
 }
 
 
+static int
+trace_screen_fence_finish(struct pipe_screen *_screen,
+                          struct pipe_fence_handle *fence,
+                          unsigned flag)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   int result;
+
+   trace_dump_call_begin("pipe_screen", "fence_finish");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
+
+   result = screen->fence_finish(screen, fence, flag);
+
+   trace_dump_ret(int, result);
+
+   trace_dump_call_end();
+
+   return result;
+}
+
+
+/********************************************************************
+ * screen
+ */
+
 static void
 trace_screen_destroy(struct pipe_screen *_screen)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
-   
+
    trace_dump_call_begin("pipe_screen", "destroy");
-   
+
    trace_dump_arg(ptr, screen);
 
    screen->destroy(screen);
-   
+
    trace_dump_call_end();
 
    trace_dump_trace_end();
@@ -410,21 +836,27 @@ trace_screen_create(struct pipe_screen *screen)
 {
    struct trace_screen *tr_scr;
    struct pipe_winsys *winsys;
-   
+
    if(!screen)
       goto error1;
 
    if(!trace_dump_trace_begin())
       goto error1;
 
+   trace_dump_call_begin("", "pipe_screen_create");
+
    tr_scr = CALLOC_STRUCT(trace_screen);
    if(!tr_scr)
       goto error2;
 
+#if 0
    winsys = trace_winsys_create(screen->winsys);
    if(!winsys)
       goto error3;
-   
+#else
+   winsys = screen->winsys;
+#endif
+
    tr_scr->base.winsys = winsys;
    tr_scr->base.destroy = trace_screen_destroy;
    tr_scr->base.get_name = trace_screen_get_name;
@@ -434,26 +866,43 @@ trace_screen_create(struct pipe_screen *screen)
    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
    tr_scr->base.texture_create = trace_screen_texture_create;
    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
-   tr_scr->base.texture_release = trace_screen_texture_release;
+   tr_scr->base.texture_destroy = trace_screen_texture_destroy;
    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
-   tr_scr->base.tex_surface_release = trace_screen_tex_surface_release;
-   tr_scr->base.surface_map = trace_screen_surface_map;
-   tr_scr->base.surface_unmap = trace_screen_surface_unmap;
-   
+   tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
+   tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
+   tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
+   tr_scr->base.transfer_map = trace_screen_transfer_map;
+   tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
+   tr_scr->base.buffer_create = trace_screen_buffer_create;
+   tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
+   tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
+   if (screen->buffer_map)
+      tr_scr->base.buffer_map = trace_screen_buffer_map;
+   if (screen->buffer_map_range)
+      tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
+   if (screen->buffer_flush_mapped_range)
+      tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
+   if (screen->buffer_unmap)
+      tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
+   tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
+   tr_scr->base.fence_reference = trace_screen_fence_reference;
+   tr_scr->base.fence_signalled = trace_screen_fence_signalled;
+   tr_scr->base.fence_finish = trace_screen_fence_finish;
+   tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
    tr_scr->screen = screen;
 
-   trace_dump_call_begin("", "pipe_screen_create");
-   trace_dump_arg_begin("winsys");
-   trace_dump_ptr(screen->winsys);
-   trace_dump_arg_end();
    trace_dump_ret(ptr, screen);
    trace_dump_call_end();
 
    return &tr_scr->base;
 
+#if 0
 error3:
    FREE(tr_scr);
+#endif
 error2:
+   trace_dump_ret(ptr, screen);
+   trace_dump_call_end();
    trace_dump_trace_end();
 error1:
    return screen;
diff --git a/src/gallium/drivers/trace/tr_screen.h b/src/gallium/drivers/trace/tr_screen.h
index 93fefdb9a5f..8c65516b509 100644
--- a/src/gallium/drivers/trace/tr_screen.h
+++ b/src/gallium/drivers/trace/tr_screen.h
@@ -36,11 +36,19 @@
 extern "C" {
 #endif
 
-   
+
+/**
+ * It often happens that new data is written directly to the user buffers
+ * without mapping/unmapping. This flag marks user buffers, so that their
+ * contents can be dumpped before being used by the pipe context.
+ */
+#define TRACE_BUFFER_USAGE_USER  (1 << 31)
+
+
 struct trace_screen
 {
    struct pipe_screen base;
-   
+
    struct pipe_screen *screen;
 };
 
@@ -53,6 +61,11 @@ struct pipe_screen *
 trace_screen_create(struct pipe_screen *screen);
 
 
+void
+trace_screen_user_buffer_update(struct pipe_screen *screen,
+                                struct pipe_buffer *buffer);
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/gallium/drivers/trace/tr_state.c b/src/gallium/drivers/trace/tr_state.c
index 524f2d61948..b6a1ce0d625 100644
--- a/src/gallium/drivers/trace/tr_state.c
+++ b/src/gallium/drivers/trace/tr_state.c
@@ -50,6 +50,14 @@ void trace_dump_block(const struct pipe_format_block *block)
 }
 
 
+static void trace_dump_reference(const struct pipe_reference *reference)
+{
+   trace_dump_struct_begin("pipe_reference");
+   trace_dump_member(int, &reference->count, count);
+   trace_dump_struct_end();
+}
+
+
 void trace_dump_template(const struct pipe_texture *templat)
 {
    if(!templat) {
@@ -58,10 +66,10 @@ void trace_dump_template(const struct pipe_texture *templat)
    }
 
    trace_dump_struct_begin("pipe_texture");
-   
+
    trace_dump_member(int, templat, target);
    trace_dump_member(format, templat, format);
-   
+
    trace_dump_member_begin("width");
    trace_dump_array(uint, templat->width, 1);
    trace_dump_member_end();
@@ -77,10 +85,10 @@ void trace_dump_template(const struct pipe_texture *templat)
    trace_dump_member_begin("block");
    trace_dump_block(&templat->block);
    trace_dump_member_end();
-   
+
    trace_dump_member(uint, templat, last_level);
    trace_dump_member(uint, templat, tex_usage);
-   
+
    trace_dump_struct_end();
 }
 
@@ -114,8 +122,7 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
    trace_dump_member(uint, state, line_stipple_factor);
    trace_dump_member(uint, state, line_stipple_pattern);
    trace_dump_member(bool, state, line_last_pixel);
-   trace_dump_member(bool, state, bypass_clipping);
-   trace_dump_member(bool, state, bypass_vs);
+   trace_dump_member(bool, state, bypass_vs_clip_and_viewport);
    trace_dump_member(bool, state, origin_lower_left);
    trace_dump_member(bool, state, flatshade_first);
    trace_dump_member(bool, state, gl_rasterization_rules);
@@ -126,9 +133,9 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
    trace_dump_member(float, state, point_size_max);
    trace_dump_member(float, state, offset_units);
    trace_dump_member(float, state, offset_scale);
-   
+
    trace_dump_member_array(uint, state, sprite_coord_mode);
-   
+
    trace_dump_struct_end();
 }
 
@@ -144,10 +151,10 @@ void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
 
    trace_dump_member_begin("stipple");
    trace_dump_array(uint,
-                    state->stipple, 
+                    state->stipple,
                     Elements(state->stipple));
    trace_dump_member_end();
-   
+
    trace_dump_struct_end();
 }
 
@@ -163,7 +170,7 @@ void trace_dump_viewport_state(const struct pipe_viewport_state *state)
 
    trace_dump_member_array(float, state, scale);
    trace_dump_member_array(float, state, translate);
-   
+
    trace_dump_struct_end();
 }
 
@@ -189,7 +196,7 @@ void trace_dump_scissor_state(const struct pipe_scissor_state *state)
 void trace_dump_clip_state(const struct pipe_clip_state *state)
 {
    unsigned i;
-   
+
    if(!state) {
       trace_dump_null();
       return;
@@ -222,7 +229,7 @@ void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
 
    trace_dump_struct_begin("pipe_constant_buffer");
 
-   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(buffer_ptr, state, buffer);
 
    trace_dump_struct_end();
 }
@@ -238,7 +245,7 @@ void trace_dump_shader_state(const struct pipe_shader_state *state)
    }
 
    tgsi_dump_str(state->tokens, 0, str, sizeof(str));
-   
+
    trace_dump_struct_begin("pipe_shader_state");
 
    trace_dump_member_begin("tokens");
@@ -252,7 +259,7 @@ void trace_dump_shader_state(const struct pipe_shader_state *state)
 void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
 {
    unsigned i;
-   
+
    if(!state) {
       trace_dump_null();
       return;
@@ -268,7 +275,7 @@ void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_
    trace_dump_member(bool, &state->depth, occlusion_count);
    trace_dump_struct_end();
    trace_dump_member_end();
-   
+
    trace_dump_member_begin("stencil");
    trace_dump_array_begin();
    for(i = 0; i < Elements(state->stencil); ++i) {
@@ -397,22 +404,47 @@ void trace_dump_surface(const struct pipe_surface *state)
 
    trace_dump_struct_begin("pipe_surface");
 
+   trace_dump_reference(&state->reference);
+
    trace_dump_member(format, state, format);
    trace_dump_member(uint, state, status);
    trace_dump_member(uint, state, clear_value);
    trace_dump_member(uint, state, width);
    trace_dump_member(uint, state, height);
 
+   trace_dump_member(uint, state, layout);
+   trace_dump_member(uint, state, offset);
+   trace_dump_member(uint, state, usage);
+
+   trace_dump_member(ptr, state, texture);
+   trace_dump_member(uint, state, face);
+   trace_dump_member(uint, state, level);
+   trace_dump_member(uint, state, zslice);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_transfer(const struct pipe_transfer *state)
+{
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_transfer");
+
+   trace_dump_member(format, state, format);
+   trace_dump_member(uint, state, width);
+   trace_dump_member(uint, state, height);
+
    trace_dump_member_begin("block");
    trace_dump_block(&state->block);
    trace_dump_member_end();
-   
+
    trace_dump_member(uint, state, nblocksx);
    trace_dump_member(uint, state, nblocksy);
    trace_dump_member(uint, state, stride);
-   trace_dump_member(uint, state, layout);
-   trace_dump_member(uint, state, offset);
-   trace_dump_member(uint, state, refcount);
    trace_dump_member(uint, state, usage);
 
    trace_dump_member(ptr, state, texture);
@@ -436,7 +468,7 @@ void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
    trace_dump_member(uint, state, stride);
    trace_dump_member(uint, state, max_index);
    trace_dump_member(uint, state, buffer_offset);
-   trace_dump_member(ptr, state, buffer);
+   trace_dump_member(buffer_ptr, state, buffer);
 
    trace_dump_struct_end();
 }
@@ -455,7 +487,7 @@ void trace_dump_vertex_element(const struct pipe_vertex_element *state)
 
    trace_dump_member(uint, state, vertex_buffer_index);
    trace_dump_member(uint, state, nr_components);
- 
+
    trace_dump_member(format, state, src_format);
 
    trace_dump_struct_end();
diff --git a/src/gallium/drivers/trace/tr_state.h b/src/gallium/drivers/trace/tr_state.h
index 5ae533dc664..513ed0ac98d 100644
--- a/src/gallium/drivers/trace/tr_state.h
+++ b/src/gallium/drivers/trace/tr_state.h
@@ -68,6 +68,8 @@ void trace_dump_sampler_state(const struct pipe_sampler_state *state);
 
 void trace_dump_surface(const struct pipe_surface *state);
 
+void trace_dump_transfer(const struct pipe_transfer *state);
+
 void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state);
 
 void trace_dump_vertex_element(const struct pipe_vertex_element *state);
diff --git a/src/gallium/drivers/trace/tr_texture.c b/src/gallium/drivers/trace/tr_texture.c
index 1cc4f0bd436..7b392f07286 100644
--- a/src/gallium/drivers/trace/tr_texture.c
+++ b/src/gallium/drivers/trace/tr_texture.c
@@ -25,7 +25,6 @@
  *
  **************************************************************************/
 
-#include "pipe/p_inlines.h"
 #include "util/u_hash_table.h"
 #include "util/u_memory.h"
 
@@ -34,26 +33,28 @@
 
 
 struct pipe_texture *
-trace_texture_create(struct trace_screen *tr_scr, 
+trace_texture_create(struct trace_screen *tr_scr,
                      struct pipe_texture *texture)
 {
    struct trace_texture *tr_tex;
-   
+
    if(!texture)
       goto error;
-   
+
    assert(texture->screen == tr_scr->screen);
-   
+
    tr_tex = CALLOC_STRUCT(trace_texture);
    if(!tr_tex)
       goto error;
-   
+
    memcpy(&tr_tex->base, texture, sizeof(struct pipe_texture));
+
+   pipe_reference_init(&tr_tex->base.reference, 1);
    tr_tex->base.screen = &tr_scr->base;
    tr_tex->texture = texture;
-   
+
    return &tr_tex->base;
-   
+
 error:
    pipe_texture_reference(&texture, NULL);
    return NULL;
@@ -61,38 +62,39 @@ error:
 
 
 void
-trace_texture_destroy(struct trace_screen *tr_scr, 
+trace_texture_destroy(struct trace_screen *tr_scr,
                       struct pipe_texture *texture)
 {
-   struct trace_texture *tr_tex = trace_texture(tr_scr, texture); 
+   struct trace_texture *tr_tex = trace_texture(tr_scr, texture);
    pipe_texture_reference(&tr_tex->texture, NULL);
    FREE(tr_tex);
 }
 
 
 struct pipe_surface *
-trace_surface_create(struct trace_texture *tr_tex, 
+trace_surface_create(struct trace_texture *tr_tex,
                      struct pipe_surface *surface)
 {
    struct trace_surface *tr_surf;
-   
+
    if(!surface)
       goto error;
-   
+
    assert(surface->texture == tr_tex->texture);
-   
+
    tr_surf = CALLOC_STRUCT(trace_surface);
    if(!tr_surf)
       goto error;
-   
+
    memcpy(&tr_surf->base, surface, sizeof(struct pipe_surface));
-   
+
+   pipe_reference_init(&tr_surf->base.reference, 1);
    tr_surf->base.texture = NULL;
    pipe_texture_reference(&tr_surf->base.texture, &tr_tex->base);
    tr_surf->surface = surface;
 
    return &tr_surf->base;
-   
+
 error:
    pipe_surface_reference(&surface, NULL);
    return NULL;
@@ -100,7 +102,7 @@ error:
 
 
 void
-trace_surface_destroy(struct trace_texture *tr_tex, 
+trace_surface_destroy(struct trace_texture *tr_tex,
                       struct pipe_surface *surface)
 {
    struct trace_surface *tr_surf = trace_surface(tr_tex, surface);
@@ -109,3 +111,45 @@ trace_surface_destroy(struct trace_texture *tr_tex,
    FREE(tr_surf);
 }
 
+
+struct pipe_transfer *
+trace_transfer_create(struct trace_texture *tr_tex,
+                     struct pipe_transfer *transfer)
+{
+   struct trace_transfer *tr_trans;
+
+   if(!transfer)
+      goto error;
+
+   assert(transfer->texture == tr_tex->texture);
+
+   tr_trans = CALLOC_STRUCT(trace_transfer);
+   if(!tr_trans)
+      goto error;
+
+   memcpy(&tr_trans->base, transfer, sizeof(struct pipe_transfer));
+
+   tr_trans->base.texture = NULL;
+   pipe_texture_reference(&tr_trans->base.texture, &tr_tex->base);
+   tr_trans->transfer = transfer;
+   assert(tr_trans->base.texture == &tr_tex->base);
+
+   return &tr_trans->base;
+
+error:
+   transfer->texture->screen->tex_transfer_destroy(transfer);
+   return NULL;
+}
+
+
+void
+trace_transfer_destroy(struct trace_texture *tr_tex,
+                      struct pipe_transfer *transfer)
+{
+   struct trace_transfer *tr_trans = trace_transfer(tr_tex, transfer);
+   struct pipe_screen *screen = tr_trans->transfer->texture->screen;
+   pipe_texture_reference(&tr_trans->base.texture, NULL);
+   screen->tex_transfer_destroy(tr_trans->transfer);
+   FREE(tr_trans);
+}
+
diff --git a/src/gallium/drivers/trace/tr_texture.h b/src/gallium/drivers/trace/tr_texture.h
index 9e72edb8a3c..9c21bc7d276 100644
--- a/src/gallium/drivers/trace/tr_texture.h
+++ b/src/gallium/drivers/trace/tr_texture.h
@@ -48,48 +48,78 @@ struct trace_surface
    struct pipe_surface base;
 
    struct pipe_surface *surface;
-   
+};
+
+
+struct trace_transfer
+{
+   struct pipe_transfer base;
+
+   struct pipe_transfer *transfer;
+
    void *map;
 };
 
 
 static INLINE struct trace_texture *
-trace_texture(struct trace_screen *tr_scr, 
+trace_texture(struct trace_screen *tr_scr,
               struct pipe_texture *texture)
 {
    if(!texture)
       return NULL;
+   assert(tr_scr);
    assert(texture->screen == &tr_scr->base);
    return (struct trace_texture *)texture;
 }
 
 
 static INLINE struct trace_surface *
-trace_surface(struct trace_texture *tr_tex, 
+trace_surface(struct trace_texture *tr_tex,
               struct pipe_surface *surface)
 {
    if(!surface)
       return NULL;
+   assert(tr_tex);
    assert(surface->texture == &tr_tex->base);
    return (struct trace_surface *)surface;
 }
 
 
+static INLINE struct trace_transfer *
+trace_transfer(struct trace_texture *tr_tex,
+               struct pipe_transfer *transfer)
+{
+   if(!transfer)
+      return NULL;
+   assert(tr_tex);
+   assert(transfer->texture == &tr_tex->base);
+   return (struct trace_transfer *)transfer;
+}
+
+
 struct pipe_texture *
-trace_texture_create(struct trace_screen *tr_scr, 
+trace_texture_create(struct trace_screen *tr_scr,
                      struct pipe_texture *texture);
 
 void
-trace_texture_destroy(struct trace_screen *tr_scr, 
+trace_texture_destroy(struct trace_screen *tr_scr,
                       struct pipe_texture *texture);
 
 struct pipe_surface *
-trace_surface_create(struct trace_texture *tr_tex, 
+trace_surface_create(struct trace_texture *tr_tex,
                      struct pipe_surface *surface);
 
 void
 trace_surface_destroy(struct trace_texture *tr_tex,
                       struct pipe_surface *surface);
 
+struct pipe_transfer *
+trace_transfer_create(struct trace_texture *tr_tex,
+                      struct pipe_transfer *transfer);
+
+void
+trace_transfer_destroy(struct trace_texture *tr_tex,
+                       struct pipe_transfer *transfer);
+
 
 #endif /* TR_TEXTURE_H_ */
diff --git a/src/gallium/drivers/trace/tr_winsys.c b/src/gallium/drivers/trace/tr_winsys.c
deleted file mode 100644
index c4148fe8104..00000000000
--- a/src/gallium/drivers/trace/tr_winsys.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * 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 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 TUNGSTEN GRAPHICS AND/OR ITS 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 "util/u_memory.h"
-#include "util/u_hash_table.h"
-
-#include "tr_dump.h"
-#include "tr_state.h"
-#include "tr_screen.h"
-#include "tr_texture.h"
-#include "tr_winsys.h"
-
-
-static unsigned trace_buffer_hash(void *buffer)
-{
-   return (unsigned)(uintptr_t)buffer;
-}
-
-
-static int trace_buffer_compare(void *buffer1, void *buffer2)
-{
-   return (char *)buffer2 - (char *)buffer1;
-}
-
-                  
-static const char *
-trace_winsys_get_name(struct pipe_winsys *_winsys)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   const char *result;
-   
-   trace_dump_call_begin("pipe_winsys", "get_name");
-   
-   trace_dump_arg(ptr, winsys);
-
-   result = winsys->get_name(winsys);
-   
-   trace_dump_ret(string, result);
-   
-   trace_dump_call_end();
-   
-   return result;
-}
-
-
-static void 
-trace_winsys_flush_frontbuffer(struct pipe_winsys *_winsys,
-                               struct pipe_surface *surface,
-                               void *context_private)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-
-   assert(surface);
-   if(surface->texture) {
-      struct trace_screen *tr_scr = trace_screen(surface->texture->screen);
-      struct trace_texture *tr_tex = trace_texture(tr_scr, surface->texture);
-      struct trace_surface *tr_surf = trace_surface(tr_tex, surface);
-      surface = tr_surf->surface;
-   }
-   
-   trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(ptr, surface);
-   /* XXX: hide, as there is nothing we can do with this
-   trace_dump_arg(ptr, context_private);
-   */
-
-   winsys->flush_frontbuffer(winsys, surface, context_private);
-   
-   trace_dump_call_end();
-}
-
-
-static struct pipe_buffer *
-trace_winsys_surface_buffer_create(struct pipe_winsys *_winsys,
-                                   unsigned width, unsigned height,
-                                   enum pipe_format format,
-                                   unsigned usage,
-                                   unsigned *pstride)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   unsigned stride;
-   struct pipe_buffer *result;
-   
-   trace_dump_call_begin("pipe_winsys", "surface_buffer_create");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(uint, width);
-   trace_dump_arg(uint, height);
-   trace_dump_arg(format, format);
-   trace_dump_arg(uint, usage);
-
-   result = winsys->surface_buffer_create(winsys,
-                                          width, height,
-                                          format,
-                                          usage,
-                                          pstride);
-   
-   stride = *pstride;
-   
-   trace_dump_arg(uint, stride);
-   
-   trace_dump_ret(ptr, result);
-   
-   trace_dump_call_end();
-   
-   return result;
-}
-
-
-static struct pipe_buffer *
-trace_winsys_buffer_create(struct pipe_winsys *_winsys, 
-                           unsigned alignment, 
-                           unsigned usage,
-                           unsigned size)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   struct pipe_buffer *buffer;
-   
-   trace_dump_call_begin("pipe_winsys", "buffer_create");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(uint, alignment);
-   trace_dump_arg(uint, usage);
-   trace_dump_arg(uint, size);
-
-   buffer = winsys->buffer_create(winsys, alignment, usage, size);
-   
-   trace_dump_ret(ptr, buffer);
-   
-   trace_dump_call_end();
-
-   /* Zero the buffer to avoid dumping uninitialized memory */
-   if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-      void *map;
-      map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
-      if(map) {
-         memset(map, 0, buffer->size);
-         winsys->buffer_unmap(winsys, buffer);
-      }
-   }
-   
-   return buffer;
-}
-
-
-static struct pipe_buffer *
-trace_winsys_user_buffer_create(struct pipe_winsys *_winsys, 
-                                void *data,
-                                unsigned size)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   struct pipe_buffer *result;
-   
-   trace_dump_call_begin("pipe_winsys", "user_buffer_create");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg_begin("data");
-   trace_dump_bytes(data, size);
-   trace_dump_arg_end();
-   trace_dump_arg(uint, size);
-
-   result = winsys->user_buffer_create(winsys, data, size);
-   
-   trace_dump_ret(ptr, result);
-   
-   trace_dump_call_end();
-   
-   /* XXX: Mark the user buffers. (we should wrap pipe_buffers, but is is 
-    * impossible to do so while texture-less surfaces are still around */
-   if(result) {
-      assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
-      result->usage |= TRACE_BUFFER_USAGE_USER;
-   }
-   
-   return result;
-}
-
-
-void
-trace_winsys_user_buffer_update(struct pipe_winsys *_winsys, 
-                                struct pipe_buffer *buffer)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   const void *map;
-   
-   if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
-      map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
-      if(map) {
-         trace_dump_call_begin("pipe_winsys", "buffer_write");
-         
-         trace_dump_arg(ptr, winsys);
-         
-         trace_dump_arg(ptr, buffer);
-         
-         trace_dump_arg_begin("data");
-         trace_dump_bytes(map, buffer->size);
-         trace_dump_arg_end();
-      
-         trace_dump_arg_begin("size");
-         trace_dump_uint(buffer->size);
-         trace_dump_arg_end();
-      
-         trace_dump_call_end();
-         
-         winsys->buffer_unmap(winsys, buffer);
-      }
-   }
-}
-
-
-static void *
-trace_winsys_buffer_map(struct pipe_winsys *_winsys, 
-                        struct pipe_buffer *buffer,
-                        unsigned usage)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   void *map;
-   
-   map = winsys->buffer_map(winsys, buffer, usage);
-   if(map) {
-      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         assert(!hash_table_get(tr_ws->buffer_maps, buffer));
-         hash_table_set(tr_ws->buffer_maps, buffer, map);
-      }
-   }
-   
-   return map;
-}
-
-
-static void
-trace_winsys_buffer_unmap(struct pipe_winsys *_winsys, 
-                          struct pipe_buffer *buffer)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   const void *map;
-   
-   map = hash_table_get(tr_ws->buffer_maps, buffer);
-   if(map) {
-      trace_dump_call_begin("pipe_winsys", "buffer_write");
-      
-      trace_dump_arg(ptr, winsys);
-      
-      trace_dump_arg(ptr, buffer);
-      
-      trace_dump_arg_begin("data");
-      trace_dump_bytes(map, buffer->size);
-      trace_dump_arg_end();
-
-      trace_dump_arg_begin("size");
-      trace_dump_uint(buffer->size);
-      trace_dump_arg_end();
-   
-      trace_dump_call_end();
-
-      hash_table_remove(tr_ws->buffer_maps, buffer);
-   }
-   
-   winsys->buffer_unmap(winsys, buffer);
-}
-
-
-static void
-trace_winsys_buffer_destroy(struct pipe_winsys *_winsys,
-                            struct pipe_buffer *buffer)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   
-   trace_dump_call_begin("pipe_winsys", "buffer_destroy");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(ptr, buffer);
-
-   winsys->buffer_destroy(winsys, buffer);
-   
-   trace_dump_call_end();
-}
-
-
-static void
-trace_winsys_fence_reference(struct pipe_winsys *_winsys,
-                             struct pipe_fence_handle **pdst,
-                             struct pipe_fence_handle *src)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   struct pipe_fence_handle *dst = *pdst;
-   
-   trace_dump_call_begin("pipe_winsys", "fence_reference");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(ptr, dst);
-   trace_dump_arg(ptr, src);
-
-   winsys->fence_reference(winsys, pdst, src);
-   
-   trace_dump_call_end();
-}
-
-
-static int
-trace_winsys_fence_signalled(struct pipe_winsys *_winsys,
-                             struct pipe_fence_handle *fence,
-                             unsigned flag)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   int result;
-   
-   trace_dump_call_begin("pipe_winsys", "fence_signalled");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(ptr, fence);
-   trace_dump_arg(uint, flag);
-
-   result = winsys->fence_signalled(winsys, fence, flag);
-   
-   trace_dump_ret(int, result);
-   
-   trace_dump_call_end();
-   
-   return result;
-}
-
-
-static int
-trace_winsys_fence_finish(struct pipe_winsys *_winsys,
-                          struct pipe_fence_handle *fence,
-                          unsigned flag)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   int result;
-   
-   trace_dump_call_begin("pipe_winsys", "fence_finish");
-   
-   trace_dump_arg(ptr, winsys);
-   trace_dump_arg(ptr, fence);
-   trace_dump_arg(uint, flag);
-
-   result = winsys->fence_finish(winsys, fence, flag);
-   
-   trace_dump_ret(int, result);
-   
-   trace_dump_call_end();
-   
-   return result;
-}
-
-
-static void
-trace_winsys_destroy(struct pipe_winsys *_winsys)
-{
-   struct trace_winsys *tr_ws = trace_winsys(_winsys);
-   struct pipe_winsys *winsys = tr_ws->winsys;
-   
-   trace_dump_call_begin("pipe_winsys", "destroy");
-   
-   trace_dump_arg(ptr, winsys);
-
-   /* 
-   winsys->destroy(winsys); 
-   */
-   
-   trace_dump_call_end();
-   
-   hash_table_destroy(tr_ws->buffer_maps);
-
-   FREE(tr_ws);
-}
-
-
-struct pipe_winsys *
-trace_winsys_create(struct pipe_winsys *winsys)
-{
-   struct trace_winsys *tr_ws;
-   
-   if(!winsys)
-      goto error1;
-   
-   tr_ws = CALLOC_STRUCT(trace_winsys);
-   if(!tr_ws)
-      goto error1;
-
-   tr_ws->base.destroy = trace_winsys_destroy;
-   tr_ws->base.get_name = trace_winsys_get_name;
-   tr_ws->base.flush_frontbuffer = trace_winsys_flush_frontbuffer;
-   tr_ws->base.surface_buffer_create = trace_winsys_surface_buffer_create;
-   tr_ws->base.buffer_create = trace_winsys_buffer_create;
-   tr_ws->base.user_buffer_create = trace_winsys_user_buffer_create;
-   tr_ws->base.buffer_map = trace_winsys_buffer_map;
-   tr_ws->base.buffer_unmap = trace_winsys_buffer_unmap;
-   tr_ws->base.buffer_destroy = trace_winsys_buffer_destroy;
-   tr_ws->base.fence_reference = trace_winsys_fence_reference;
-   tr_ws->base.fence_signalled = trace_winsys_fence_signalled;
-   tr_ws->base.fence_finish = trace_winsys_fence_finish;
-   
-   tr_ws->winsys = winsys;
-
-   tr_ws->buffer_maps = hash_table_create(trace_buffer_hash, 
-                                          trace_buffer_compare);
-   if(!tr_ws->buffer_maps)
-      goto error2;
-   
-   trace_dump_call_begin("", "pipe_winsys_create");
-   trace_dump_ret(ptr, winsys);
-   trace_dump_call_end();
-
-   return &tr_ws->base;
-   
-error2:
-   FREE(tr_ws);
-error1:
-   return winsys;
-}