25 files changed, 868 insertions, 988 deletions

diff --git a/src/mesa/state_tracker/st_atom_shader.c b/src/mesa/state_tracker/st_atom_shader.c
index d4976941f9..4ec10badad 100644
--- a/src/mesa/state_tracker/st_atom_shader.c
+++ b/src/mesa/state_tracker/st_atom_shader.c
@@ -41,7 +41,7 @@
 #include "main/mtypes.h"
 
 #include "pipe/p_context.h"
-#include "pipe/tgsi/exec/tgsi_core.h"
+#include "pipe/p_shader_tokens.h"
 
 #include "st_context.h"
 #include "st_cache.h"
diff --git a/src/mesa/state_tracker/st_atom_texture.c b/src/mesa/state_tracker/st_atom_texture.c
index f25cfd386a..c4e5af02d5 100644
--- a/src/mesa/state_tracker/st_atom_texture.c
+++ b/src/mesa/state_tracker/st_atom_texture.c
@@ -51,24 +51,24 @@ update_textures(struct st_context *st)
    for (u = 0; u < st->ctx->Const.MaxTextureImageUnits; u++) {
       struct gl_texture_object *texObj
          = st->ctx->Texture.Unit[u]._Current;
-      struct pipe_mipmap_tree *mt;
+      struct pipe_texture *pt;
       if (texObj) {
          GLboolean flush, retval;
 
-         retval = st_finalize_mipmap_tree(st->ctx, st->pipe, u, &flush);
+         retval = st_finalize_texture(st->ctx, st->pipe, u, &flush);
 #if 0
-         printf("finalize_mipmap_tree returned %d, flush = %d\n",
+         printf("finalize_texture returned %d, flush = %d\n",
                 retval, flush);
 #endif
 
-         mt = st_get_texobj_mipmap_tree(texObj);
+         pt = st_get_texobj_texture(texObj);
       }
       else {
-         mt = NULL;
+         pt = NULL;
       }
 
-      st->state.texture[u] = mt;
-      st->pipe->set_texture_state(st->pipe, u, mt);
+      st->state.texture[u] = pt;
+      st->pipe->set_texture_state(st->pipe, u, pt);
    }
 }
 
diff --git a/src/mesa/state_tracker/st_cb_accum.c b/src/mesa/state_tracker/st_cb_accum.c
index 7a245b0ed6..c8d9cba12f 100644
--- a/src/mesa/state_tracker/st_cb_accum.c
+++ b/src/mesa/state_tracker/st_cb_accum.c
@@ -42,6 +42,7 @@
 #include "st_format.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_inlines.h"
 
 
 /**
@@ -68,7 +69,7 @@ st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
    GLfloat *accBuf;
    GLint i;
 
-   (void) pipe->region_map(pipe, acc_ps->region);
+   (void) pipe_surface_map(acc_ps);
 
    accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
@@ -83,7 +84,7 @@ st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 
    free(accBuf);
 
-   pipe->region_unmap(pipe, acc_ps->region);
+   pipe_surface_unmap(acc_ps);
 }
 
 
@@ -99,7 +100,7 @@ accum_mad(struct pipe_context *pipe, GLfloat scale, GLfloat bias,
 
    accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
-   (void) pipe->region_map(pipe, acc_ps->region);
+   (void) pipe_surface_map(acc_ps);
 
    pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
 
@@ -111,7 +112,7 @@ accum_mad(struct pipe_context *pipe, GLfloat scale, GLfloat bias,
 
    free(accBuf);
 
-   pipe->region_unmap(pipe, acc_ps->region);
+   pipe_surface_unmap(acc_ps);
 }
 
 
@@ -128,8 +129,8 @@ accum_accum(struct pipe_context *pipe, GLfloat value,
    colorBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
    accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
-   colorMap = pipe->region_map(pipe, color_ps->region);
-   accMap = pipe->region_map(pipe, acc_ps->region);
+   colorMap = pipe_surface_map(color_ps);
+   accMap = pipe_surface_map(acc_ps);
 
    pipe->get_tile_rgba(pipe, color_ps, xpos, ypos, width, height, colorBuf);
    pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
@@ -143,8 +144,8 @@ accum_accum(struct pipe_context *pipe, GLfloat value,
    free(colorBuf);
    free(accBuf);
 
-   pipe->region_unmap(pipe, color_ps->region);
-   pipe->region_unmap(pipe, acc_ps->region);
+   pipe_surface_unmap(color_ps);
+   pipe_surface_unmap(acc_ps);
 }
 
 
@@ -159,8 +160,8 @@ accum_load(struct pipe_context *pipe, GLfloat value,
 
    buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
-   (void) pipe->region_map(pipe, color_ps->region);
-   (void) pipe->region_map(pipe, acc_ps->region);
+   (void) pipe_surface_map(color_ps);
+   (void) pipe_surface_map(acc_ps);
 
    pipe->get_tile_rgba(pipe, color_ps, xpos, ypos, width, height, buf);
 
@@ -172,8 +173,8 @@ accum_load(struct pipe_context *pipe, GLfloat value,
 
    free(buf);
 
-   pipe->region_unmap(pipe, color_ps->region);
-   pipe->region_unmap(pipe, acc_ps->region);
+   pipe_surface_unmap(color_ps);
+   pipe_surface_unmap(acc_ps);
 }
 
 
@@ -190,8 +191,8 @@ accum_return(GLcontext *ctx, GLfloat value,
 
    abuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
-   (void) pipe->region_map(pipe, color_ps->region);
-   (void) pipe->region_map(pipe, acc_ps->region);
+   (void) pipe_surface_map(color_ps);
+   (void) pipe_surface_map(acc_ps);
 
    pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, abuf);
 
@@ -218,8 +219,8 @@ accum_return(GLcontext *ctx, GLfloat value,
    if (cbuf)
       free(cbuf);
 
-   pipe->region_unmap(pipe, color_ps->region);
-   pipe->region_unmap(pipe, acc_ps->region);
+   pipe_surface_unmap(color_ps);
+   pipe_surface_unmap(acc_ps);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index 219a5afcbd..b4b2429a2a 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -55,7 +55,7 @@
 
 
 static GLuint
-color_value(GLuint pipeFormat, const GLfloat color[4])
+color_value(enum pipe_format pipeFormat, const GLfloat color[4])
 {
    GLubyte r, g, b, a;
 
@@ -65,33 +65,36 @@ color_value(GLuint pipeFormat, const GLfloat color[4])
    UNCLAMPED_FLOAT_TO_UBYTE(a, color[3]);
 
    switch (pipeFormat) {
-   case PIPE_FORMAT_U_R8_G8_B8_A8:
+   case PIPE_FORMAT_R8G8B8A8_UNORM:
       return (r << 24) | (g << 16) | (b << 8) | a;
-   case PIPE_FORMAT_U_A8_R8_G8_B8:
+   case PIPE_FORMAT_A8R8G8B8_UNORM:
       return (a << 24) | (r << 16) | (g << 8) | b;
-   case PIPE_FORMAT_U_R5_G6_B5:
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+      return (b << 24) | (g << 16) | (r << 8) | a;
+   case PIPE_FORMAT_R5G6B5_UNORM:
       return ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);
    default:
+      assert(0);
       return 0;
    }
 }
  
 
 static uint
-depth_value(GLuint pipeFormat, GLfloat value)
+depth_value(enum pipe_format pipeFormat, GLfloat value)
 {
    switch (pipeFormat) {
-   case PIPE_FORMAT_U_Z16:
+   case PIPE_FORMAT_Z16_UNORM:
       return (uint) (value * 0xffff);
-   case PIPE_FORMAT_U_Z32:
+   case PIPE_FORMAT_Z32_UNORM:
       /* special-case to avoid overflow */
       if (value == 1.0)
          return 0xffffffff;
       else
          return (uint) (value * 0xffffffff);
-   case PIPE_FORMAT_S8_Z24:
+   case PIPE_FORMAT_S8Z24_UNORM:
       return (uint) (value * 0xffffff);
-   case PIPE_FORMAT_Z24_S8:
+   case PIPE_FORMAT_Z24S8_UNORM:
       return ((uint) (value * 0xffffff)) << 8;
    default:
       assert(0);
@@ -101,11 +104,11 @@ depth_value(GLuint pipeFormat, GLfloat value)
 
 
 static GLboolean
-is_depth_stencil_format(GLuint pipeFormat)
+is_depth_stencil_format(enum pipe_format pipeFormat)
 {
    switch (pipeFormat) {
-   case PIPE_FORMAT_S8_Z24:
-   case PIPE_FORMAT_Z24_S8:
+   case PIPE_FORMAT_S8Z24_UNORM:
+   case PIPE_FORMAT_Z24S8_UNORM:
       return GL_TRUE;
    default:
       return GL_FALSE;
@@ -520,10 +523,10 @@ clear_depth_stencil_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
       GLuint clearValue = depth_value(strb->surface->format, ctx->Depth.Clear);
 
       switch (strb->surface->format) {
-      case PIPE_FORMAT_S8_Z24:
+      case PIPE_FORMAT_S8Z24_UNORM:
          clearValue |= ctx->Stencil.Clear << 24;
          break;
-      case PIPE_FORMAT_Z24_S8:
+      case PIPE_FORMAT_Z24S8_UNORM:
          clearValue |= clearValue | ctx->Stencil.Clear;
          break;
       default:
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index df41d5ce5b..c0e41dbeec 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -33,6 +33,7 @@
 #include "main/imports.h"
 #include "main/image.h"
 #include "main/macros.h"
+#include "main/texformat.h"
 #include "shader/program.h"
 #include "shader/prog_parameter.h"
 #include "shader/prog_print.h"
@@ -50,6 +51,7 @@
 #include "st_draw.h"
 #include "st_format.h"
 #include "st_mesa_to_tgsi.h"
+#include "st_texture.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
@@ -440,65 +442,22 @@ _mesa_base_format(GLenum format)
 }
 
 
-
-static struct pipe_mipmap_tree *
-alloc_mipmap_tree(struct st_context *st,
-                  GLsizei width, GLsizei height, uint pipeFormat)
-{
-   const GLbitfield flags = PIPE_SURFACE_FLAG_TEXTURE;
-   struct pipe_mipmap_tree *mt;
-   GLuint cpp;
-
-   mt = CALLOC_STRUCT(pipe_mipmap_tree);
-   if (!mt)
-      return NULL;
-
-   cpp = st_sizeof_format(pipeFormat);
-
-   /* allocate texture region/storage */
-   mt->region = st->pipe->winsys->region_alloc(st->pipe->winsys,
-                                               cpp, width, height, flags);
-
-   mt->target = PIPE_TEXTURE_2D;
-   mt->internal_format = GL_RGBA;
-   mt->format = pipeFormat;
-   mt->first_level = 0;
-   mt->last_level = 0;
-   mt->width0 = width;
-   mt->height0 = height;
-   mt->depth0 = 1;
-   mt->cpp = cpp;
-   mt->compressed = 0;
-   mt->pitch = mt->region->pitch;
-   mt->depth_pitch = 0;
-   mt->total_height = height;
-   mt->level[0].level_offset = 0;
-   mt->level[0].width = width;
-   mt->level[0].height = height;
-   mt->level[0].depth = 1;
-   mt->level[0].nr_images = 1;
-   mt->level[0].image_offset = NULL;
-   mt->refcount = 1;
-
-   return mt;
-}
-
-
 /**
- * Make mipmap tree containing an image for glDrawPixels image.
+ * Make texture containing an image for glDrawPixels image.
  * If 'pixels' is NULL, leave the texture image data undefined.
  */
-static struct pipe_mipmap_tree *
-make_mipmap_tree(struct st_context *st,
-                 GLsizei width, GLsizei height, GLenum format, GLenum type,
-                 const struct gl_pixelstore_attrib *unpack,
-                 const GLvoid *pixels)
+static struct pipe_texture *
+make_texture(struct st_context *st,
+	     GLsizei width, GLsizei height, GLenum format, GLenum type,
+	     const struct gl_pixelstore_attrib *unpack,
+	     const GLvoid *pixels)
 {
    GLcontext *ctx = st->ctx;
    struct pipe_context *pipe = st->pipe;
    const struct gl_texture_format *mformat;
-   struct pipe_mipmap_tree *mt;
-   GLuint pipeFormat, cpp;
+   struct pipe_texture *pt;
+   enum pipe_format pipeFormat;
+   GLuint cpp;
    GLenum baseFormat;
 
    baseFormat = _mesa_base_format(format);
@@ -510,31 +469,34 @@ make_mipmap_tree(struct st_context *st,
    assert(pipeFormat);
    cpp = st_sizeof_format(pipeFormat);
 
-   mt = alloc_mipmap_tree(st, width, height, pipeFormat);
-   if (!mt)
+   pt = st_texture_create(st, PIPE_TEXTURE_2D, pipeFormat, baseFormat, 0, 0,
+			  width, height, 1, 0);
+   if (!pt)
       return NULL;
 
    if (unpack->BufferObj && unpack->BufferObj->Name) {
       /*
-      mt->region = buffer_object_region(unpack->BufferObj);
+      pt->region = buffer_object_region(unpack->BufferObj);
       */
       printf("st_DrawPixels (sourcing from PBO not implemented yet)\n");
    }
 
    {
+      struct pipe_surface *surface;
       static const GLuint dstImageOffsets = 0;
       GLboolean success;
-      GLuint pitch = mt->region->pitch;
       GLubyte *dest;
       const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;
 
       /* we'll do pixel transfer in a fragment shader */
       ctx->_ImageTransferState = 0x0;
 
-      /* map texture region */
-      dest = pipe->region_map(pipe, mt->region);
+      surface = pipe->get_tex_surface(pipe, pt, 0, 0, 0);
 
-      /* Put image into texture region.
+      /* map texture surface */
+      dest = pipe_surface_map(surface);
+
+      /* Put image into texture surface.
        * Note that the image is actually going to be upside down in
        * the texture.  We deal with that with texcoords.
        */
@@ -543,7 +505,7 @@ make_mipmap_tree(struct st_context *st,
                                     mformat,          /* gl_texture_format */
                                     dest,             /* dest */
                                     0, 0, 0,          /* dstX/Y/Zoffset */
-                                    pitch * cpp,      /* dstRowStride, bytes */
+                                    surface->pitch * cpp, /* dstRowStride, bytes */
                                     &dstImageOffsets, /* dstImageOffsets */
                                     width, height, 1, /* size */
                                     format, type,     /* src format/type */
@@ -551,44 +513,15 @@ make_mipmap_tree(struct st_context *st,
                                     unpack);
 
       /* unmap */
-      pipe->region_unmap(pipe, mt->region);
+      pipe_surface_unmap(surface);
+      pipe_surface_reference(&surface, NULL);
       assert(success);
 
       /* restore */
       ctx->_ImageTransferState = imageTransferStateSave;
    }
 
-#if 0
-   mt->target = PIPE_TEXTURE_2D;
-   mt->internal_format = GL_RGBA;
-   mt->format = pipeFormat;
-   mt->first_level = 0;
-   mt->last_level = 0;
-   mt->width0 = width;
-   mt->height0 = height;
-   mt->depth0 = 1;
-   mt->cpp = cpp;
-   mt->compressed = 0;
-   mt->pitch = mt->region->pitch;
-   mt->depth_pitch = 0;
-   mt->total_height = height;
-   mt->level[0].level_offset = 0;
-   mt->level[0].width = width;
-   mt->level[0].height = height;
-   mt->level[0].depth = 1;
-   mt->level[0].nr_images = 1;
-   mt->level[0].image_offset = NULL;
-   mt->refcount = 1;
-#endif
-   return mt;
-}
-
-
-static void
-free_mipmap_tree(struct pipe_context *pipe, struct pipe_mipmap_tree *mt)
-{
-   pipe->winsys->region_release(pipe->winsys, &mt->region);
-   free(mt);
+   return pt;
 }
 
 
@@ -694,7 +627,7 @@ static void
 draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
                    GLsizei width, GLsizei height,
                    GLfloat zoomX, GLfloat zoomY,
-                   struct pipe_mipmap_tree *mt,
+                   struct pipe_texture *pt,
                    struct st_vertex_program *stvp,
                    struct st_fragment_program *stfp,
                    const GLfloat *color,
@@ -762,9 +695,9 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
       pipe->set_viewport_state(pipe, &vp);
    }
 
-   /* mipmap tree state: */
+   /* texture state: */
    {
-      pipe->set_texture_state(pipe, unit, mt);
+      pipe->set_texture_state(pipe, unit, pt);
    }
 
    /* Compute window coords (y=0=bottom) with pixel zoom.
@@ -797,47 +730,47 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
  * XXX probably move this to a re-usable place.
  */
 static GLboolean
-compatible_formats(GLenum format, GLenum type, GLuint pipeFormat)
+compatible_formats(GLenum format, GLenum type, enum pipe_format pipeFormat)
 {
    static const GLuint one = 1;
    GLubyte littleEndian = *((GLubyte *) &one);
 
-   if (pipeFormat == PIPE_FORMAT_U_R8_G8_B8_A8 &&
+   if (pipeFormat == PIPE_FORMAT_R8G8B8A8_UNORM &&
        format == GL_RGBA &&
        type == GL_UNSIGNED_BYTE &&
        !littleEndian) {
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_R8_G8_B8_A8 &&
+   else if (pipeFormat == PIPE_FORMAT_R8G8B8A8_UNORM &&
             format == GL_ABGR_EXT &&
             type == GL_UNSIGNED_BYTE &&
             littleEndian) {
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_A8_R8_G8_B8 &&
+   else if (pipeFormat == PIPE_FORMAT_A8R8G8B8_UNORM &&
             format == GL_BGRA &&
             type == GL_UNSIGNED_BYTE &&
             littleEndian) {
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_R5_G6_B5 &&
+   else if (pipeFormat == PIPE_FORMAT_R5G6B5_UNORM &&
             format == GL_RGB &&
             type == GL_UNSIGNED_SHORT_5_6_5) {
       /* endian don't care */
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_R5_G6_B5 &&
+   else if (pipeFormat == PIPE_FORMAT_R5G6B5_UNORM &&
             format == GL_BGR &&
             type == GL_UNSIGNED_SHORT_5_6_5_REV) {
       /* endian don't care */
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_S8 &&
+   else if (pipeFormat == PIPE_FORMAT_S8_UNORM &&
             format == GL_STENCIL_INDEX &&
             type == GL_UNSIGNED_BYTE) {
       return GL_TRUE;
    }
-   else if (pipeFormat == PIPE_FORMAT_U_Z32 &&
+   else if (pipeFormat == PIPE_FORMAT_Z32_UNORM &&
             format == GL_DEPTH_COMPONENT &&
             type == GL_UNSIGNED_INT) {
       return GL_TRUE;
@@ -919,7 +852,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
    pipe->flush(pipe, 0);
 
    /* map the stencil buffer */
-   stmap = pipe->region_map(pipe, ps->region);
+   stmap = pipe_surface_map(ps);
 
    /* if width > MAX_WIDTH, have to process image in chunks */
    skipPixels = 0;
@@ -952,13 +885,13 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
             switch (ps->format) {
             case PIPE_FORMAT_U_S8:
                {
-                  ubyte *dest = stmap + spanY * ps->region->pitch + spanX;
+                  ubyte *dest = stmap + spanY * ps->pitch + spanX;
                   memcpy(dest, values, spanWidth);
                }
                break;
-            case PIPE_FORMAT_S8_Z24:
+            case PIPE_FORMAT_S8Z24_UNORM:
                {
-                  uint *dest = (uint *) stmap + spanY * ps->region->pitch + spanX;
+                  uint *dest = (uint *) stmap + spanY * ps->pitch + spanX;
                   GLint k;
                   for (k = 0; k < spanWidth; k++) {
                      uint p = dest[k];
@@ -976,7 +909,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
    }
 
    /* unmap the stencil buffer */
-   pipe->region_unmap(pipe, ps->region);
+   pipe_surface_unmap(ps);
 }
 
 
@@ -1026,14 +959,13 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
        any_pixel_transfer_ops(st) ||
        !compatible_formats(format, type, ps->format)) {
       /* textured quad */
-      struct pipe_mipmap_tree *mt
-         = make_mipmap_tree(ctx->st, width, height, format, type,
-                            unpack, pixels);
-      if (mt) {
+      struct pipe_texture *pt
+         = make_texture(ctx->st, width, height, format, type, unpack, pixels);
+      if (pt) {
          draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
                             width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                            mt, stvp, stfp, color, GL_FALSE);
-         free_mipmap_tree(st->pipe, mt);
+                            pt, stvp, stfp, color, GL_FALSE);
+	 st->pipe->texture_release(st->pipe, &pt);
       }
    }
    else {
@@ -1047,26 +979,29 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 /**
  * Create a texture which represents a bitmap image.
  */
-static struct pipe_mipmap_tree *
+static struct pipe_texture *
 make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
                     const struct gl_pixelstore_attrib *unpack,
                     const GLubyte *bitmap)
 {
    struct pipe_context *pipe = ctx->st->pipe;
-   const uint flags = PIPE_SURFACE_FLAG_TEXTURE;
-   uint format = 0, cpp, comp, pitch;
+   struct pipe_surface *surface;
+   uint format = 0, cpp, comp;
+   GLenum internal_format;
    ubyte *dest;
-   struct pipe_mipmap_tree *mt;
+   struct pipe_texture *pt;
    int row, col;
 
    /* find a texture format we know */
    if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_I8 )) {
       format = PIPE_FORMAT_U_I8;
+      internal_format = GL_INTENSITY8;
       cpp = 1;
       comp = 0;
    }
-   else if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8_R8_G8_B8 )) {
-      format = PIPE_FORMAT_U_A8_R8_G8_B8;
+   else if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM )) {
+      format = PIPE_FORMAT_A8R8G8B8_UNORM;
+      internal_format = GL_RGBA8;
       cpp = 4;
       comp = 3; /* alpha channel */ /*XXX little-endian dependency */
    }
@@ -1076,33 +1011,26 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
    }
 
    /**
-    * Create a mipmap tree.
+    * Create a texture.
     */
-   mt = CALLOC_STRUCT(pipe_mipmap_tree);
-   if (!mt)
+   pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, format, internal_format,
+			  0, 0, width, height, 1, 0);
+   if (!pt)
       return NULL;
 
    if (unpack->BufferObj && unpack->BufferObj->Name) {
       /*
-      mt->region = buffer_object_region(unpack->BufferObj);
+      pt->region = buffer_object_region(unpack->BufferObj);
       */
       printf("st_Bitmap (sourcing from PBO not implemented yet)\n");
    }
 
+   surface = pipe->get_tex_surface(pipe, pt, 0, 0, 0);
 
-   /* allocate texture region/storage */
-   mt->region = pipe->winsys->region_alloc(pipe->winsys,
-                                           cpp, width, height, flags);
-   pitch = mt->region->pitch;
+   /* map texture surface */
+   dest = pipe_surface_map(surface);
 
-   /* map texture region */
-   dest = pipe->region_map(pipe, mt->region);
-   if (!dest) {
-      printf("st_Bitmap region_map() failed!?!");
-      return NULL;
-   }
-
-   /* Put image into texture region.
+   /* Put image into texture surface.
     * Note that the image is actually going to be upside down in
     * the texture.  We deal with that with texcoords.
     */
@@ -1110,7 +1038,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
    for (row = 0; row < height; row++) {
       const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
                  bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
-      ubyte *destRow = dest + row * pitch * cpp;
+      ubyte *destRow = dest + row * surface->pitch * cpp;
 
       if (unpack->LsbFirst) {
          /* Lsb first */
@@ -1159,31 +1087,13 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
 
    } /* row */
 
-   /* unmap */
-   pipe->region_unmap(pipe, mt->region);
+   /* Release surface */
+   pipe_surface_unmap(surface);
+   pipe_surface_reference(&surface, NULL);
 
-   mt->target = PIPE_TEXTURE_2D;
-   mt->internal_format = GL_RGBA;
-   mt->format = format;
-   mt->first_level = 0;
-   mt->last_level = 0;
-   mt->width0 = width;
-   mt->height0 = height;
-   mt->depth0 = 1;
-   mt->cpp = cpp;
-   mt->compressed = 0;
-   mt->pitch = mt->region->pitch;
-   mt->depth_pitch = 0;
-   mt->total_height = height;
-   mt->level[0].level_offset = 0;
-   mt->level[0].width = width;
-   mt->level[0].height = height;
-   mt->level[0].depth = 1;
-   mt->level[0].nr_images = 1;
-   mt->level[0].image_offset = NULL;
-   mt->refcount = 1;
+   pt->format = format;
 
-   return mt;
+   return pt;
 }
 
 
@@ -1195,21 +1105,21 @@ st_Bitmap(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
    struct st_fragment_program *stfp;
    struct st_vertex_program *stvp;
    struct st_context *st = ctx->st;
-   struct pipe_mipmap_tree *mt;
+   struct pipe_texture *pt;
 
    stvp = make_vertex_shader(ctx->st, GL_TRUE);
    stfp = combined_bitmap_fragment_program(ctx);
 
    st_validate_state(st);
 
-   mt = make_bitmap_texture(ctx, width, height, unpack, bitmap);
-   if (mt) {
+   pt = make_bitmap_texture(ctx, width, height, unpack, bitmap);
+   if (pt) {
       draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
                          width, height, 1.0, 1.0,
-                         mt, stvp, stfp,
+                         pt, stvp, stfp,
                          ctx->Current.RasterColor, GL_FALSE);
 
-      free_mipmap_tree(st->pipe, mt);
+      st->pipe->texture_release(st->pipe, &pt);
    }
 }
 
@@ -1219,8 +1129,6 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
                     GLsizei width, GLsizei height,
                     GLint dstx, GLint dsty)
 {
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = st->pipe;
    struct st_renderbuffer *rbRead = st_renderbuffer(ctx->ReadBuffer->_StencilBuffer);
    struct st_renderbuffer *rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
    struct pipe_surface *psRead = rbRead->surface;
@@ -1236,8 +1144,8 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
    }
 
    /* map the stencil buffers */
-   readMap = pipe->region_map(pipe, psRead->region);
-   drawMap = pipe->region_map(pipe, psDraw->region);
+   readMap = pipe_surface_map(psRead);
+   drawMap = pipe_surface_map(psDraw);
 
    /* this will do stencil pixel transfer ops */
    st_read_stencil_pixels(ctx, srcx, srcy, width, height, GL_UNSIGNED_BYTE,
@@ -1256,11 +1164,11 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
          y = ctx->DrawBuffer->Height - y - 1;
       }
 
-      dst = drawMap + (y * psDraw->region->pitch + dstx) * psDraw->region->cpp;
+      dst = drawMap + (y * psDraw->pitch + dstx) * psDraw->cpp;
       src = buffer + i * width;
 
       switch (psDraw->format) {
-      case PIPE_FORMAT_S8_Z24:
+      case PIPE_FORMAT_S8Z24_UNORM:
          {
             uint *dst4 = (uint *) dst;
             int j;
@@ -1281,8 +1189,8 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
    free(buffer);
 
    /* unmap the stencil buffers */
-   pipe->region_unmap(pipe, psRead->region);
-   pipe->region_unmap(pipe, psDraw->region);
+   pipe_surface_unmap(psRead);
+   pipe_surface_unmap(psDraw);
 }
 
 
@@ -1297,7 +1205,8 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
    struct st_vertex_program *stvp;
    struct st_fragment_program *stfp;
    struct pipe_surface *psRead;
-   struct pipe_mipmap_tree *mt;
+   struct pipe_surface *psTex;
+   struct pipe_texture *pt;
    GLfloat *color;
    uint format;
 
@@ -1328,56 +1237,52 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
    psRead = rbRead->surface;
    format = psRead->format;
 
-   mt = alloc_mipmap_tree(ctx->st, width, height, format);
-   if (!mt)
+   pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, format,
+			  rbRead->Base.InternalFormat, 0, 0, width, height, 1, 0);
+   if (!pt)
       return;
 
+   psTex = pipe->get_tex_surface(pipe, pt, 0, 0, 0);
+
    if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
       srcy = ctx->DrawBuffer->Height - srcy - height;
    }
 
    /* For some drivers (like Xlib) it's not possible to treat the
-    * front/back color buffers as regions (they're XImages and Pixmaps).
-    * So, this var tells us if we can use region_copy here...
+    * front/back color buffers as surfaces (they're XImages and Pixmaps).
+    * So, this var tells us if we can use surface_copy here...
     */
-   if (st->haveFramebufferRegions) {
-      /* copy source framebuffer region into mipmap/texture */
-      pipe->region_copy(pipe,
-                        mt->region, /* dest */
-                        0, /* dest_offset */
-                        0, 0, /* destx/y */
-                        psRead->region,
-                        0, /* src_offset */
-                        srcx, srcy, width, height);
+   if (st->haveFramebufferSurfaces) {
+      /* copy source framebuffer surface into mipmap/texture */
+      pipe->surface_copy(pipe,
+			 psTex, /* dest */
+			 0, 0, /* destx/y */
+			 psRead,
+			 srcx, srcy, width, height);
    }
    else {
       /* alternate path using get/put_tile() */
-      struct pipe_surface *psTex;
       GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
 
-      psTex = pipe->get_tex_surface(pipe, mt, 0, 0, 0);
-
-      (void) pipe->region_map(pipe, psRead->region);
-      (void) pipe->region_map(pipe, psTex->region);
+      (void) pipe_surface_map(psRead);
+      (void) pipe_surface_map(psTex);
 
       pipe->get_tile_rgba(pipe, psRead, srcx, srcy, width, height, buf);
       pipe->put_tile_rgba(pipe, psTex, 0, 0, width, height, buf);
 
-      pipe->region_unmap(pipe, psRead->region);
-      pipe->region_unmap(pipe, psTex->region);
-
-      pipe_surface_reference(&psTex, NULL);
+      pipe_surface_unmap(psRead);
+      pipe_surface_unmap(psTex);
 
       free(buf);
    }
 
-
    /* draw textured quad */
    draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],
                       width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                      mt, stvp, stfp, color, GL_TRUE);
+                      pt, stvp, stfp, color, GL_TRUE);
 
-   free_mipmap_tree(st->pipe, mt);
+   pipe_surface_reference(&psTex, NULL);
+   st->pipe->texture_release(st->pipe, &pt);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c
index f58d532b2a..cbda56b5c3 100644
--- a/src/mesa/state_tracker/st_cb_fbo.c
+++ b/src/mesa/state_tracker/st_cb_fbo.c
@@ -55,7 +55,8 @@
  * Compute the renderbuffer's Red/Green/EtcBit fields from the pipe format.
  */
 static int
-init_renderbuffer_bits(struct st_renderbuffer *strb, uint pipeFormat)
+init_renderbuffer_bits(struct st_renderbuffer *strb,
+                       enum pipe_format pipeFormat)
 {
    struct pipe_format_info info;
 
@@ -86,7 +87,7 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
 {
    struct pipe_context *pipe = ctx->st->pipe;
    struct st_renderbuffer *strb = st_renderbuffer(rb);
-   const uint pipeFormat
+   const enum pipe_format pipeFormat
       = st_choose_pipe_format(pipe, internalFormat, GL_NONE, GL_NONE);
    GLuint cpp;
    GLbitfield flags = PIPE_SURFACE_FLAG_RENDER; /* want to render to surface */
@@ -104,23 +105,28 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
       assert(strb->surface);
       if (!strb->surface)
          return GL_FALSE;
+      strb->surface->cpp = cpp;
    }
 
-   /* free old region */
-   if (strb->surface->region) {
-      /* loop here since mapping is refcounted */
-      struct pipe_region *r = strb->surface->region;
-      while (r->map)
-         pipe->region_unmap(pipe, r);
-      pipe->winsys->region_release(pipe->winsys, &strb->surface->region);
-   }
+   strb->surface->pitch = pipe->winsys->surface_pitch(pipe->winsys, cpp,
+                                                      width, flags);
+
+   /* loop here since mapping is refcounted */
+   while (strb->surface->map)
+      pipe_surface_unmap(strb->surface);
+   if (strb->surface->buffer)
+      pipe->winsys->buffer_reference(pipe->winsys, &strb->surface->buffer,
+				     NULL);
 
-   strb->surface->region = pipe->winsys->region_alloc(pipe->winsys, cpp,
-                                                      width, height, flags);
-   if (!strb->surface->region)
+   strb->surface->buffer = pipe->winsys->buffer_create(pipe->winsys, flags);
+   if (!strb->surface->buffer)
       return GL_FALSE; /* out of memory, try s/w buffer? */
 
-   ASSERT(strb->surface->region->buffer);
+   pipe->winsys->buffer_data(pipe->winsys, strb->surface->buffer,
+			     strb->surface->pitch * cpp * height, NULL,
+			     PIPE_BUFFER_USAGE_PIXEL);
+
+   ASSERT(strb->surface->buffer);
    ASSERT(strb->surface->format);
 
    strb->Base.Width  = strb->surface->width  = width;
@@ -282,7 +288,7 @@ st_render_texture(GLcontext *ctx,
    struct st_renderbuffer *strb;
    struct gl_renderbuffer *rb;
    struct pipe_context *pipe = st->pipe;
-   struct pipe_mipmap_tree *mt;
+   struct pipe_texture *pt;
 
    assert(!att->Renderbuffer);
 
@@ -298,26 +304,26 @@ st_render_texture(GLcontext *ctx,
    rb->AllocStorage = NULL; /* should not get called */
    strb = st_renderbuffer(rb);
 
-   /* get the mipmap tree for the texture */
-   mt = st_get_texobj_mipmap_tree(att->Texture);
-   assert(mt);
-   assert(mt->level[att->TextureLevel].width);
+   /* get the texture for the texture object */
+   pt = st_get_texobj_texture(att->Texture);
+   assert(pt);
+   assert(pt->width[att->TextureLevel]);
 
-   rb->Width = mt->level[att->TextureLevel].width;
-   rb->Height = mt->level[att->TextureLevel].height;
+   rb->Width = pt->width[att->TextureLevel];
+   rb->Height = pt->height[att->TextureLevel];
 
-   /* the renderbuffer's surface is inside the mipmap_tree: */
-   strb->surface = pipe->get_tex_surface(pipe, mt,
+   /* the renderbuffer's surface is inside the texture */
+   strb->surface = pipe->get_tex_surface(pipe, pt,
                                          att->CubeMapFace,
                                          att->TextureLevel,
                                          att->Zoffset);
    assert(strb->surface);
 
-   init_renderbuffer_bits(strb, mt->format);
+   init_renderbuffer_bits(strb, pt->format);
 
    /*
-   printf("RENDER TO TEXTURE obj=%p mt=%p surf=%p  %d x %d\n",
-          att->Texture, mt, strb->surface, rb->Width, rb->Height);
+   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",
+          att->Texture, pt, strb->surface, rb->Width, rb->Height);
    */
 
    /* Invalidate buffer state so that the pipe's framebuffer state
diff --git a/src/mesa/state_tracker/st_cb_feedback.c b/src/mesa/state_tracker/st_cb_feedback.c
index a9fd2579a2..ea775b9452 100644
--- a/src/mesa/state_tracker/st_cb_feedback.c
+++ b/src/mesa/state_tracker/st_cb_feedback.c
@@ -43,7 +43,6 @@
 #include "main/macros.h"
 
 #include "vbo/vbo.h"
-#include "vbo/vbo_context.h"
 
 #include "st_context.h"
 #include "st_atom.h"
@@ -281,26 +280,25 @@ static void
 st_RenderMode(GLcontext *ctx, GLenum newMode )
 {
    struct st_context *st = ctx->st;
-   struct vbo_context *vbo = (struct vbo_context *) ctx->swtnl_im;
    struct draw_context *draw = st->draw;
 
    if (newMode == GL_RENDER) {
       /* restore normal VBO draw function */
-      vbo->draw_prims = st_draw_vbo;
+      vbo_set_draw_func(ctx, st_draw_vbo);
    }
    else if (newMode == GL_SELECT) {
       if (!st->selection_stage)
          st->selection_stage = draw_glselect_stage(ctx, draw);
       draw_set_rasterize_stage(draw, st->selection_stage);
       /* Plug in new vbo draw function */
-      vbo->draw_prims = st_feedback_draw_vbo;
+      vbo_set_draw_func(ctx, st_feedback_draw_vbo);
    }
    else {
       if (!st->feedback_stage)
          st->feedback_stage = draw_glfeedback_stage(ctx, draw);
       draw_set_rasterize_stage(draw, st->feedback_stage);
       /* Plug in new vbo draw function */
-      vbo->draw_prims = st_feedback_draw_vbo;
+      vbo_set_draw_func(ctx, st_feedback_draw_vbo);
       /* need to generate/use a vertex program that emits pos/color/tex */
       st->dirty.st |= ST_NEW_VERTEX_PROGRAM;
    }
diff --git a/src/mesa/state_tracker/st_cb_readpixels.c b/src/mesa/state_tracker/st_cb_readpixels.c
index 2e7c01672a..96829fcfa0 100644
--- a/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/src/mesa/state_tracker/st_cb_readpixels.c
@@ -39,6 +39,7 @@
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_inlines.h"
 #include "st_context.h"
 #include "st_cb_readpixels.h"
 #include "st_cb_fbo.h"
@@ -56,8 +57,6 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
                        const struct gl_pixelstore_attrib *packing,
                        GLvoid *pixels)
 {
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = st->pipe;
    struct gl_framebuffer *fb = ctx->ReadBuffer;
    struct st_renderbuffer *strb = st_renderbuffer(fb->_StencilBuffer);
    struct pipe_surface *ps = strb->surface;
@@ -65,7 +64,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
    GLint j;
 
    /* map the stencil buffer */
-   stmap = pipe->region_map(pipe, ps->region);
+   stmap = pipe_surface_map(ps);
 
    /* width should never be > MAX_WIDTH since we did clipping earlier */
    ASSERT(width <= MAX_WIDTH);
@@ -87,22 +86,22 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
       switch (ps->format) {
       case PIPE_FORMAT_U_S8:
          {
-            const ubyte *src = stmap + srcY * ps->region->pitch + x;
+            const ubyte *src = stmap + srcY * ps->pitch + x;
             memcpy(values, src, width);
          }
          break;
-      case PIPE_FORMAT_S8_Z24:
+      case PIPE_FORMAT_S8Z24_UNORM:
          {
-            const uint *src = (uint *) stmap + srcY * ps->region->pitch + x;
+            const uint *src = (uint *) stmap + srcY * ps->pitch + x;
             GLint k;
             for (k = 0; k < width; k++) {
                values[k] = src[k] >> 24;
             }
          }
          break;
-      case PIPE_FORMAT_Z24_S8:
+      case PIPE_FORMAT_Z24S8_UNORM:
          {
-            const uint *src = (uint *) stmap + srcY * ps->region->pitch + x;
+            const uint *src = (uint *) stmap + srcY * ps->pitch + x;
             GLint k;
             for (k = 0; k < width; k++) {
                values[k] = src[k] & 0xff;
@@ -122,7 +121,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
 
 
    /* unmap the stencil buffer */
-   pipe->region_unmap(pipe, ps->region);
+   pipe_surface_unmap(ps);
 }
 
 
@@ -151,7 +150,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 
    /* Do all needed clipping here, so that we can forget about it later */
    if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {
-      /* The ReadPixels region is totally outside the window bounds */
+      /* The ReadPixels surface is totally outside the window bounds */
       return;
    }
 
@@ -180,7 +179,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
    if (!strb)
       return;
 
-   pipe->region_map(pipe, strb->surface->region);
+   pipe_surface_map(strb->surface);
 
    if (format == GL_RGBA && type == GL_FLOAT) {
       /* write tile(row) directly into user's buffer */
@@ -231,7 +230,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       }
    }
 
-   pipe->region_unmap(pipe, strb->surface->region);
+   pipe_surface_unmap(strb->surface);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index 4e6d4857f4..14f8d38def 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -40,10 +40,11 @@
 #include "state_tracker/st_cb_fbo.h"
 #include "state_tracker/st_cb_texture.h"
 #include "state_tracker/st_format.h"
-#include "state_tracker/st_mipmap_tree.h"
+#include "state_tracker/st_texture.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_inlines.h"
 
 
 #define DBG if (0) printf
@@ -53,8 +54,7 @@ struct st_texture_object
 {
    struct gl_texture_object base;       /* The "parent" object */
 
-   /* The mipmap tree must include at least these levels once
-    * validated:
+   /* The texture must include at least these levels once validated:
     */
    GLuint firstLevel;
    GLuint lastLevel;
@@ -64,9 +64,9 @@ struct st_texture_object
    GLuint textureOffset;
 
    /* On validation any active images held in main memory or in other
-    * regions will be copied to this region and the old storage freed.
+    * textures will be copied to this texture and the old storage freed.
     */
-   struct pipe_mipmap_tree *mt;
+   struct pipe_texture *pt;
 
    GLboolean imageOverride;
    GLint depthOverride;
@@ -75,24 +75,6 @@ struct st_texture_object
 
 
 
-struct st_texture_image
-{
-   struct gl_texture_image base;
-
-   /* These aren't stored in gl_texture_image 
-    */
-   GLuint level;
-   GLuint face;
-
-   /* If stImage->mt != NULL, image data is stored here.
-    * Else if stImage->base.Data != NULL, image is stored there.
-    * Else there is no image data.
-    */
-   struct pipe_mipmap_tree *mt;
-};
-
-
-
 
 static INLINE struct st_texture_object *
 st_texture_object(struct gl_texture_object *obj)
@@ -107,11 +89,11 @@ st_texture_image(struct gl_texture_image *img)
 }
 
 
-struct pipe_mipmap_tree *
-st_get_texobj_mipmap_tree(struct gl_texture_object *texObj)
+struct pipe_texture *
+st_get_texobj_texture(struct gl_texture_object *texObj)
 {
    struct st_texture_object *stObj = st_texture_object(texObj);
-   return stObj->mt;
+   return stObj->pt;
 }
 
 
@@ -173,9 +155,9 @@ st_IsTextureResident(GLcontext * ctx, struct gl_texture_object *texObj)
    struct st_texture_object *stObj = st_texture_object(texObj);
 
    return
-      stObj->mt &&
-      stObj->mt->region &&
-      intel_is_region_resident(intel, stObj->mt->region);
+      stObj->pt &&
+      stObj->pt->region &&
+      intel_is_region_resident(intel, stObj->pt->region);
 #endif
    return 1;
 }
@@ -206,11 +188,10 @@ static void
 st_DeleteTextureObject(GLcontext *ctx,
 			 struct gl_texture_object *texObj)
 {
-   struct pipe_context *pipe = ctx->st->pipe;
    struct st_texture_object *stObj = st_texture_object(texObj);
 
-   if (stObj->mt)
-      st_miptree_release(pipe, &stObj->mt);
+   if (stObj->pt)
+      ctx->st->pipe->texture_release(ctx->st->pipe, &stObj->pt);
 
    _mesa_delete_texture_object(ctx, texObj);
 }
@@ -219,13 +200,12 @@ st_DeleteTextureObject(GLcontext *ctx,
 static void
 st_FreeTextureImageData(GLcontext * ctx, struct gl_texture_image *texImage)
 {
-   struct pipe_context *pipe = ctx->st->pipe;
    struct st_texture_image *stImage = st_texture_image(texImage);
 
    DBG("%s\n", __FUNCTION__);
 
-   if (stImage->mt) {
-      st_miptree_release(pipe, &stImage->mt);
+   if (stImage->pt) {
+      ctx->st->pipe->texture_release(ctx->st->pipe, &stImage->pt);
    }
 
    if (texImage->Data) {
@@ -286,10 +266,10 @@ do_memcpy(void *dest, const void *src, size_t n)
 }
 
 
-/* Functions to store texture images.  Where possible, mipmap_tree's
+/* Functions to store texture images.  Where possible, textures
  * will be created or further instantiated with image data, otherwise
  * images will be stored in malloc'd memory.  A validation step is
- * required to pull those images into a mipmap tree, or otherwise
+ * required to pull those images into a texture, or otherwise
  * decide a fallback is required.
  */
 
@@ -312,17 +292,16 @@ logbase2(int n)
 /* Otherwise, store it in memory if (Border != 0) or (any dimension ==
  * 1).
  *    
- * Otherwise, if max_level >= level >= min_level, create tree with
- * space for textures from min_level down to max_level.
+ * Otherwise, if max_level >= level >= min_level, create texture with
+ * space for images from min_level down to max_level.
  *
- * Otherwise, create tree with space for textures from (level
- * 0)..(1x1).  Consider pruning this tree at a validation if the
- * saving is worth it.
+ * Otherwise, create texture with space for images from (level 0)..(1x1).
+ * Consider pruning this texture at a validation if the saving is worth it.
  */
 static void
-guess_and_alloc_mipmap_tree(struct pipe_context *pipe,
-                            struct st_texture_object *stObj,
-                            struct st_texture_image *stImage)
+guess_and_alloc_texture(struct st_context *st,
+			struct st_texture_object *stObj,
+			struct st_texture_image *stImage)
 {
    GLuint firstLevel;
    GLuint lastLevel;
@@ -381,23 +360,20 @@ guess_and_alloc_mipmap_tree(struct pipe_context *pipe,
       lastLevel = firstLevel + MAX2(MAX2(l2width, l2height), l2depth);
    }
 
-   assert(!stObj->mt);
+   assert(!stObj->pt);
    if (stImage->base.IsCompressed)
       comp_byte = compressed_num_bytes(stImage->base.TexFormat->MesaFormat);
-   stObj->mt = st_miptree_create(pipe,
+   stObj->pt = st_texture_create(st,
                                  gl_target_to_pipe(stObj->base.Target),
-                                 stImage->base.InternalFormat,
+                                 st_mesa_format_to_pipe_format(stImage->base.TexFormat->MesaFormat),
+				 stImage->base.InternalFormat,
                                  firstLevel,
                                  lastLevel,
                                  width,
                                  height,
                                  depth,
-                                 stImage->base.TexFormat->TexelBytes,
                                  comp_byte);
 
-   stObj->mt->format
-      = st_mesa_format_to_pipe_format(stImage->base.TexFormat->MesaFormat);
-
    DBG("%s - success\n", __FUNCTION__);
 }
 
@@ -481,11 +457,11 @@ try_pbo_upload(GLcontext *ctx,
    else
       src_stride = width;
 
-   dst_offset = st_miptree_image_offset(stImage->mt,
+   dst_offset = st_texture_image_offset(stImage->pt,
                                            stImage->face,
                                            stImage->level);
 
-   dst_stride = stImage->mt->pitch;
+   dst_stride = stImage->pt->pitch;
 
    {
       struct _DriBufferObject *src_buffer =
@@ -494,11 +470,11 @@ try_pbo_upload(GLcontext *ctx,
       /* Temporary hack: cast to _DriBufferObject:
        */
       struct _DriBufferObject *dst_buffer =
-         (struct _DriBufferObject *)stImage->mt->region->buffer;
+         (struct _DriBufferObject *)stImage->pt->region->buffer;
 
 
       intelEmitCopyBlit(intel,
-                        stImage->mt->cpp,
+                        stImage->pt->cpp,
                         src_stride, src_buffer, src_offset,
                         dst_stride, dst_buffer, dst_offset,
                         0, 0, 0, 0, width, height,
@@ -539,7 +515,6 @@ st_TexImage(GLcontext * ctx,
               struct gl_texture_object *texObj,
               struct gl_texture_image *texImage, GLsizei imageSize, int compressed)
 {
-   struct pipe_context *pipe = ctx->st->pipe;
    struct st_texture_object *stObj = st_texture_object(texObj);
    struct st_texture_image *stImage = st_texture_image(texImage);
    GLint postConvWidth = width;
@@ -588,58 +563,58 @@ st_TexImage(GLcontext * ctx,
    /* Release the reference to a potentially orphaned buffer.   
     * Release any old malloced memory.
     */
-   if (stImage->mt) {
-      st_miptree_release(pipe, &stImage->mt);
+   if (stImage->pt) {
+      ctx->st->pipe->texture_release(ctx->st->pipe, &stImage->pt);
       assert(!texImage->Data);
    }
    else if (texImage->Data) {
       _mesa_align_free(texImage->Data);
    }
 
-   /* If this is the only texture image in the tree, could call
+   /* If this is the only texture image in the texture, could call
     * bmBufferData with NULL data to free the old block and avoid
     * waiting on any outstanding fences.
     */
-   if (stObj->mt &&
-       stObj->mt->first_level == level &&
-       stObj->mt->last_level == level &&
-       stObj->mt->target != PIPE_TEXTURE_CUBE &&
-       !st_miptree_match_image(stObj->mt, &stImage->base,
+   if (stObj->pt &&
+       stObj->pt->first_level == level &&
+       stObj->pt->last_level == level &&
+       stObj->pt->target != PIPE_TEXTURE_CUBE &&
+       !st_texture_match_image(stObj->pt, &stImage->base,
                                   stImage->face, stImage->level)) {
 
       DBG("release it\n");
-      st_miptree_release(pipe, &stObj->mt);
-      assert(!stObj->mt);
+      ctx->st->pipe->texture_release(ctx->st->pipe, &stObj->pt);
+      assert(!stObj->pt);
    }
 
-   if (!stObj->mt) {
-      guess_and_alloc_mipmap_tree(pipe, stObj, stImage);
-      if (!stObj->mt) {
-	 DBG("guess_and_alloc_mipmap_tree: failed\n");
+   if (!stObj->pt) {
+      guess_and_alloc_texture(ctx->st, stObj, stImage);
+      if (!stObj->pt) {
+	 DBG("guess_and_alloc_texture: failed\n");
       }
    }
 
-   assert(!stImage->mt);
+   assert(!stImage->pt);
 
-   if (stObj->mt &&
-       st_miptree_match_image(stObj->mt, &stImage->base,
+   if (stObj->pt &&
+       st_texture_match_image(stObj->pt, &stImage->base,
                                  stImage->face, stImage->level)) {
 
-      st_miptree_reference(&stImage->mt, stObj->mt);
-      assert(stImage->mt);
+      pipe_texture_reference(ctx->st->pipe, &stImage->pt, stObj->pt);
+      assert(stImage->pt);
    }
 
-   if (!stImage->mt)
-      DBG("XXX: Image did not fit into tree - storing in local memory!\n");
+   if (!stImage->pt)
+      DBG("XXX: Image did not fit into texture - storing in local memory!\n");
 
 #if 0 /* XXX FIX when st_buffer_objects are in place */
    /* PBO fastpaths:
     */
    if (dims <= 2 &&
-       stImage->mt &&
+       stImage->pt &&
        intel_buffer_object(unpack->BufferObj) &&
        check_pbo_format(internalFormat, format,
-                        type, stImage->base.TexFormat)) {
+                        type, texImage->TexFormat)) {
 
       DBG("trying pbo upload\n");
 
@@ -649,9 +624,9 @@ st_TexImage(GLcontext * ctx,
        * performance (in particular when pipe_region_cow() is
        * required).
        */
-      if (stObj->mt == stImage->mt &&
-          stObj->mt->first_level == level &&
-          stObj->mt->last_level == level) {
+      if (stObj->pt == stImage->pt &&
+          stObj->pt->first_level == level &&
+          stObj->pt->last_level == level) {
 
          if (try_pbo_zcopy(intel, stImage, unpack,
                            internalFormat,
@@ -681,8 +656,8 @@ st_TexImage(GLcontext * ctx,
 #endif
 
 
-   /* intelCopyTexImage calls this function with pixels == NULL, with
-    * the expectation that the mipmap tree will be set up but nothing
+   /* st_CopyTexImage calls this function with pixels == NULL, with
+    * the expectation that the texture will be set up but nothing
     * more will be done.  This is where those calls return:
     */
    if (compressed) {
@@ -697,13 +672,9 @@ st_TexImage(GLcontext * ctx,
    if (!pixels)
       return;
 
-   if (stImage->mt) {
-      texImage->Data = st_miptree_image_map(pipe,
-                                               stImage->mt,
-                                               stImage->face,
-                                               stImage->level,
-                                               &dstRowStride,
-                                               stImage->base.ImageOffsets);
+   if (stImage->pt) {
+      texImage->Data = st_texture_image_map(ctx->st, stImage, 0);
+      dstRowStride = stImage->surface->pitch * stImage->surface->cpp;
    }
    else {
       /* Allocate regular memory and store the image there temporarily.   */
@@ -731,22 +702,37 @@ st_TexImage(GLcontext * ctx,
    if (compressed) {
      memcpy(texImage->Data, pixels, imageSize);
    }
-   else if (!texImage->TexFormat->StoreImage(ctx, dims, 
-                                             texImage->_BaseFormat, 
-                                             texImage->TexFormat, 
-                                             texImage->Data,
-                                             0, 0, 0, /* dstX/Y/Zoffset */
-                                             dstRowStride,
-                                             texImage->ImageOffsets,
-                                             width, height, depth,
-                                             format, type, pixels, unpack)) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
+   else {
+      GLuint srcImageStride = _mesa_image_image_stride(unpack, width, height,
+						       format, type);
+      int i;
+      const GLubyte *src = (const GLubyte *) pixels;
+
+      for (i = 0; i++ < depth;) {
+	 if (!texImage->TexFormat->StoreImage(ctx, dims, 
+					      texImage->_BaseFormat, 
+					      texImage->TexFormat, 
+					      texImage->Data,
+					      0, 0, 0, /* dstX/Y/Zoffset */
+					      dstRowStride,
+					      texImage->ImageOffsets,
+					      width, height, 1,
+					      format, type, src, unpack)) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
+	 }
+
+	 if (stImage->pt && i < depth) {
+	    st_texture_image_unmap(stImage);
+	    texImage->Data = st_texture_image_map(ctx->st, stImage, i);
+	    src += srcImageStride;
+	 }
+      }
    }
 
    _mesa_unmap_teximage_pbo(ctx, unpack);
 
-   if (stImage->mt) {
-      st_miptree_image_unmap(pipe, stImage->mt);
+   if (stImage->pt) {
+      st_texture_image_unmap(stImage);
       texImage->Data = NULL;
    }
 
@@ -835,52 +821,61 @@ st_get_tex_image(GLcontext * ctx, GLenum target, GLint level,
                  struct gl_texture_object *texObj,
                  struct gl_texture_image *texImage, int compressed)
 {
-   /*
-   struct intel_context *intel = intel_context(ctx);
-   */
-   struct pipe_context *pipe = ctx->st->pipe;
    struct st_texture_image *stImage = st_texture_image(texImage);
+   GLuint dstImageStride = _mesa_image_image_stride(&ctx->Pack, texImage->Width,
+						    texImage->Height, format,
+						    type);
+   GLuint depth;
+   int i;
+   GLubyte *dest;
 
    /* Map */
-   if (stImage->mt) {
+   if (stImage->pt) {
       /* Image is stored in hardware format in a buffer managed by the
        * kernel.  Need to explicitly map and unmap it.
        */
-      stImage->base.Data =
-         st_miptree_image_map(pipe,
-                                 stImage->mt,
-                                 stImage->face,
-                                 stImage->level,
-                                 &stImage->base.RowStride,
-                                 stImage->base.ImageOffsets);
-      stImage->base.RowStride /= stImage->mt->cpp;
+      texImage->Data = st_texture_image_map(ctx->st, stImage, 0);
+      texImage->RowStride = stImage->surface->pitch;
    }
    else {
       /* Otherwise, the image should actually be stored in
-       * stImage->base.Data.  This is pretty confusing for
+       * texImage->Data.  This is pretty confusing for
        * everybody, I'd much prefer to separate the two functions of
        * texImage->Data - storage for texture images in main memory
        * and access (ie mappings) of images.  In other words, we'd
        * create a new texImage->Map field and leave Data simply for
        * storage.
        */
-      assert(stImage->base.Data);
+      assert(texImage->Data);
    }
 
+   depth = texImage->Depth;
+   texImage->Depth = 1;
 
-   if (compressed) {
-      _mesa_get_compressed_teximage(ctx, target, level, pixels,
-				    texObj, texImage);
-   } else {
-      _mesa_get_teximage(ctx, target, level, format, type, pixels,
-			 texObj, texImage);
+   dest = (GLubyte *) pixels;
+
+   for (i = 0; i++ < depth;) {
+      if (compressed) {
+	 _mesa_get_compressed_teximage(ctx, target, level, dest,
+				       texObj, texImage);
+      } else {
+	 _mesa_get_teximage(ctx, target, level, format, type, dest,
+			    texObj, texImage);
+      }
+
+      if (stImage->pt && i < depth) {
+	 st_texture_image_unmap(stImage);
+	 texImage->Data = st_texture_image_map(ctx->st, stImage, i);
+	 dest += dstImageStride;
+      }
    }
-     
+
+   texImage->Depth = depth;
 
    /* Unmap */
-   if (stImage->mt) {
-      st_miptree_image_unmap(pipe, stImage->mt);
-      stImage->base.Data = NULL;
+   if (stImage->pt) {
+      st_texture_image_unmap(stImage);
+      texImage->Data = NULL;
    }
 }
 
@@ -920,9 +915,12 @@ st_TexSubimage(GLcontext * ctx,
                  struct gl_texture_object *texObj,
                  struct gl_texture_image *texImage)
 {
-   struct pipe_context *pipe = ctx->st->pipe;
    struct st_texture_image *stImage = st_texture_image(texImage);
    GLuint dstRowStride;
+   GLuint srcImageStride = _mesa_image_image_stride(packing, width, height,
+						    format, type);
+   int i;
+   const GLubyte *src;
 
    DBG("%s target %s level %d offset %d,%d %dx%d\n", __FUNCTION__,
        _mesa_lookup_enum_by_nr(target),
@@ -937,25 +935,30 @@ st_TexSubimage(GLcontext * ctx,
    /* Map buffer if necessary.  Need to lock to prevent other contexts
     * from uploading the buffer under us.
     */
-   if (stImage->mt) 
-      texImage->Data = st_miptree_image_map(pipe,
-                                               stImage->mt,
-                                               stImage->face,
-                                               stImage->level,
-                                               &dstRowStride,
-                                               texImage->ImageOffsets);
+   if (stImage->pt) {
+      texImage->Data = st_texture_image_map(ctx->st, stImage, zoffset);
+      dstRowStride = stImage->surface->pitch * stImage->surface->cpp;
+   }
 
-   assert(dstRowStride);
+   src = (const GLubyte *) pixels;
 
-   if (!texImage->TexFormat->StoreImage(ctx, dims, texImage->_BaseFormat,
-                                        texImage->TexFormat,
-                                        texImage->Data,
-                                        xoffset, yoffset, zoffset,
-                                        dstRowStride,
-                                        texImage->ImageOffsets,
-                                        width, height, depth,
-                                        format, type, pixels, packing)) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "intelTexSubImage");
+   for (i = 0; i++ < depth;) {
+      if (!texImage->TexFormat->StoreImage(ctx, dims, texImage->_BaseFormat,
+					   texImage->TexFormat,
+					   texImage->Data,
+					   xoffset, yoffset, 0,
+					   dstRowStride,
+					   texImage->ImageOffsets,
+					   width, height, 1,
+					   format, type, src, packing)) {
+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "st_TexSubImage");
+      }
+
+      if (stImage->pt && i < depth) {
+	 st_texture_image_unmap(stImage);
+	 texImage->Data = st_texture_image_map(ctx->st, stImage, zoffset + i);
+	 src += srcImageStride;
+      }
    }
 
 #if 0
@@ -969,8 +972,8 @@ st_TexSubimage(GLcontext * ctx,
 
    _mesa_unmap_teximage_pbo(ctx, packing);
 
-   if (stImage->mt) {
-      st_miptree_image_unmap(pipe, stImage->mt);
+   if (stImage->pt) {
+      st_texture_image_unmap(stImage);
       texImage->Data = NULL;
    }
 }
@@ -1055,8 +1058,8 @@ texture_face(GLenum target)
 
 
 /**
- * Do a CopyTexSubImage operation by mapping the source region and
- * dest region and using get_tile()/put_tile() to access the pixels/texels.
+ * Do a CopyTexSubImage operation by mapping the source surface and
+ * dest surface and using get_tile()/put_tile() to access the pixels/texels.
  *
  * Note: srcY=0=TOP of renderbuffer
  */
@@ -1073,7 +1076,7 @@ fallback_copy_texsubimage(GLcontext *ctx,
 {
    struct pipe_context *pipe = ctx->st->pipe;
    const uint face = texture_face(target);
-   struct pipe_mipmap_tree *mt = stImage->mt;
+   struct pipe_texture *pt = stImage->pt;
    struct pipe_surface *src_surf, *dest_surf;
    GLfloat *data;
    GLint row, yStep;
@@ -1089,11 +1092,11 @@ fallback_copy_texsubimage(GLcontext *ctx,
 
    src_surf = strb->surface;
 
-   dest_surf = pipe->get_tex_surface(pipe, mt,
+   dest_surf = pipe->get_tex_surface(pipe, pt,
                                     face, level, destZ);
 
-   (void) pipe->region_map(pipe, dest_surf->region);
-   (void) pipe->region_map(pipe, src_surf->region);
+   (void) pipe_surface_map(dest_surf);
+   (void) pipe_surface_map(src_surf);
 
    /* buffer for one row */
    data = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
@@ -1114,8 +1117,8 @@ fallback_copy_texsubimage(GLcontext *ctx,
    }
 
 
-   (void) pipe->region_unmap(pipe, dest_surf->region);
-   (void) pipe->region_unmap(pipe, src_surf->region);
+   (void) pipe_surface_unmap(dest_surf);
+   (void) pipe_surface_unmap(src_surf);
 
    free(data);
 }
@@ -1149,8 +1152,7 @@ do_copy_texsubimage(GLcontext *ctx,
    struct gl_framebuffer *fb = ctx->ReadBuffer;
    struct st_renderbuffer *strb;
    struct pipe_context *pipe = ctx->st->pipe;
-   struct pipe_region *src_region, *dest_region;
-   uint dest_offset, src_offset;
+   struct pipe_surface *dest_surface;
    uint dest_format, src_format;
 
    (void) texImage;
@@ -1169,28 +1171,24 @@ do_copy_texsubimage(GLcontext *ctx,
 
    assert(strb);
    assert(strb->surface);
-   assert(stImage->mt);
+   assert(stImage->pt);
 
    if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
       srcY = strb->Base.Height - srcY - height;
    }
 
    src_format = strb->surface->format;
-   dest_format = stImage->mt->format;
+   dest_format = stImage->pt->format;
 
-   src_region = strb->surface->region;
-   dest_region = stImage->mt->region;
+   dest_surface = pipe->get_tex_surface(pipe, stImage->pt, stImage->face,
+					stImage->level, destZ);
 
    if (src_format == dest_format &&
        ctx->_ImageTransferState == 0x0 &&
-       src_region &&
-       dest_region &&
-       src_region->cpp == dest_region->cpp) {
+       strb->surface->buffer &&
+       dest_surface->buffer &&
+       strb->surface->cpp == stImage->pt->cpp) {
       /* do blit-style copy */
-      src_offset = 0;
-      dest_offset = st_miptree_image_offset(stImage->mt,
-                                            stImage->face,
-                                            stImage->level);
 
       /* XXX may need to invert image depending on window
        * vs. user-created FBO
@@ -1202,28 +1200,26 @@ do_copy_texsubimage(GLcontext *ctx,
        * worth it:
        */
       intelEmitCopyBlit(intel,
-                        stImage->mt->cpp,
+                        stImage->pt->cpp,
                         -src->pitch,
                         src->buffer,
                         src->height * src->pitch * src->cpp,
-                        stImage->mt->pitch,
-                        stImage->mt->region->buffer,
+                        stImage->pt->pitch,
+                        stImage->pt->region->buffer,
                         dest_offset,
                         x, y + height, dstx, dsty, width, height,
                         GL_COPY); /* ? */
 #else
 
-      pipe->region_copy(pipe,
-                        /* dest */
-                        dest_region,
-                        dest_offset,
-                        destX, destY,
-                        /* src */
-                        src_region,
-                        src_offset,
-                        srcX, srcY,
-                        /* size */
-                        width, height);
+      pipe->surface_copy(pipe,
+			 /* dest */
+			 dest_surface,
+			 destX, destY,
+			 /* src */
+			 strb->surface,
+			 srcX, srcY,
+			 /* size */
+			 width, height);
 #endif
    }
    else {
@@ -1233,6 +1229,7 @@ do_copy_texsubimage(GLcontext *ctx,
                                 srcX, srcY, width, height);
    }
 
+   pipe_surface_reference(&dest_surface, NULL);
 
 #if 0
    /* GL_SGIS_generate_mipmap -- this can be accelerated now.
@@ -1266,7 +1263,7 @@ st_CopyTexImage1D(GLcontext * ctx, GLenum target, GLint level,
       goto fail;
 #endif
 
-   /* Setup or redefine the texture object, mipmap tree and texture
+   /* Setup or redefine the texture object, texture and texture
     * image.  Don't populate yet.  
     */
    ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
@@ -1298,7 +1295,7 @@ st_CopyTexImage2D(GLcontext * ctx, GLenum target, GLint level,
       goto fail;
 #endif
 
-   /* Setup or redefine the texture object, mipmap tree and texture
+   /* Setup or redefine the texture object, texture and texture
     * image.  Don't populate yet.  
     */
    ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
@@ -1406,28 +1403,28 @@ calculate_first_last_level(struct st_texture_object *stObj)
 
 
 static void
-copy_image_data_to_tree(struct pipe_context *pipe,
-                        struct st_texture_object *stObj,
-                        struct st_texture_image *stImage)
+copy_image_data_to_texture(struct st_context *st,
+			   struct st_texture_object *stObj,
+			   struct st_texture_image *stImage)
 {
-   if (stImage->mt) {
+   if (stImage->pt) {
       /* Copy potentially with the blitter:
        */
-      st_miptree_image_copy(pipe,
-                            stObj->mt,  /* dest miptree */
+      st_texture_image_copy(st->pipe,
+                            stObj->pt,  /* dest texture */
                             stImage->face, stImage->level,
-                            stImage->mt /* src miptree */
+                            stImage->pt /* src texture */
                             );
 
-      st_miptree_release(pipe, &stImage->mt);
+      st->pipe->texture_release(st->pipe, &stImage->pt);
    }
    else {
       assert(stImage->base.Data != NULL);
 
       /* More straightforward upload.  
        */
-      st_miptree_image_data(pipe,
-                               stObj->mt,
+      st_texture_image_data(st->pipe,
+                               stObj->pt,
                                stImage->face,
                                stImage->level,
                                stImage->base.Data,
@@ -1438,16 +1435,16 @@ copy_image_data_to_tree(struct pipe_context *pipe,
       stImage->base.Data = NULL;
    }
 
-   st_miptree_reference(&stImage->mt, stObj->mt);
+   pipe_texture_reference(st->pipe, &stImage->pt, stObj->pt);
 }
 
 
 /*  
  */
 GLboolean
-st_finalize_mipmap_tree(GLcontext *ctx,
-                        struct pipe_context *pipe, GLuint unit,
-                        GLboolean *needFlush)
+st_finalize_texture(GLcontext *ctx,
+		    struct pipe_context *pipe, GLuint unit,
+		    GLboolean *needFlush)
 {
    struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current;
    struct st_texture_object *stObj = st_texture_object(tObj);
@@ -1464,7 +1461,7 @@ st_finalize_mipmap_tree(GLcontext *ctx,
     */
    assert(stObj->base._Complete);
 
-   /* What levels must the tree include at a minimum?
+   /* What levels must the texture include at a minimum?
     */
    calculate_first_last_level(stObj);
    firstImage =
@@ -1473,27 +1470,27 @@ st_finalize_mipmap_tree(GLcontext *ctx,
    /* Fallback case:
     */
    if (firstImage->base.Border) {
-      if (stObj->mt) {
-         st_miptree_release(pipe, &stObj->mt);
+      if (stObj->pt) {
+         ctx->st->pipe->texture_release(ctx->st->pipe, &stObj->pt);
       }
       return GL_FALSE;
    }
 
 
-   /* If both firstImage and stObj have a tree which can contain
+   /* If both firstImage and stObj point to a texture which can contain
     * all active images, favour firstImage.  Note that because of the
     * completeness requirement, we know that the image dimensions
     * will match.
     */
-   if (firstImage->mt &&
-       firstImage->mt != stObj->mt &&
-       firstImage->mt->first_level <= stObj->firstLevel &&
-       firstImage->mt->last_level >= stObj->lastLevel) {
+   if (firstImage->pt &&
+       firstImage->pt != stObj->pt &&
+       firstImage->pt->first_level <= stObj->firstLevel &&
+       firstImage->pt->last_level >= stObj->lastLevel) {
 
-      if (stObj->mt)
-         st_miptree_release(pipe, &stObj->mt);
+      if (stObj->pt)
+         ctx->st->pipe->texture_release(ctx->st->pipe, &stObj->pt);
 
-      st_miptree_reference(&stObj->mt, firstImage->mt);
+      pipe_texture_reference(ctx->st->pipe, &stObj->pt, firstImage->pt);
    }
 
    if (firstImage->base.IsCompressed) {
@@ -1504,48 +1501,45 @@ st_finalize_mipmap_tree(GLcontext *ctx,
       cpp = firstImage->base.TexFormat->TexelBytes;
    }
 
-   /* Check tree can hold all active levels.  Check tree matches
+   /* Check texture can hold all active levels.  Check texture matches
     * target, imageFormat, etc.
     * 
     * XXX: For some layouts (eg i945?), the test might have to be
-    * first_level == firstLevel, as the tree isn't valid except at the
+    * first_level == firstLevel, as the texture isn't valid except at the
     * original start level.  Hope to get around this by
     * programming minLod, maxLod, baseLevel into the hardware and
-    * leaving the tree alone.
+    * leaving the texture alone.
     */
-   if (stObj->mt &&
-       (stObj->mt->target != gl_target_to_pipe(stObj->base.Target) ||
-	stObj->mt->internal_format != firstImage->base.InternalFormat ||
-	stObj->mt->first_level != stObj->firstLevel ||
-	stObj->mt->last_level != stObj->lastLevel ||
-	stObj->mt->width0 != firstImage->base.Width ||
-	stObj->mt->height0 != firstImage->base.Height ||
-	stObj->mt->depth0 != firstImage->base.Depth ||
-	stObj->mt->cpp != cpp ||
-	stObj->mt->compressed != firstImage->base.IsCompressed)) {
-      st_miptree_release(pipe, &stObj->mt);
+   if (stObj->pt &&
+       (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
+	stObj->pt->internal_format != firstImage->base.InternalFormat ||
+	stObj->pt->first_level != stObj->firstLevel ||
+	stObj->pt->last_level != stObj->lastLevel ||
+	stObj->pt->width[0] != firstImage->base.Width ||
+	stObj->pt->height[0] != firstImage->base.Height ||
+	stObj->pt->depth[0] != firstImage->base.Depth ||
+	stObj->pt->cpp != cpp ||
+	stObj->pt->compressed != firstImage->base.IsCompressed)) {
+      ctx->st->pipe->texture_release(ctx->st->pipe, &stObj->pt);
    }
 
 
-   /* May need to create a new tree:
+   /* May need to create a new texture:
     */
-   if (!stObj->mt) {
-      stObj->mt = st_miptree_create(pipe,
+   if (!stObj->pt) {
+      stObj->pt = st_texture_create(ctx->st,
                                     gl_target_to_pipe(stObj->base.Target),
-                                    firstImage->base.InternalFormat,
+                                    st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat),
+				    firstImage->base.InternalFormat,
                                     stObj->firstLevel,
                                     stObj->lastLevel,
                                     firstImage->base.Width,
                                     firstImage->base.Height,
                                     firstImage->base.Depth,
-                                    cpp,
                                     comp_byte);
-
-      stObj->mt->format
-         = st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
    }
 
-   /* Pull in any images not in the object's tree:
+   /* Pull in any images not in the object's texture:
     */
    nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
    for (face = 0; face < nr_faces; face++) {
@@ -1553,10 +1547,10 @@ st_finalize_mipmap_tree(GLcontext *ctx,
          struct st_texture_image *stImage =
             st_texture_image(stObj->base.Image[face][i]);
 
-         /* Need to import images in main memory or held in other trees.
+         /* Need to import images in main memory or held in other textures.
           */
-         if (stObj->mt != stImage->mt) {
-            copy_image_data_to_tree(pipe, stObj, stImage);
+         if (stObj->pt != stImage->pt) {
+            copy_image_data_to_texture(ctx->st, stObj, stImage);
 	    *needFlush = GL_TRUE;
          }
       }
diff --git a/src/mesa/state_tracker/st_cb_texture.h b/src/mesa/state_tracker/st_cb_texture.h
index 7a1867dc58..7f8082b029 100644
--- a/src/mesa/state_tracker/st_cb_texture.h
+++ b/src/mesa/state_tracker/st_cb_texture.h
@@ -2,14 +2,14 @@
 #define ST_CB_TEXTURE_H
 
 
-extern struct pipe_mipmap_tree *
-st_get_texobj_mipmap_tree(struct gl_texture_object *texObj);
+extern struct pipe_texture *
+st_get_texobj_texture(struct gl_texture_object *texObj);
 
 
 extern GLboolean
-st_finalize_mipmap_tree(GLcontext *ctx,
-                        struct pipe_context *pipe, GLuint unit,
-                        GLboolean *needFlush);
+st_finalize_texture(GLcontext *ctx,
+		    struct pipe_context *pipe, GLuint unit,
+		    GLboolean *needFlush);
 
 
 extern void
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index a4ec3721be..524e06fb00 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -29,7 +29,7 @@
 #include "main/context.h"
 #include "main/extensions.h"
 #include "vbo/vbo.h"
-#include "drivers/common/driverfuncs.h"
+#include "shader/shader_api.h"
 #include "st_public.h"
 #include "st_context.h"
 #include "st_cb_accum.h"
@@ -103,7 +103,7 @@ st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
 
    st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
 
-   st->haveFramebufferRegions = GL_TRUE;
+   st->haveFramebufferSurfaces = GL_TRUE;
 
    st->pixel_xfer.cache = _mesa_new_program_cache();
 
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index a6045230a0..c31b76c63f 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -34,9 +34,7 @@
 
 
 struct st_context;
-struct st_region;
 struct st_texture_object;
-struct st_texture_image;
 struct st_fragment_program;
 struct draw_context;
 struct draw_stage;
@@ -61,6 +59,25 @@ struct st_tracked_state {
 
 
 
+struct st_texture_image
+{
+   struct gl_texture_image base;
+
+   /* These aren't stored in gl_texture_image 
+    */
+   GLuint level;
+   GLuint face;
+
+   /* If stImage->pt != NULL, image data is stored here.
+    * Else if stImage->base.Data != NULL, image is stored there.
+    * Else there is no image data.
+    */
+   struct pipe_texture *pt;
+
+   struct pipe_surface *surface;
+};
+
+
 
 struct st_context
 {
@@ -91,7 +108,7 @@ struct st_context
       struct pipe_constant_buffer constants[2];
       struct pipe_feedback_state feedback;
       struct pipe_framebuffer_state framebuffer;
-      struct pipe_mipmap_tree *texture[PIPE_MAX_SAMPLERS];
+      struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
       struct pipe_poly_stipple poly_stipple;
       struct pipe_scissor_state scissor;
       struct pipe_viewport_state viewport;
@@ -113,11 +130,11 @@ struct st_context
    char vendor[100];
    char renderer[100];
 
-   /** Can we access the front/back color buffers as pipe_regions?
+   /** Can we access the front/back color buffers as pipe_surfaces?
     * We can't with the Xlib driver...
     * This is a hack that should be fixed someday.
     */
-   GLboolean haveFramebufferRegions;
+   GLboolean haveFramebufferSurfaces;
 
    /* State to be validated:
     */
diff --git a/src/mesa/state_tracker/st_debug.c b/src/mesa/state_tracker/st_debug.c
index e00684ac03..cffd66751d 100644
--- a/src/mesa/state_tracker/st_debug.c
+++ b/src/mesa/state_tracker/st_debug.c
@@ -30,7 +30,8 @@
 #include "shader/prog_print.h"
 
 #include "pipe/p_state.h"
-#include "pipe/tgsi/exec/tgsi_core.h"
+#include "pipe/p_shader_tokens.h"
+#include "pipe/tgsi/util/tgsi_dump.h"
 
 #include "pipe/cso_cache/cso_cache.h"
 
diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 3b6d829145..32dcd73c46 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -34,7 +34,6 @@
 #include "main/image.h"
 
 #include "vbo/vbo.h"
-#include "vbo/vbo_context.h"
 
 #include "st_atom.h"
 #include "st_cache.h"
@@ -83,6 +82,7 @@ pipe_vertex_format(GLenum type, GLuint size)
    default:
       assert(0);
    }
+   return 0; /* silence compiler warning */
 }
 
 
@@ -324,27 +324,26 @@ static void
 set_feedback_vertex_format(GLcontext *ctx)
 {
    struct st_context *st = ctx->st;
-   uint attrs[PIPE_MAX_SHADER_OUTPUTS];
-   enum interp_mode interp[PIPE_MAX_SHADER_OUTPUTS];
-   GLuint n, i;
+   struct vertex_info vinfo;
+   GLuint i;
 
    if (ctx->RenderMode == GL_SELECT) {
       assert(ctx->RenderMode == GL_SELECT);
-      n = 1;
-      attrs[0] = FORMAT_4F;
-      interp[0] = INTERP_NONE;
+      vinfo.num_attribs = 1;
+      vinfo.format[0] = FORMAT_4F;
+      vinfo.interp_mode[0] = INTERP_NONE;
    }
    else {
       /* GL_FEEDBACK, or glRasterPos */
       /* emit all attribs (pos, color, texcoord) as GLfloat[4] */
-      n = st->state.vs->state.num_outputs;
-      for (i = 0; i < n; i++) {
-         attrs[i] = FORMAT_4F;
-         interp[i] = INTERP_NONE;
+      vinfo.num_attribs = st->state.vs->state.num_outputs;
+      for (i = 0; i < vinfo.num_attribs; i++) {
+         vinfo.format[i] = FORMAT_4F;
+         vinfo.interp_mode[i] = INTERP_LINEAR;
       }
    }
 
-   draw_set_vertex_attributes(st->draw, attrs, interp, n);
+   draw_set_vertex_info(st->draw, &vinfo);
 }
 
 
@@ -519,14 +518,11 @@ st_feedback_draw_vbo(GLcontext *ctx,
 void st_init_draw( struct st_context *st )
 {
    GLcontext *ctx = st->ctx;
-   struct vbo_context *vbo = (struct vbo_context *) ctx->swtnl_im;
 
    /* actually, not used here, but elsewhere */
    create_default_attribs_buffer(st);
 
-   assert(vbo);
-   assert(vbo->draw_prims);
-   vbo->draw_prims = st_draw_vbo;
+   vbo_set_draw_func(ctx, st_draw_vbo);
 }
 
 
diff --git a/src/mesa/state_tracker/st_format.c b/src/mesa/state_tracker/st_format.c
index c6b5bc968f..8d39e1bec6 100644
--- a/src/mesa/state_tracker/st_format.c
+++ b/src/mesa/state_tracker/st_format.c
@@ -99,9 +99,7 @@ format_size(
  * XXX temporary here
  */
 GLboolean
-st_get_format_info(
-   GLuint format,
-   struct pipe_format_info *pinfo )
+st_get_format_info(enum pipe_format format, struct pipe_format_info *pinfo)
 {
    if (pf_layout(format) == PIPE_FORMAT_LAYOUT_RGBAZS) {
       pipe_format_rgbazs_t info;
@@ -109,16 +107,18 @@ st_get_format_info(
       info = format;
 
 #if 0
-      printf(
-         "PIPE_FORMAT: X(%u), Y(%u), Z(%u), W(%u)\n",
-         info.sizeX,
-         info.sizeY,
-         info.sizeZ,
-         info.sizeW );
+      {
+         char  fmtname[256];
+
+         pf_sprint_name( fmtname, format );
+         printf(
+            "%s\n",
+            fmtname );
+      }
 #endif
 
       /* Data type */
-      if (format == PIPE_FORMAT_U_A1_R5_G5_B5 || format == PIPE_FORMAT_U_R5_G6_B5) {
+      if (format == PIPE_FORMAT_A1R5G5B5_UNORM || format == PIPE_FORMAT_R5G6B5_UNORM) {
          pinfo->datatype = GL_UNSIGNED_SHORT;
       }
       else {
@@ -220,10 +220,10 @@ st_get_format_info(
  * Return bytes per pixel for the given format.
  */
 GLuint
-st_sizeof_format(GLuint pipeFormat)
+st_sizeof_format(enum pipe_format format)
 {
    struct pipe_format_info info;
-   if (!st_get_format_info( pipeFormat, &info )) {
+   if (!st_get_format_info( format, &info )) {
       assert( 0 );
       return 0;
    }
@@ -235,10 +235,10 @@ st_sizeof_format(GLuint pipeFormat)
  * Return bytes per pixel for the given format.
  */
 GLenum
-st_format_datatype(GLuint pipeFormat)
+st_format_datatype(enum pipe_format format)
 {
    struct pipe_format_info info;
-   if (!st_get_format_info( pipeFormat, &info )) {
+   if (!st_get_format_info( format, &info )) {
       assert( 0 );
       return 0;
    }
@@ -246,14 +246,16 @@ st_format_datatype(GLuint pipeFormat)
 }
 
 
-GLuint
+enum pipe_format
 st_mesa_format_to_pipe_format(GLuint mesaFormat)
 {
    switch (mesaFormat) {
       /* fix this */
    case MESA_FORMAT_ARGB8888_REV:
    case MESA_FORMAT_ARGB8888:
-      return PIPE_FORMAT_U_A8_R8_G8_B8;
+      return PIPE_FORMAT_A8R8G8B8_UNORM;
+   case MESA_FORMAT_ARGB4444:
+      return PIPE_FORMAT_A4R4G4B4_UNORM;
    case MESA_FORMAT_AL88:
       return PIPE_FORMAT_U_A8_L8;
    case MESA_FORMAT_A8:
@@ -263,7 +265,7 @@ st_mesa_format_to_pipe_format(GLuint mesaFormat)
    case MESA_FORMAT_I8:
       return PIPE_FORMAT_U_I8;
    case MESA_FORMAT_Z16:
-      return PIPE_FORMAT_U_Z16;
+      return PIPE_FORMAT_Z16_UNORM;
    default:
       assert(0);
       return 0;
@@ -271,20 +273,23 @@ st_mesa_format_to_pipe_format(GLuint mesaFormat)
 }
 
 /**
- * Search list of formats for first RGBA format.
+ * Find an RGBA format supported by the context/winsys.
  */
 static GLuint
 default_rgba_format(
    struct pipe_context *pipe )
 {
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_R8_G8_B8_A8 )) {
-      return PIPE_FORMAT_U_R8_G8_B8_A8;
-   }
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8_R8_G8_B8 )) {
-      return PIPE_FORMAT_U_A8_R8_G8_B8;
-   }
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_R5_G6_B5 )) {
-      return PIPE_FORMAT_U_R5_G6_B5;
+   static const uint colorFormats[] = {
+      PIPE_FORMAT_R8G8B8A8_UNORM,
+      PIPE_FORMAT_A8R8G8B8_UNORM,
+      PIPE_FORMAT_B8G8R8A8_UNORM,
+      PIPE_FORMAT_R5G6B5_UNORM
+   };
+   uint i;
+   for (i = 0; i < Elements(colorFormats); i++) {
+      if (pipe->is_format_supported( pipe, colorFormats[i] )) {
+         return colorFormats[i];
+      }
    }
    return PIPE_FORMAT_NONE;
 }
@@ -297,35 +302,36 @@ static GLuint
 default_deep_rgba_format(
    struct pipe_context *pipe )
 {
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_S_R16_G16_B16_A16 )) {
-      return PIPE_FORMAT_S_R16_G16_B16_A16;
+   if (pipe->is_format_supported( pipe, PIPE_FORMAT_R16G16B16A16_SNORM )) {
+      return PIPE_FORMAT_R16G16B16A16_SNORM;
    }
    return PIPE_FORMAT_NONE;
 }
 
 
 /**
- * Search list of formats for first depth/Z format.
+ * Find an Z format supported by the context/winsys.
  */
 static GLuint
 default_depth_format(
    struct pipe_context *pipe )
 {
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_Z16 )) {
-      return PIPE_FORMAT_U_Z16;
-   }
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_Z32 )) {
-      return PIPE_FORMAT_U_Z32;
-   }
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8_Z24 )) {
-      return PIPE_FORMAT_S8_Z24;
-   }
-   if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24_S8 )) {
-      return PIPE_FORMAT_Z24_S8;
+   static const uint zFormats[] = {
+      PIPE_FORMAT_Z16_UNORM,
+      PIPE_FORMAT_Z32_UNORM,
+      PIPE_FORMAT_S8Z24_UNORM,
+      PIPE_FORMAT_Z24S8_UNORM
+   };
+   uint i;
+   for (i = 0; i < Elements(zFormats); i++) {
+      if (pipe->is_format_supported( pipe, zFormats[i] )) {
+         return zFormats[i];
+      }
    }
    return PIPE_FORMAT_NONE;
 }
 
+
 /**
  * Choose the PIPE_FORMAT_ to use for storing a texture image based
  * on the user's internalFormat, format and type parameters.
@@ -350,16 +356,16 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
    case GL_COMPRESSED_RGBA:
       if (format == GL_BGRA) {
          if (type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_INT_8_8_8_8_REV) {
-            if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8_R8_G8_B8 ))
-               return PIPE_FORMAT_U_A8_R8_G8_B8;
+            if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM ))
+               return PIPE_FORMAT_A8R8G8B8_UNORM;
          }
          else if (type == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
-            if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A4_R4_G4_B4 ))
-               return PIPE_FORMAT_U_A4_R4_G4_B4;
+            if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM ))
+               return PIPE_FORMAT_A4R4G4B4_UNORM;
          }
          else if (type == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
-            if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A1_R5_G5_B5 ))
-               return PIPE_FORMAT_U_A1_R5_G5_B5;
+            if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
+               return PIPE_FORMAT_A1R5G5B5_UNORM;
          }
       }
       return default_rgba_format( pipe );
@@ -368,8 +374,8 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
    case GL_RGB:
    case GL_COMPRESSED_RGB:
       if (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) {
-         if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_R5_G6_B5 ))
-            return PIPE_FORMAT_U_R5_G6_B5;
+         if (pipe->is_format_supported( pipe, PIPE_FORMAT_R5G6B5_UNORM ))
+            return PIPE_FORMAT_R5G6B5_UNORM;
       }
       return default_rgba_format( pipe );
 
@@ -382,13 +388,13 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
 
    case GL_RGBA4:
    case GL_RGBA2:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A4_R4_G4_B4 ))
-         return PIPE_FORMAT_U_A4_R4_G4_B4;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM ))
+         return PIPE_FORMAT_A4R4G4B4_UNORM;
       return default_rgba_format( pipe );
 
    case GL_RGB5_A1:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A1_R5_G5_B5 ))
-         return PIPE_FORMAT_U_A1_R5_G5_B5;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
+         return PIPE_FORMAT_A1R5G5B5_UNORM;
       return default_rgba_format( pipe );
 
    case GL_RGB8:
@@ -400,8 +406,8 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
    case GL_RGB5:
    case GL_RGB4:
    case GL_R3_G3_B2:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A1_R5_G5_B5 ))
-         return PIPE_FORMAT_U_A1_R5_G5_B5;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
+         return PIPE_FORMAT_A1R5G5B5_UNORM;
       return default_rgba_format( pipe );
 
    case GL_ALPHA:
@@ -483,18 +489,18 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
 #endif
 
    case GL_DEPTH_COMPONENT16:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_Z16 ))
-         return PIPE_FORMAT_U_Z16;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z16_UNORM ))
+         return PIPE_FORMAT_Z16_UNORM;
       /* fall-through */
    case GL_DEPTH_COMPONENT24:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8_Z24 ))
-         return PIPE_FORMAT_S8_Z24;
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24_S8 ))
-         return PIPE_FORMAT_Z24_S8;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
+         return PIPE_FORMAT_S8Z24_UNORM;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
+         return PIPE_FORMAT_Z24S8_UNORM;
       /* fall-through */
    case GL_DEPTH_COMPONENT32:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_Z32 ))
-         return PIPE_FORMAT_U_Z32;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z32_UNORM ))
+         return PIPE_FORMAT_Z32_UNORM;
       /* fall-through */
    case GL_DEPTH_COMPONENT:
       return default_depth_format( pipe );
@@ -506,18 +512,18 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
    case GL_STENCIL_INDEX16_EXT:
       if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_S8 ))
          return PIPE_FORMAT_U_S8;
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8_Z24 ))
-         return PIPE_FORMAT_S8_Z24;
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24_S8 ))
-         return PIPE_FORMAT_Z24_S8;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
+         return PIPE_FORMAT_S8Z24_UNORM;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
+         return PIPE_FORMAT_Z24S8_UNORM;
       return PIPE_FORMAT_NONE;
 
    case GL_DEPTH_STENCIL_EXT:
    case GL_DEPTH24_STENCIL8_EXT:
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8_Z24 ))
-         return PIPE_FORMAT_S8_Z24;
-      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24_S8 ))
-         return PIPE_FORMAT_Z24_S8;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
+         return PIPE_FORMAT_S8Z24_UNORM;
+      if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
+         return PIPE_FORMAT_Z24S8_UNORM;
       return PIPE_FORMAT_NONE;
 
    default:
@@ -537,7 +543,7 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
  */
 const struct gl_texture_format *
 st_ChooseTextureFormat(GLcontext * ctx, GLint internalFormat,
-                         GLenum format, GLenum type)
+                       GLenum format, GLenum type)
 {
 #if 0
    struct intel_context *intel = intel_context(ctx);
@@ -546,6 +552,8 @@ st_ChooseTextureFormat(GLcontext * ctx, GLint internalFormat,
    const GLboolean do32bpt = 1;
 #endif
 
+   (void) ctx;
+
    switch (internalFormat) {
    case 4:
    case GL_RGBA:
diff --git a/src/mesa/state_tracker/st_format.h b/src/mesa/state_tracker/st_format.h
index 23abc36edf..6ccf5536f9 100644
--- a/src/mesa/state_tracker/st_format.h
+++ b/src/mesa/state_tracker/st_format.h
@@ -26,13 +26,13 @@
  **************************************************************************/
 
 
-#ifndef ST_CB_TEXIMAGE_H
-#define ST_CB_TEXIMAGE_H
+#ifndef ST_FORMAT_H
+#define ST_FORMAT_H
 
 
 struct pipe_format_info
 {
-   GLuint format;
+   enum pipe_format format;
    GLenum base_format;
    GLenum datatype;
    GLubyte red_bits;
@@ -47,21 +47,19 @@ struct pipe_format_info
 };
 
 
-extern GLboolean
-st_get_format_info(
-   GLuint format,
-   struct pipe_format_info *pinfo );
+GLboolean
+st_get_format_info(enum pipe_format format, struct pipe_format_info *pinfo);
 
 
 extern GLuint
-st_sizeof_format(GLuint pipeFormat);
+st_sizeof_format(enum pipe_format format);
 
 
 extern GLenum
-st_format_datatype(GLuint pipeFormat);
+st_format_datatype(enum pipe_format format);
 
 
-extern GLuint
+extern enum pipe_format
 st_mesa_format_to_pipe_format(GLuint mesaFormat);
 
 
diff --git a/src/mesa/state_tracker/st_framebuffer.c b/src/mesa/state_tracker/st_framebuffer.c
index 4ae2837f0a..8633f431b2 100644
--- a/src/mesa/state_tracker/st_framebuffer.c
+++ b/src/mesa/state_tracker/st_framebuffer.c
@@ -155,7 +155,7 @@ st_get_framebuffer_surface(struct st_framebuffer *stfb, uint surfIndex)
 {
    struct st_renderbuffer *strb;
 
-   assert(surfIndex <= ST_SURFACE_BACK_RIGHT);
+   assert(surfIndex <= ST_SURFACE_DEPTH);
 
    /* sanity checks, ST tokens should match Mesa tokens */
    assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index ab7aa504a1..b392edf16d 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -30,10 +30,13 @@
  * Michal Krol
  */
 
-
-#include "tgsi_platform.h"
-#include "pipe/tgsi/exec/tgsi_core.h"
+#include "pipe/p_compiler.h"
+#include "pipe/p_shader_tokens.h"
+#include "pipe/tgsi/util/tgsi_parse.h"
+#include "pipe/tgsi/util/tgsi_build.h"
+#include "pipe/tgsi/util/tgsi_util.h"
 #include "st_mesa_to_tgsi.h"
+#include "shader/prog_instruction.h"
 #include "shader/prog_parameter.h"
 
 #define TGSI_DEBUG 0
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.h b/src/mesa/state_tracker/st_mesa_to_tgsi.h
index 941a75ab05..4cd4b96a58 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.h
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.h
@@ -29,11 +29,15 @@
 #ifndef ST_MESA_TO_TGSI_H

 #define ST_MESA_TO_TGSI_H

 

+#include "mtypes.h"

+

+

 #if defined __cplusplus

 extern "C" {

 #endif

 

 struct tgsi_token;

+struct gl_program;

 

 GLboolean

 tgsi_translate_mesa_program(

diff --git a/src/mesa/state_tracker/st_mipmap_tree.c b/src/mesa/state_tracker/st_mipmap_tree.c
deleted file mode 100644
index d1db590bee..0000000000
--- a/src/mesa/state_tracker/st_mipmap_tree.c
+++ /dev/null
@@ -1,320 +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.
- * 
- **************************************************************************/
-
-#include "st_mipmap_tree.h"
-#include "enums.h"
-
-#include "pipe/p_state.h"
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
-
-
-#define DBG if(0) printf
-
-#if 0
-static GLenum
-target_to_target(GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-      return GL_TEXTURE_CUBE_MAP_ARB;
-   default:
-      return target;
-   }
-}
-#endif
-
-struct pipe_mipmap_tree *
-st_miptree_create(struct pipe_context *pipe,
-                  unsigned target,
-                     GLenum internal_format,
-                     GLuint first_level,
-                     GLuint last_level,
-                     GLuint width0,
-                     GLuint height0,
-                     GLuint depth0, GLuint cpp, GLuint compress_byte)
-{
-   GLboolean ok;
-   struct pipe_mipmap_tree *mt = calloc(sizeof(*mt), 1);
-   GLbitfield flags = 0x0;
-
-   assert(target <= PIPE_TEXTURE_CUBE);
-
-   DBG("%s target %s format %s level %d..%d\n", __FUNCTION__,
-       _mesa_lookup_enum_by_nr(target),
-       _mesa_lookup_enum_by_nr(internal_format), first_level, last_level);
-
-   mt->target = target;
-   mt->internal_format = internal_format;
-   mt->first_level = first_level;
-   mt->last_level = last_level;
-   mt->width0 = width0;
-   mt->height0 = height0;
-   mt->depth0 = depth0;
-   mt->cpp = compress_byte ? compress_byte : cpp;
-   mt->compressed = compress_byte ? 1 : 0;
-   mt->refcount = 1; 
-
-   ok = pipe->mipmap_tree_layout(pipe, mt);
-   if (ok) {
-      /* note: it's OK to pass 'pitch' as 'width' here: */
-      mt->region = pipe->winsys->region_alloc(pipe->winsys, mt->cpp, mt->pitch,
-                                              mt->total_height, flags);
-      mt->pitch = mt->region->pitch; /*XXX NEW */
-   }
-
-   if (!mt->region) {
-      free(mt);
-      return NULL;
-   }
-
-   return mt;
-}
-
-
-void
-st_miptree_reference(struct pipe_mipmap_tree **dst,
-                        struct pipe_mipmap_tree *src)
-{
-   src->refcount++;
-   *dst = src;
-   DBG("%s %p refcount now %d\n", __FUNCTION__, (void *) src, src->refcount);
-}
-
-void
-st_miptree_release(struct pipe_context *pipe,
-                   struct pipe_mipmap_tree **mt)
-{
-   if (!*mt)
-      return;
-
-   DBG("%s %p refcount will be %d\n",
-       __FUNCTION__, (void *) *mt, (*mt)->refcount - 1);
-   if (--(*mt)->refcount <= 0) {
-      GLuint i;
-
-      DBG("%s deleting %p\n", __FUNCTION__, (void *) *mt);
-
-      pipe->winsys->region_release(pipe->winsys, &((*mt)->region));
-
-      for (i = 0; i < MAX_TEXTURE_LEVELS; i++)
-         if ((*mt)->level[i].image_offset)
-            free((*mt)->level[i].image_offset);
-
-      free(*mt);
-   }
-   *mt = NULL;
-}
-
-
-
-
-/* Can the image be pulled into a unified mipmap tree.  This mirrors
- * the completeness test in a lot of ways.
- *
- * Not sure whether I want to pass gl_texture_image here.
- */
-GLboolean
-st_miptree_match_image(struct pipe_mipmap_tree *mt,
-                          struct gl_texture_image *image,
-                          GLuint face, GLuint level)
-{
-   /* Images with borders are never pulled into mipmap trees. 
-    */
-   if (image->Border) 
-      return GL_FALSE;
-
-   if (image->InternalFormat != mt->internal_format ||
-       image->IsCompressed != mt->compressed)
-      return GL_FALSE;
-
-   /* Test image dimensions against the base level image adjusted for
-    * minification.  This will also catch images not present in the
-    * tree, changed targets, etc.
-    */
-   if (image->Width != mt->level[level].width ||
-       image->Height != mt->level[level].height ||
-       image->Depth != mt->level[level].depth)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/* Although we use the image_offset[] array to store relative offsets
- * to cube faces, Mesa doesn't know anything about this and expects
- * each cube face to be treated as a separate image.
- *
- * These functions present that view to mesa:
- */
-const GLuint *
-st_miptree_depth_offsets(struct pipe_mipmap_tree *mt, GLuint level)
-{
-   static const GLuint zero = 0;
-
-   if (mt->target != PIPE_TEXTURE_3D || mt->level[level].nr_images == 1)
-      return &zero;
-   else
-      return mt->level[level].image_offset;
-}
-
-
-/**
- * Return the offset to the given mipmap texture image within the
- * texture memory buffer, in bytes.
- */
-GLuint
-st_miptree_image_offset(const struct pipe_mipmap_tree * mt,
-                        GLuint face, GLuint level)
-{
-   if (mt->target == PIPE_TEXTURE_CUBE)
-      return (mt->level[level].level_offset +
-              mt->level[level].image_offset[face] * mt->cpp);
-   else
-      return mt->level[level].level_offset;
-}
-
-
-GLuint
-st_miptree_texel_offset(const struct pipe_mipmap_tree * mt,
-                        GLuint face, GLuint level,
-                        GLuint col, GLuint row, GLuint img)
-{
-   GLuint imgOffset = st_miptree_image_offset(mt, face, level);
-
-   return imgOffset + row * (mt->pitch + col) * mt->cpp;
-}
-
-
-
-/**
- * Map a teximage in a mipmap tree.
- * \param row_stride  returns row stride in bytes
- * \param image_stride  returns image stride in bytes (for 3D textures).
- * \return address of mapping
- */
-GLubyte *
-st_miptree_image_map(struct pipe_context *pipe,
-                        struct pipe_mipmap_tree * mt,
-                        GLuint face,
-                        GLuint level,
-                        GLuint * row_stride, GLuint * image_offsets)
-{
-   GLubyte *ptr;
-   DBG("%s \n", __FUNCTION__);
-
-   if (row_stride)
-      *row_stride = mt->pitch * mt->cpp;
-
-   if (image_offsets)
-      memcpy(image_offsets, mt->level[level].image_offset,
-             mt->level[level].depth * sizeof(GLuint));
-
-   ptr = pipe->region_map(pipe, mt->region);
-
-   return ptr + st_miptree_image_offset(mt, face, level);
-}
-
-void
-st_miptree_image_unmap(struct pipe_context *pipe,
-                          struct pipe_mipmap_tree *mt)
-{
-   DBG("%s\n", __FUNCTION__);
-   pipe->region_unmap(pipe, mt->region);
-}
-
-
-
-/* Upload data for a particular image.
- */
-void
-st_miptree_image_data(struct pipe_context *pipe,
-                      struct pipe_mipmap_tree *dst,
-                      GLuint face,
-                      GLuint level,
-                      void *src,
-                      GLuint src_row_pitch, GLuint src_image_pitch)
-{
-   GLuint depth = dst->level[level].depth;
-   GLuint dst_offset = st_miptree_image_offset(dst, face, level);
-   const GLuint *dst_depth_offset = st_miptree_depth_offsets(dst, level);
-   GLuint i;
-   GLuint height = 0;
-   const GLubyte *srcUB = src;
-
-   DBG("%s\n", __FUNCTION__);
-   for (i = 0; i < depth; i++) {
-      height = dst->level[level].height;
-      if(dst->compressed)
-	 height /= 4;
-      pipe->region_data(pipe, dst->region,
-                        dst_offset + dst_depth_offset[i], /* dst_offset */
-                        0, 0,                             /* dstx, dsty */
-                        srcUB,
-                        src_row_pitch,
-                        0, 0,                             /* source x, y */
-                        dst->level[level].width, height); /* width, height */
-
-      srcUB += src_image_pitch * dst->cpp;
-   }
-}
-
-/* Copy mipmap image between trees
- */
-void
-st_miptree_image_copy(struct pipe_context *pipe,
-                         struct pipe_mipmap_tree *dst,
-                         GLuint face, GLuint level,
-                         struct pipe_mipmap_tree *src)
-{
-   GLuint width = src->level[level].width;
-   GLuint height = src->level[level].height;
-   GLuint depth = src->level[level].depth;
-   GLuint dst_offset = st_miptree_image_offset(dst, face, level);
-   GLuint src_offset = st_miptree_image_offset(src, face, level);
-   const GLuint *dst_depth_offset = st_miptree_depth_offsets(dst, level);
-   const GLuint *src_depth_offset = st_miptree_depth_offsets(src, level);
-   GLuint i;
-
-   if (dst->compressed)
-      height /= 4;
-   for (i = 0; i < depth; i++) {
-      pipe->region_copy(pipe,
-                        dst->region, dst_offset + dst_depth_offset[i],
-                        0, 0, /* destX, Y */
-                        src->region, src_offset + src_depth_offset[i],
-                        0, 0, /* srcX, Y */
-                        width, height);
-   }
-
-}
diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index ce5384671c..e64bf14d56 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -36,8 +36,9 @@
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
+#include "pipe/p_shader_tokens.h"
 #include "pipe/draw/draw_context.h"
-#include "pipe/tgsi/exec/tgsi_core.h"
+#include "pipe/tgsi/util/tgsi_dump.h"
 
 #include "st_context.h"
 #include "st_cache.h"
diff --git a/src/mesa/state_tracker/st_program.h b/src/mesa/state_tracker/st_program.h
index 51877af8da..049f9f659f 100644
--- a/src/mesa/state_tracker/st_program.h
+++ b/src/mesa/state_tracker/st_program.h
@@ -35,7 +35,7 @@
 #define ST_PROGRAM_H
 
 #include "mtypes.h"
-#include "pipe/tgsi/exec/tgsi_token.h"
+#include "pipe/p_shader_tokens.h"
 #include "x86/rtasm/x86sse.h"
 
 
diff --git a/src/mesa/state_tracker/st_public.h b/src/mesa/state_tracker/st_public.h
index 408e1927e5..307635936b 100644
--- a/src/mesa/state_tracker/st_public.h
+++ b/src/mesa/state_tracker/st_public.h
@@ -35,6 +35,7 @@
 #define ST_SURFACE_BACK_LEFT    1
 #define ST_SURFACE_FRONT_RIGHT  2
 #define ST_SURFACE_BACK_RIGHT   3
+#define ST_SURFACE_DEPTH        8
 
 
 struct st_context;
diff --git a/src/mesa/state_tracker/st_texture.c b/src/mesa/state_tracker/st_texture.c
new file mode 100644
index 0000000000..1ec4514873
--- /dev/null
+++ b/src/mesa/state_tracker/st_texture.c
@@ -0,0 +1,275 @@
+/**************************************************************************
+ * 
+ * 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.
+ * 
+ **************************************************************************/
+
+#include "st_context.h"
+#include "st_format.h"
+#include "st_texture.h"
+#include "enums.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "pipe/p_inlines.h"
+#include "pipe/p_util.h"
+#include "pipe/p_inlines.h"
+#include "pipe/p_winsys.h"
+
+
+#define DBG if(0) printf
+
+#if 0
+static GLenum
+target_to_target(GLenum target)
+{
+   switch (target) {
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
+      return GL_TEXTURE_CUBE_MAP_ARB;
+   default:
+      return target;
+   }
+}
+#endif
+
+struct pipe_texture *
+st_texture_create(struct st_context *st,
+                  unsigned target,
+		  unsigned format,
+		  GLenum internal_format,
+		  GLuint first_level,
+		  GLuint last_level,
+		  GLuint width0,
+		  GLuint height0,
+		  GLuint depth0,
+		  GLuint compress_byte)
+{
+   struct pipe_texture *pt = CALLOC_STRUCT(pipe_texture);
+
+   assert(target <= PIPE_TEXTURE_CUBE);
+
+   DBG("%s target %s format %s level %d..%d\n", __FUNCTION__,
+       _mesa_lookup_enum_by_nr(target),
+       _mesa_lookup_enum_by_nr(internal_format), first_level, last_level);
+
+   if (!pt)
+      return NULL;
+
+   assert(format);
+
+   pt->target = target;
+   pt->format = format;
+   pt->internal_format = internal_format;
+   pt->first_level = first_level;
+   pt->last_level = last_level;
+   pt->width[0] = width0;
+   pt->height[0] = height0;
+   pt->depth[0] = depth0;
+   pt->compressed = compress_byte ? 1 : 0;
+   pt->cpp = pt->compressed ? compress_byte : st_sizeof_format(format);
+   pt->refcount = 1; 
+
+   st->pipe->texture_create(st->pipe, &pt);
+
+   return pt;
+}
+
+
+
+
+/* Can the image be pulled into a unified mipmap texture.  This mirrors
+ * the completeness test in a lot of ways.
+ *
+ * Not sure whether I want to pass gl_texture_image here.
+ */
+GLboolean
+st_texture_match_image(struct pipe_texture *pt,
+                          struct gl_texture_image *image,
+                          GLuint face, GLuint level)
+{
+   /* Images with borders are never pulled into mipmap textures. 
+    */
+   if (image->Border) 
+      return GL_FALSE;
+
+   if (image->InternalFormat != pt->internal_format ||
+       image->IsCompressed != pt->compressed)
+      return GL_FALSE;
+
+   /* Test image dimensions against the base level image adjusted for
+    * minification.  This will also catch images not present in the
+    * texture, changed targets, etc.
+    */
+   if (image->Width != pt->width[level] ||
+       image->Height != pt->height[level] ||
+       image->Depth != pt->depth[level])
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
+
+
+#if 000
+/* Although we use the image_offset[] array to store relative offsets
+ * to cube faces, Mesa doesn't know anything about this and expects
+ * each cube face to be treated as a separate image.
+ *
+ * These functions present that view to mesa:
+ */
+const GLuint *
+st_texture_depth_offsets(struct pipe_texture *pt, GLuint level)
+{
+   static const GLuint zero = 0;
+
+   if (pt->target != PIPE_TEXTURE_3D || pt->level[level].nr_images == 1)
+      return &zero;
+   else
+      return pt->level[level].image_offset;
+}
+
+
+/**
+ * Return the offset to the given mipmap texture image within the
+ * texture memory buffer, in bytes.
+ */
+GLuint
+st_texture_image_offset(const struct pipe_texture * pt,
+                        GLuint face, GLuint level)
+{
+   if (pt->target == PIPE_TEXTURE_CUBE)
+      return (pt->level[level].level_offset +
+              pt->level[level].image_offset[face] * pt->cpp);
+   else
+      return pt->level[level].level_offset;
+}
+#endif
+
+
+/**
+ * Map a teximage in a mipmap texture.
+ * \param row_stride  returns row stride in bytes
+ * \param image_stride  returns image stride in bytes (for 3D textures).
+ * \return address of mapping
+ */
+GLubyte *
+st_texture_image_map(struct st_context *st, struct st_texture_image *stImage,
+		     GLuint zoffset)
+{
+   struct pipe_texture *pt = stImage->pt;
+   DBG("%s \n", __FUNCTION__);
+
+   stImage->surface = st->pipe->get_tex_surface(st->pipe, pt, stImage->face,
+						stImage->level,	zoffset);
+
+   return pipe_surface_map(stImage->surface);
+}
+
+void
+st_texture_image_unmap(struct st_texture_image *stImage)
+{
+   DBG("%s\n", __FUNCTION__);
+
+   pipe_surface_unmap(stImage->surface);
+
+   pipe_surface_reference(&stImage->surface, NULL);
+}
+
+
+
+/* Upload data for a particular image.
+ */
+void
+st_texture_image_data(struct pipe_context *pipe,
+                      struct pipe_texture *dst,
+                      GLuint face,
+                      GLuint level,
+                      void *src,
+                      GLuint src_row_pitch, GLuint src_image_pitch)
+{
+   GLuint depth = dst->depth[level];
+   GLuint i;
+   GLuint height = 0;
+   const GLubyte *srcUB = src;
+   struct pipe_surface *dst_surface;
+
+   DBG("%s\n", __FUNCTION__);
+   for (i = 0; i < depth; i++) {
+      height = dst->height[level];
+      if(dst->compressed)
+	 height /= 4;
+
+      dst_surface = pipe->get_tex_surface(pipe, dst, face, level, i);
+
+      pipe->surface_data(pipe, dst_surface,
+			 0, 0,                             /* dstx, dsty */
+			 srcUB,
+			 src_row_pitch,
+			 0, 0,                             /* source x, y */
+			 dst->width[level], height); /* width, height */
+
+      pipe_surface_reference(&dst_surface, NULL);
+
+      srcUB += src_image_pitch * dst->cpp;
+   }
+}
+
+/* Copy mipmap image between textures
+ */
+void
+st_texture_image_copy(struct pipe_context *pipe,
+                         struct pipe_texture *dst,
+                         GLuint face, GLuint level,
+                         struct pipe_texture *src)
+{
+   GLuint width = src->width[level];
+   GLuint height = src->height[level];
+   GLuint depth = src->depth[level];
+   struct pipe_surface *src_surface;
+   struct pipe_surface *dst_surface;
+   GLuint i;
+
+   if (dst->compressed)
+      height /= 4;
+   for (i = 0; i < depth; i++) {
+      dst_surface = pipe->get_tex_surface(pipe, dst, face, level, i);
+      src_surface = pipe->get_tex_surface(pipe, src, face, level, i);
+
+      pipe->surface_copy(pipe,
+			 dst_surface,
+			 0, 0, /* destX, Y */
+			 src_surface,
+			 0, 0, /* srcX, Y */
+			 width, height);
+
+      pipe_surface_reference(&dst_surface, NULL);
+      pipe_surface_reference(&src_surface, NULL);
+   }
+
+}
diff --git a/src/mesa/state_tracker/st_mipmap_tree.h b/src/mesa/state_tracker/st_texture.h
index 3e7fd7fa0c..f49d91a069 100644
--- a/src/mesa/state_tracker/st_mipmap_tree.h
+++ b/src/mesa/state_tracker/st_texture.h
@@ -25,94 +25,84 @@
  * 
  **************************************************************************/
 
-#ifndef ST_MIPMAP_TREE_H
-#define ST_MIPMAP_TREE_H
+#ifndef ST_TEXTURE_H
+#define ST_TEXTURE_H
 
 
 #include "main/mtypes.h"
 
 struct pipe_context;
-struct pipe_mipmap_tree;
+struct pipe_texture;
 struct pipe_region;
 
 
-extern struct pipe_mipmap_tree *
-st_miptree_create(struct pipe_context *pipe,
-                  GLenum target,
+extern struct pipe_texture *
+st_texture_create(struct st_context *st,
+                  unsigned target,
+		  unsigned format,
                   GLenum internal_format,
                   GLuint first_level,
                   GLuint last_level,
                   GLuint width0,
                   GLuint height0,
                   GLuint depth0,
-                  GLuint cpp,
                   GLuint compress_byte);
 
-extern void
-st_miptree_reference(struct pipe_mipmap_tree **dst,
-                     struct pipe_mipmap_tree *src);
-
-extern void
-st_miptree_release(struct pipe_context *pipe, struct pipe_mipmap_tree **mt);
-
 
-/* Check if an image fits an existing mipmap tree layout
+/* Check if an image fits an existing texture
  */
 extern GLboolean
-st_miptree_match_image(struct pipe_mipmap_tree *mt,
+st_texture_match_image(struct pipe_texture *pt,
                        struct gl_texture_image *image,
                        GLuint face, GLuint level);
 
-/* Return a pointer to an image within a tree.  Return image stride as
+/* Return a pointer to an image within a texture.  Return image stride as
  * well.
  */
 extern GLubyte *
-st_miptree_image_map(struct pipe_context *pipe,
-                     struct pipe_mipmap_tree *mt,
-                     GLuint face, GLuint level,
-                     GLuint * row_stride, GLuint * image_stride);
+st_texture_image_map(struct st_context *st,
+                     struct st_texture_image *stImage,
+		     GLuint zoffset);
 
 extern void
-st_miptree_image_unmap(struct pipe_context *pipe,
-                       struct pipe_mipmap_tree *mt);
+st_texture_image_unmap(struct st_texture_image *stImage);
 
 
 /* Return pointers to each 2d slice within an image.  Indexed by depth
  * value.
  */
 extern const GLuint *
-st_miptree_depth_offsets(struct pipe_mipmap_tree *mt, GLuint level);
+st_texture_depth_offsets(struct pipe_texture *pt, GLuint level);
 
 
-/* Return the linear offset of an image relative to the start of the
- * tree:
+/* Return the linear offset of an image relative to the start of its region:
  */
 extern GLuint
-st_miptree_image_offset(const struct pipe_mipmap_tree *mt,
+st_texture_image_offset(const struct pipe_texture *pt,
                         GLuint face, GLuint level);
 
 extern GLuint
-st_miptree_texel_offset(const struct pipe_mipmap_tree * mt,
+st_texture_texel_offset(const struct pipe_texture * pt,
                         GLuint face, GLuint level,
                         GLuint col, GLuint row, GLuint img);
 
 
-/* Upload an image into a tree
+/* Upload an image into a texture
  */
 extern void
-st_miptree_image_data(struct pipe_context *pipe,
-                      struct pipe_mipmap_tree *dst,
+st_texture_image_data(struct pipe_context *pipe,
+                      struct pipe_texture *dst,
                       GLuint face, GLuint level, void *src,
                       GLuint src_row_pitch, GLuint src_image_pitch);
 
 
-/* Copy an image between two trees
+/* Copy an image between two textures
  */
 extern void
-st_miptree_image_copy(struct pipe_context *pipe,
-                      struct pipe_mipmap_tree *dst,
+st_texture_image_copy(struct pipe_context *pipe,
+                      struct pipe_texture *dst,
                       GLuint face, GLuint level,
-                      struct pipe_mipmap_tree *src);
+                      struct pipe_texture *src);
 
 
 #endif