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

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

31 files changed, 1408 insertions, 477 deletions

diff --git a/src/gallium/auxiliary/util/Makefile b/src/gallium/auxiliary/util/Makefile
index 44c23777218..160df8dfa71 100644
--- a/src/gallium/auxiliary/util/Makefile
+++ b/src/gallium/auxiliary/util/Makefile
@@ -4,7 +4,7 @@ include $(TOP)/configs/current
 LIBNAME = util
 
 C_SOURCES = \
-	p_debug.c \
+	u_debug.c \
 	u_blit.c \
 	u_cache.c \
 	u_draw_quad.c \
@@ -27,6 +27,3 @@ C_SOURCES = \
 	u_simple_screen.c
 
 include ../../Makefile.template
-
-symlinks:
-
diff --git a/src/gallium/auxiliary/util/SConscript b/src/gallium/auxiliary/util/SConscript
index 35f683fb8e6..9d5dd006f08 100644
--- a/src/gallium/auxiliary/util/SConscript
+++ b/src/gallium/auxiliary/util/SConscript
@@ -3,11 +3,13 @@ Import('*')
 util = env.ConvenienceLibrary(
 	target = 'util',
 	source = [
-		'p_debug.c',
-		'p_debug_mem.c',
-		'p_debug_prof.c',
+		'u_bitmask.c',
 		'u_blit.c',
 		'u_cache.c',
+		'u_debug.c',
+		'u_debug_memory.c',
+		'u_debug_profile.c',
+		'u_debug_stack.c',
 		'u_draw_quad.c',
 		'u_gen_mipmap.c',
 		'u_handle_table.c',
diff --git a/src/gallium/auxiliary/util/u_bitmask.c b/src/gallium/auxiliary/util/u_bitmask.c
new file mode 100644
index 00000000000..77587c07ec0
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_bitmask.c
@@ -0,0 +1,320 @@
+/**************************************************************************
+ * 
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE 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.
+ * 
+ **************************************************************************/
+
+/**
+ * @file
+ * Generic bitmask implementation.
+ *  
+ * @author Jose Fonseca <[email protected]>
+ */
+
+
+#include "pipe/p_compiler.h"
+#include "util/u_debug.h"
+
+#include "util/u_memory.h"
+#include "util/u_bitmask.h"
+
+
+typedef uint32_t util_bitmask_word;  
+
+
+#define UTIL_BITMASK_INITIAL_WORDS 16
+#define UTIL_BITMASK_BITS_PER_BYTE 8
+#define UTIL_BITMASK_BITS_PER_WORD (sizeof(util_bitmask_word) * UTIL_BITMASK_BITS_PER_BYTE)
+
+
+struct util_bitmask
+{
+   util_bitmask_word *words;
+   
+   /** Number of bits we can currently hold */
+   unsigned size;
+   
+   /** Number of consecutive bits set at the start of the bitmask */
+   unsigned filled;
+};
+
+
+struct util_bitmask *
+util_bitmask_create(void)
+{
+   struct util_bitmask *bm;
+   
+   bm = MALLOC_STRUCT(util_bitmask);
+   if(!bm)
+      return NULL;
+   
+   bm->words = (util_bitmask_word *)CALLOC(UTIL_BITMASK_INITIAL_WORDS, sizeof(util_bitmask_word));
+   if(!bm->words) {
+      FREE(bm);
+      return NULL;
+   }
+   
+   bm->size = UTIL_BITMASK_INITIAL_WORDS * UTIL_BITMASK_BITS_PER_WORD;
+   bm->filled = 0;
+   
+   return bm;
+}
+
+
+/**
+ * Resize the bitmask if necessary 
+ */
+static INLINE boolean
+util_bitmask_resize(struct util_bitmask *bm,
+                    unsigned minimum_index)
+{
+   unsigned minimum_size = minimum_index + 1;
+   unsigned new_size;
+   util_bitmask_word *new_words;
+
+   /* Check integer overflow */
+   if(!minimum_size)
+      return FALSE;
+      
+   if(bm->size > minimum_size)
+      return TRUE;
+
+   assert(bm->size % UTIL_BITMASK_BITS_PER_WORD == 0);
+   new_size = bm->size;
+   while(!(new_size > minimum_size)) {
+      new_size *= 2;
+      /* Check integer overflow */
+      if(new_size < bm->size)
+         return FALSE;
+   }
+   assert(new_size);
+   assert(new_size % UTIL_BITMASK_BITS_PER_WORD == 0);
+   
+   new_words = (util_bitmask_word *)REALLOC((void *)bm->words,
+                                            bm->size / UTIL_BITMASK_BITS_PER_BYTE,
+                                            new_size / UTIL_BITMASK_BITS_PER_BYTE);
+   if(!new_words)
+      return FALSE;
+   
+   memset(new_words + bm->size/UTIL_BITMASK_BITS_PER_WORD, 
+          0, 
+          (new_size - bm->size)/UTIL_BITMASK_BITS_PER_BYTE);
+   
+   bm->size = new_size;
+   bm->words = new_words;
+   
+   return TRUE;
+}
+
+
+/**
+ * Lazily update the filled.
+ */
+static INLINE void
+util_bitmask_filled_set(struct util_bitmask *bm,
+                        unsigned index)
+{
+   assert(bm->filled <= bm->size);
+   assert(index <= bm->size);
+   
+   if(index == bm->filled) {
+      ++bm->filled;
+      assert(bm->filled <= bm->size);
+   }
+}
+
+static INLINE void
+util_bitmask_filled_unset(struct util_bitmask *bm,
+                          unsigned index)
+{
+   assert(bm->filled <= bm->size);
+   assert(index <= bm->size);
+   
+   if(index < bm->filled)
+      bm->filled = index;
+}
+
+
+unsigned
+util_bitmask_add(struct util_bitmask *bm)
+{
+   unsigned word;
+   unsigned bit;
+   util_bitmask_word mask;
+   
+   assert(bm);
+
+   /* linear search for an empty index */
+   word = bm->filled / UTIL_BITMASK_BITS_PER_WORD;
+   bit  = bm->filled % UTIL_BITMASK_BITS_PER_WORD;
+   mask = 1 << bit;
+   while(word < bm->size / UTIL_BITMASK_BITS_PER_WORD) {
+      while(bit < UTIL_BITMASK_BITS_PER_WORD) {
+         if(!(bm->words[word] & mask))
+            goto found;
+         ++bm->filled;
+         ++bit;
+         mask <<= 1;
+      }
+      ++word;
+      bit = 0;
+      mask = 1;
+   }
+found:
+   
+   /* grow the bitmask if necessary */
+   if(!util_bitmask_resize(bm, bm->filled))
+      return UTIL_BITMASK_INVALID_INDEX;
+
+   assert(!(bm->words[word] & mask));
+   bm->words[word] |= mask;
+
+   return bm->filled++;
+}
+
+
+unsigned
+util_bitmask_set(struct util_bitmask *bm, 
+                 unsigned index)
+{
+   unsigned word = index / UTIL_BITMASK_BITS_PER_WORD;
+   unsigned bit  = index % UTIL_BITMASK_BITS_PER_WORD;
+   util_bitmask_word mask = 1 << bit;
+   
+   assert(bm);
+   
+   /* grow the bitmask if necessary */
+   if(!util_bitmask_resize(bm, index))
+      return UTIL_BITMASK_INVALID_INDEX;
+
+   bm->words[word] |= mask;
+
+   util_bitmask_filled_set(bm, index);
+   
+   return index;
+}
+
+
+void
+util_bitmask_clear(struct util_bitmask *bm, 
+                   unsigned index)
+{
+   unsigned word = index / UTIL_BITMASK_BITS_PER_WORD;
+   unsigned bit  = index % UTIL_BITMASK_BITS_PER_WORD;
+   util_bitmask_word mask = 1 << bit;
+   
+   assert(bm);
+   
+   if(index >= bm->size)
+      return;
+
+   bm->words[word] &= ~mask;
+   
+   util_bitmask_filled_unset(bm, index);
+}
+
+
+boolean
+util_bitmask_get(struct util_bitmask *bm, 
+                 unsigned index)
+{
+   unsigned word = index / UTIL_BITMASK_BITS_PER_WORD;
+   unsigned bit  = index % UTIL_BITMASK_BITS_PER_WORD;
+   util_bitmask_word mask = 1 << bit;
+   
+   assert(bm);
+   
+   if(index < bm->filled) {
+      assert(bm->words[word] & mask);
+      return TRUE;
+   }
+
+   if(index > bm->size)
+      return FALSE;
+
+   if(bm->words[word] & mask) {
+      util_bitmask_filled_set(bm, index);
+      return TRUE;
+   }
+   else
+      return FALSE;
+}
+
+
+unsigned
+util_bitmask_get_next_index(struct util_bitmask *bm, 
+                            unsigned index)
+{
+   unsigned word = index / UTIL_BITMASK_BITS_PER_WORD;
+   unsigned bit  = index % UTIL_BITMASK_BITS_PER_WORD;
+   util_bitmask_word mask = 1 << bit;
+
+   if(index < bm->filled) {
+      assert(bm->words[word] & mask);
+      return index;
+   }
+
+   if(index >= bm->size) {
+      return UTIL_BITMASK_INVALID_INDEX;
+   }
+
+   /* Do a linear search */
+   while(word < bm->size / UTIL_BITMASK_BITS_PER_WORD) {
+      while(bit < UTIL_BITMASK_BITS_PER_WORD) {
+         if(bm->words[word] & mask) {
+            if(index == bm->filled) {
+               ++bm->filled;
+               assert(bm->filled <= bm->size);
+            }
+            return index;
+         }
+         ++index;
+         ++bit;
+         mask <<= 1;
+      }
+      ++word;
+      bit = 0;
+      mask = 1;
+   }
+   
+   return UTIL_BITMASK_INVALID_INDEX;
+}
+
+
+unsigned
+util_bitmask_get_first_index(struct util_bitmask *bm)
+{
+   return util_bitmask_get_next_index(bm, 0);
+}
+
+
+void
+util_bitmask_destroy(struct util_bitmask *bm)
+{
+   assert(bm);
+
+   FREE(bm->words);
+   FREE(bm);
+}
+
diff --git a/src/gallium/auxiliary/util/u_bitmask.h b/src/gallium/auxiliary/util/u_bitmask.h
new file mode 100644
index 00000000000..87f1110296a
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_bitmask.h
@@ -0,0 +1,114 @@
+/**************************************************************************
+ * 
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE 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.
+ * 
+ **************************************************************************/
+
+/**
+ * @file
+ * Generic bitmask.
+ *  
+ * @author Jose Fonseca <[email protected]>
+ */
+
+#ifndef U_HANDLE_BITMASK_H_
+#define U_HANDLE_BITMASK_H_
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define UTIL_BITMASK_INVALID_INDEX (~0U)
+   
+   
+/**
+ * Abstract data type to represent arbitrary set of bits.
+ */
+struct util_bitmask;
+
+
+struct util_bitmask *
+util_bitmask_create(void);
+
+
+/**
+ * Search a cleared bit and set it.
+ * 
+ * It searches for the first cleared bit.
+ * 
+ * Returns the bit index on success, or UTIL_BITMASK_INVALID_INDEX on out of 
+ * memory growing the bitmask.
+ */
+unsigned
+util_bitmask_add(struct util_bitmask *bm);
+
+/**
+ * Set a bit.
+ * 
+ * Returns the input index on success, or UTIL_BITMASK_INVALID_INDEX on out of 
+ * memory growing the bitmask.
+ */
+unsigned
+util_bitmask_set(struct util_bitmask *bm, 
+                 unsigned index);
+
+void
+util_bitmask_clear(struct util_bitmask *bm, 
+                   unsigned index);
+
+boolean
+util_bitmask_get(struct util_bitmask *bm, 
+                 unsigned index);
+
+
+void
+util_bitmask_destroy(struct util_bitmask *bm);
+
+
+/**
+ * Search for the first set bit.
+ * 
+ * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. 
+ */
+unsigned
+util_bitmask_get_first_index(struct util_bitmask *bm);
+
+
+/**
+ * Search for the first set bit, starting from the giving index.
+ * 
+ * Returns UTIL_BITMASK_INVALID_INDEX if a set bit cannot be found. 
+ */
+unsigned
+util_bitmask_get_next_index(struct util_bitmask *bm,
+                            unsigned index);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* U_HANDLE_BITMASK_H_ */
diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
index 841e9c01e7e..deb68c43a6c 100644
--- a/src/gallium/auxiliary/util/u_blit.c
+++ b/src/gallium/auxiliary/util/u_blit.c
@@ -34,10 +34,11 @@
 
 
 #include "pipe/p_context.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
 #include "pipe/p_shader_tokens.h"
+#include "pipe/p_state.h"
 
 #include "util/u_blit.h"
 #include "util/u_draw_quad.h"
@@ -59,8 +60,6 @@ struct blit_state
    struct pipe_sampler_state sampler;
    struct pipe_viewport_state viewport;
 
-   struct pipe_shader_state vert_shader;
-   struct pipe_shader_state frag_shader;
    void *vs;
    void *fs;
 
@@ -103,8 +102,7 @@ util_create_blit(struct pipe_context *pipe, struct cso_context *cso)
    memset(&ctx->rasterizer, 0, sizeof(ctx->rasterizer));
    ctx->rasterizer.front_winding = PIPE_WINDING_CW;
    ctx->rasterizer.cull_mode = PIPE_WINDING_NONE;
-   ctx->rasterizer.bypass_clipping = 1;
-   /*ctx->rasterizer.bypass_vs = 1;*/
+   ctx->rasterizer.bypass_vs_clip_and_viewport = 1;
    ctx->rasterizer.gl_rasterization_rules = 1;
 
    /* samplers */
@@ -117,28 +115,20 @@ util_create_blit(struct pipe_context *pipe, struct cso_context *cso)
    ctx->sampler.mag_img_filter = 0; /* set later */
    ctx->sampler.normalized_coords = 1;
 
-   /* viewport (identity, we setup vertices in wincoords) */
-   ctx->viewport.scale[0] = 1.0;
-   ctx->viewport.scale[1] = 1.0;
-   ctx->viewport.scale[2] = 1.0;
-   ctx->viewport.scale[3] = 1.0;
-   ctx->viewport.translate[0] = 0.0;
-   ctx->viewport.translate[1] = 0.0;
-   ctx->viewport.translate[2] = 0.0;
-   ctx->viewport.translate[3] = 0.0;
-
-   /* vertex shader */
+
+   /* vertex shader - still required to provide the linkage between
+    * fragment shader input semantics and vertex_element/buffers.
+    */
    {
       const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
                                       TGSI_SEMANTIC_GENERIC };
       const uint semantic_indexes[] = { 0, 0 };
       ctx->vs = util_make_vertex_passthrough_shader(pipe, 2, semantic_names,
-                                                    semantic_indexes,
-                                                    &ctx->vert_shader);
+                                                    semantic_indexes);
    }
 
    /* fragment shader */
-   ctx->fs = util_make_fragment_tex_shader(pipe, &ctx->frag_shader);
+   ctx->fs = util_make_fragment_tex_shader(pipe);
    ctx->vbuf = NULL;
 
    /* init vertex data that doesn't change */
@@ -163,10 +153,7 @@ util_destroy_blit(struct blit_state *ctx)
    pipe->delete_vs_state(pipe, ctx->vs);
    pipe->delete_fs_state(pipe, ctx->fs);
 
-   FREE((void*) ctx->vert_shader.tokens);
-   FREE((void*) ctx->frag_shader.tokens);
-
-   pipe_buffer_reference(pipe->screen, &ctx->vbuf, NULL);
+   pipe_buffer_reference(&ctx->vbuf, NULL);
 
    FREE(ctx);
 }
@@ -199,7 +186,6 @@ static unsigned
 setup_vertex_data(struct blit_state *ctx,
                   float x0, float y0, float x1, float y1, float z)
 {
-   void *buf;
    unsigned offset;
 
    ctx->vertices[0][0][0] = x0;
@@ -228,12 +214,8 @@ setup_vertex_data(struct blit_state *ctx,
 
    offset = get_next_slot( ctx );
 
-   buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
-                         PIPE_BUFFER_USAGE_CPU_WRITE);
-
-   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
-
-   pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+   pipe_buffer_write(ctx->pipe->screen, ctx->vbuf,
+                     offset, sizeof(ctx->vertices), ctx->vertices);
 
    return offset;
 }
@@ -249,7 +231,6 @@ setup_vertex_data_tex(struct blit_state *ctx,
                       float s0, float t0, float s1, float t1,
                       float z)
 {
-   void *buf;
    unsigned offset;
 
    ctx->vertices[0][0][0] = x0;
@@ -278,12 +259,8 @@ setup_vertex_data_tex(struct blit_state *ctx,
 
    offset = get_next_slot( ctx );
 
-   buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
-                         PIPE_BUFFER_USAGE_CPU_WRITE);
-
-   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
-
-   pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+   pipe_buffer_write(ctx->pipe->screen, ctx->vbuf,
+                     offset, sizeof(ctx->vertices), ctx->vertices);
 
    return offset;
 }
@@ -337,7 +314,7 @@ util_blit_pixels(struct blit_state *ctx,
 
    if(dst->format == src->format && (dstX1 - dstX0) == srcW && (dstY1 - dstY0) == srcH) {
       /* FIXME: this will most surely fail for overlapping rectangles */
-      pipe->surface_copy(pipe, FALSE,
+      pipe->surface_copy(pipe,
 			 dst, dstX0, dstY0,   /* dest */
 			 src, srcX0, srcY0, /* src */
 			 srcW, srcH);     /* size */
@@ -371,14 +348,14 @@ util_blit_pixels(struct blit_state *ctx,
                                      PIPE_BUFFER_USAGE_GPU_WRITE);
 
    /* load temp texture */
-   pipe->surface_copy(pipe, FALSE,
+   pipe->surface_copy(pipe,
                       texSurf, 0, 0,   /* dest */
                       src, srcLeft, srcTop, /* src */
                       srcW, srcH);     /* size */
 
    /* free the surface, update the texture if necessary.
     */
-   screen->tex_surface_release(screen, &texSurf);
+   pipe_surface_reference(&texSurf, NULL);
 
    /* save state (restored below) */
    cso_save_blend(ctx->cso);
@@ -389,13 +366,11 @@ util_blit_pixels(struct blit_state *ctx,
    cso_save_framebuffer(ctx->cso);
    cso_save_fragment_shader(ctx->cso);
    cso_save_vertex_shader(ctx->cso);
-   cso_save_viewport(ctx->cso);
 
    /* set misc state we care about */
    cso_set_blend(ctx->cso, &ctx->blend);
    cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
    cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
-   cso_set_viewport(ctx->cso, &ctx->viewport);
 
    /* sampler */
    ctx->sampler.min_img_filter = filter;
@@ -437,9 +412,8 @@ util_blit_pixels(struct blit_state *ctx,
    cso_restore_framebuffer(ctx->cso);
    cso_restore_fragment_shader(ctx->cso);
    cso_restore_vertex_shader(ctx->cso);
-   cso_restore_viewport(ctx->cso);
 
-   screen->texture_release(screen, &tex);
+   pipe_texture_reference(&tex, NULL);
 }
 
 
@@ -448,7 +422,7 @@ util_blit_pixels(struct blit_state *ctx,
  */
 void util_blit_flush( struct blit_state *ctx )
 {
-   pipe_buffer_reference(ctx->pipe->screen, &ctx->vbuf, NULL);
+   pipe_buffer_reference(&ctx->vbuf, NULL);
    ctx->vbuf_slot = 0;
 } 
 
@@ -471,8 +445,6 @@ util_blit_pixels_tex(struct blit_state *ctx,
                  int dstX1, int dstY1,
                  float z, uint filter)
 {
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_screen *screen = pipe->screen;
    struct pipe_framebuffer_state fb;
    float s0, t0, s1, t1;
    unsigned offset;
@@ -488,8 +460,10 @@ util_blit_pixels_tex(struct blit_state *ctx,
    t0 = srcY0 / (float)tex->height[0];
    t1 = srcY1 / (float)tex->height[0];
 
-   assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+   assert(ctx->pipe->screen->is_format_supported(ctx->pipe->screen, dst->format,
+                                                 PIPE_TEXTURE_2D,
+                                                 PIPE_TEXTURE_USAGE_RENDER_TARGET,
+                                                 0));
 
    /* save state (restored below) */
    cso_save_blend(ctx->cso);
@@ -500,13 +474,11 @@ util_blit_pixels_tex(struct blit_state *ctx,
    cso_save_framebuffer(ctx->cso);
    cso_save_fragment_shader(ctx->cso);
    cso_save_vertex_shader(ctx->cso);
-   cso_save_viewport(ctx->cso);
 
    /* set misc state we care about */
    cso_set_blend(ctx->cso, &ctx->blend);
    cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
    cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
-   cso_set_viewport(ctx->cso, &ctx->viewport);
 
    /* sampler */
    ctx->sampler.min_img_filter = filter;
@@ -551,5 +523,4 @@ util_blit_pixels_tex(struct blit_state *ctx,
    cso_restore_framebuffer(ctx->cso);
    cso_restore_fragment_shader(ctx->cso);
    cso_restore_vertex_shader(ctx->cso);
-   cso_restore_viewport(ctx->cso);
 }
diff --git a/src/gallium/auxiliary/util/u_cache.c b/src/gallium/auxiliary/util/u_cache.c
index 0a1a64259f1..41cd38171fa 100644
--- a/src/gallium/auxiliary/util/u_cache.c
+++ b/src/gallium/auxiliary/util/u_cache.c
@@ -36,7 +36,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #include "util/u_math.h"
 #include "util/u_memory.h"
diff --git a/src/gallium/auxiliary/util/p_debug.c b/src/gallium/auxiliary/util/u_debug.c
index f373f941dd8..f96e27e09fd 100644
--- a/src/gallium/auxiliary/util/p_debug.c
+++ b/src/gallium/auxiliary/util/u_debug.c
@@ -50,6 +50,7 @@
 #define WIN32_LEAN_AND_MEAN      // Exclude rarely-used stuff from Windows headers
 #endif
 #include <windows.h>
+#include <stdio.h>
 
 #else
 
@@ -59,7 +60,7 @@
 #endif
 
 #include "pipe/p_compiler.h" 
-#include "pipe/p_debug.h" 
+#include "util/u_debug.h" 
 #include "pipe/p_format.h" 
 #include "pipe/p_state.h" 
 #include "pipe/p_inlines.h" 
@@ -106,6 +107,12 @@ void _debug_vprintf(const char *format, va_list ap)
       OutputDebugStringA(buf);
       buf[0] = '\0';
    }
+   
+   if(GetConsoleWindow() && !IsDebuggerPresent()) {
+      vfprintf(stderr, format, ap);
+      fflush(stderr);
+   }
+   
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_CE)
    wchar_t *wide_format;
    long wide_str_len;   
@@ -643,34 +650,37 @@ void debug_dump_image(const char *prefix,
 void debug_dump_surface(const char *prefix,
                         struct pipe_surface *surface)     
 {
-   unsigned surface_usage;
+   struct pipe_texture *texture;
+   struct pipe_screen *screen;
+   struct pipe_transfer *transfer;
    void *data;
 
    if (!surface)
-      goto error1;
+      return;
+
+   texture = surface->texture;
+   screen = texture->screen;
 
-   /* XXX: force mappable surface */
-   surface_usage = surface->usage;
-   surface->usage |= PIPE_BUFFER_USAGE_CPU_READ;
+   transfer = screen->get_tex_transfer(screen, texture, surface->face,
+                                       surface->level, surface->zslice,
+                                       PIPE_TRANSFER_READ, 0, 0, surface->width,
+                                       surface->height);
    
-   data = pipe_surface_map(surface, 
-                           PIPE_BUFFER_USAGE_CPU_READ);
+   data = screen->transfer_map(screen, transfer);
    if(!data)
-      goto error2;
+      goto error;
    
    debug_dump_image(prefix, 
-                    surface->format,
-                    surface->block.size, 
-                    surface->nblocksx,
-                    surface->nblocksy,
-                    surface->stride,
+                    transfer->format,
+                    transfer->block.size, 
+                    transfer->nblocksx,
+                    transfer->nblocksy,
+                    transfer->stride,
                     data);
    
-   pipe_surface_unmap(surface);
-error2:
-   surface->usage = surface_usage;
-error1:
-   ;
+   screen->transfer_unmap(screen, transfer);
+error:
+   screen->tex_transfer_destroy(transfer);
 }
 
 
@@ -710,8 +720,10 @@ debug_dump_surface_bmp(const char *filename,
                        struct pipe_surface *surface)
 {
 #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
+   struct pipe_texture *texture;
+   struct pipe_screen *screen;
    struct util_stream *stream;
-   unsigned surface_usage;
+   struct pipe_transfer *transfer;
    struct bmp_file_header bmfh;
    struct bmp_info_header bmih;
    float *rgba;
@@ -748,14 +760,18 @@ debug_dump_surface_bmp(const char *filename,
    
    util_stream_write(stream, &bmfh, 14);
    util_stream_write(stream, &bmih, 40);
+
+   texture = surface->texture;
+   screen = texture->screen;
    
-   /* XXX: force mappable surface */
-   surface_usage = surface->usage;
-   surface->usage |= PIPE_BUFFER_USAGE_CPU_READ;
+   transfer = screen->get_tex_transfer(screen, texture, surface->face,
+                                       surface->level, surface->zslice,
+                                       PIPE_TRANSFER_READ, 0, 0, surface->width,
+                                       surface->height);
 
    y = surface->height;
    while(y--) {
-      pipe_get_tile_rgba(surface,
+      pipe_get_tile_rgba(transfer,
                          0, y, surface->width, 1,
                          rgba);
       for(x = 0; x < surface->width; ++x)
@@ -768,9 +784,9 @@ debug_dump_surface_bmp(const char *filename,
          util_stream_write(stream, &pixel, 4);
       }  
    }
-   
-   surface->usage = surface_usage;
 
+   screen->tex_transfer_destroy(transfer);
+   
    util_stream_close(stream);
 error2:
    FREE(rgba);
diff --git a/src/gallium/auxiliary/util/u_debug.h b/src/gallium/auxiliary/util/u_debug.h
new file mode 100644
index 00000000000..7c829707b20
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_debug.h
@@ -0,0 +1,361 @@
+/**************************************************************************
+ * 
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ **************************************************************************/
+
+/**
+ * @file
+ * Cross-platform debugging helpers.
+ * 
+ * For now it just has assert and printf replacements, but it might be extended 
+ * with stack trace reports and more advanced logging in the near future. 
+ * 
+ * @author Jose Fonseca <[email protected]>
+ */
+
+#ifndef U_DEBUG_H_
+#define U_DEBUG_H_
+
+
+#include <stdarg.h>
+
+#include "pipe/p_compiler.h"
+
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+#if defined(DBG) || defined(DEBUG)
+#ifndef DEBUG
+#define DEBUG 1
+#endif
+#else
+#ifndef NDEBUG
+#define NDEBUG 1
+#endif
+#endif
+
+   
+/* MSVC bebore VC7 does not have the __FUNCTION__ macro */
+#if defined(_MSC_VER) && _MSC_VER < 1300
+#define __FUNCTION__ "???"
+#endif
+
+
+void _debug_vprintf(const char *format, va_list ap);
+   
+
+static INLINE void
+_debug_printf(const char *format, ...)
+{
+   va_list ap;
+   va_start(ap, format);
+   _debug_vprintf(format, ap);
+   va_end(ap);
+}
+
+
+/**
+ * Print debug messages.
+ *
+ * The actual channel used to output debug message is platform specific. To 
+ * avoid misformating or truncation, follow these rules of thumb:   
+ * - output whole lines
+ * - avoid outputing large strings (512 bytes is the current maximum length 
+ * that is guaranteed to be printed in all platforms)
+ */
+static INLINE void
+debug_printf(const char *format, ...)
+{
+#ifdef DEBUG
+   va_list ap;
+   va_start(ap, format);
+   _debug_vprintf(format, ap);
+   va_end(ap);
+#else
+   (void) format; /* silence warning */
+#endif
+}
+
+
+#ifdef DEBUG
+#define debug_vprintf(_format, _ap) _debug_vprintf(_format, _ap)
+#else
+#define debug_vprintf(_format, _ap) ((void)0)
+#endif
+
+
+#ifdef DEBUG
+/**
+ * Dump a blob in hex to the same place that debug_printf sends its
+ * messages.
+ */
+void debug_print_blob( const char *name, const void *blob, unsigned size );
+
+/* Print a message along with a prettified format string
+ */
+void debug_print_format(const char *msg, unsigned fmt );
+#else
+#define debug_print_blob(_name, _blob, _size) ((void)0)
+#define debug_print_format(_msg, _fmt) ((void)0)
+#endif
+
+
+void _debug_break(void);
+
+
+/**
+ * Hard-coded breakpoint.
+ */
+#ifdef DEBUG
+#if defined(PIPE_ARCH_X86) && defined(PIPE_CC_GCC)
+#define debug_break() __asm("int3")
+#elif defined(PIPE_ARCH_X86) && defined(PIPE_CC_MSVC)
+#define debug_break()  do { _asm {int 3} } while(0)
+#else
+#define debug_break() _debug_break()
+#endif
+#else /* !DEBUG */
+#define debug_break() ((void)0)
+#endif /* !DEBUG */
+
+
+long
+debug_get_num_option(const char *name, long dfault);
+
+void _debug_assert_fail(const char *expr, 
+                        const char *file, 
+                        unsigned line, 
+                        const char *function);
+
+
+/** 
+ * Assert macro
+ * 
+ * Do not expect that the assert call terminates -- errors must be handled 
+ * regardless of assert behavior.
+ */
+#ifdef DEBUG
+#define debug_assert(expr) ((expr) ? (void)0 : _debug_assert_fail(#expr, __FILE__, __LINE__, __FUNCTION__))
+#else
+#define debug_assert(expr) ((void)(expr))
+#endif
+
+
+/** Override standard assert macro */
+#ifdef assert
+#undef assert
+#endif
+#define assert(expr) debug_assert(expr)
+
+
+/**
+ * Output the current function name.
+ */
+#ifdef DEBUG
+#define debug_checkpoint() \
+   _debug_printf("%s\n", __FUNCTION__)
+#else
+#define debug_checkpoint() \
+   ((void)0) 
+#endif
+
+
+/**
+ * Output the full source code position.
+ */
+#ifdef DEBUG
+#define debug_checkpoint_full() \
+   _debug_printf("%s:%u:%s", __FILE__, __LINE__, __FUNCTION__) 
+#else
+#define debug_checkpoint_full() \
+   ((void)0) 
+#endif
+
+
+/**
+ * Output a warning message. Muted on release version.
+ */
+#ifdef DEBUG
+#define debug_warning(__msg) \
+   _debug_printf("%s:%u:%s: warning: %s\n", __FILE__, __LINE__, __FUNCTION__, __msg)
+#else
+#define debug_warning(__msg) \
+   ((void)0) 
+#endif
+
+
+/**
+ * Output an error message. Not muted on release version.
+ */
+#ifdef DEBUG
+#define debug_error(__msg) \
+   _debug_printf("%s:%u:%s: error: %s\n", __FILE__, __LINE__, __FUNCTION__, __msg) 
+#else
+#define debug_error(__msg) \
+   _debug_printf("error: %s\n", __msg)
+#endif
+
+
+/**
+ * Used by debug_dump_enum and debug_dump_flags to describe symbols.
+ */
+struct debug_named_value
+{
+   const char *name;
+   unsigned long value;
+};
+
+
+/**
+ * Some C pre-processor magic to simplify creating named values.
+ * 
+ * Example:
+ * @code
+ * static const debug_named_value my_names[] = {
+ *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_X),
+ *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Y),
+ *    DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Z),
+ *    DEBUG_NAMED_VALUE_END
+ * };
+ * 
+ *    ...
+ *    debug_printf("%s = %s\n", 
+ *                 name,
+ *                 debug_dump_enum(my_names, my_value));
+ *    ...
+ * @endcode
+ */
+#define DEBUG_NAMED_VALUE(__symbol) {#__symbol, (unsigned long)__symbol} 
+#define DEBUG_NAMED_VALUE_END {NULL, 0} 
+
+
+/**
+ * Convert a enum value to a string.
+ */
+const char *
+debug_dump_enum(const struct debug_named_value *names, 
+                unsigned long value);
+
+const char *
+debug_dump_enum_noprefix(const struct debug_named_value *names, 
+                         const char *prefix,
+                         unsigned long value);
+
+
+/**
+ * Convert binary flags value to a string.
+ */
+const char *
+debug_dump_flags(const struct debug_named_value *names, 
+                 unsigned long value);
+
+
+/**
+ * Get option.
+ * 
+ * It is an alias for getenv on Linux. 
+ * 
+ * On Windows it reads C:\gallium.cfg, which is a text file with CR+LF line 
+ * endings with one option per line as
+ *  
+ *   NAME=value
+ * 
+ * This file must be terminated with an extra empty line.
+ */
+const char *
+debug_get_option(const char *name, const char *dfault);
+
+boolean
+debug_get_bool_option(const char *name, boolean dfault);
+
+long
+debug_get_num_option(const char *name, long dfault);
+
+unsigned long
+debug_get_flags_option(const char *name, 
+                       const struct debug_named_value *flags,
+                       unsigned long dfault);
+
+
+void *
+debug_malloc(const char *file, unsigned line, const char *function,
+             size_t size);
+
+void
+debug_free(const char *file, unsigned line, const char *function,
+           void *ptr);
+
+void *
+debug_calloc(const char *file, unsigned line, const char *function,
+             size_t count, size_t size );
+
+void *
+debug_realloc(const char *file, unsigned line, const char *function,
+              void *old_ptr, size_t old_size, size_t new_size );
+
+unsigned long
+debug_memory_begin(void);
+
+void 
+debug_memory_end(unsigned long beginning);
+
+
+#if defined(PROFILE) && defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
+
+void
+debug_profile_start(void);
+
+void 
+debug_profile_stop(void);
+
+#endif
+
+
+#ifdef DEBUG
+struct pipe_surface;
+void debug_dump_image(const char *prefix,
+                      unsigned format, unsigned cpp,
+                      unsigned width, unsigned height,
+                      unsigned stride,
+                      const void *data);
+void debug_dump_surface(const char *prefix,
+                        struct pipe_surface *surface);   
+void debug_dump_surface_bmp(const char *filename,
+                            struct pipe_surface *surface);
+#else
+#define debug_dump_image(prefix, format, cpp, width, height, stride, data) ((void)0)
+#define debug_dump_surface(prefix, surface) ((void)0)
+#define debug_dump_surface_bmp(filename, surface) ((void)0)
+#endif
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* U_DEBUG_H_ */
diff --git a/src/gallium/auxiliary/util/p_debug_mem.c b/src/gallium/auxiliary/util/u_debug_memory.c
index 250fd60f634..7623cb93981 100644
--- a/src/gallium/auxiliary/util/p_debug_mem.c
+++ b/src/gallium/auxiliary/util/u_debug_memory.c
@@ -44,11 +44,13 @@
 #include <stdlib.h>
 #endif
 
-#include "pipe/p_debug.h" 
+#include "util/u_debug.h" 
+#include "util/u_debug_stack.h" 
 #include "util/u_double_list.h" 
 
 
 #define DEBUG_MEMORY_MAGIC 0x6e34090aU 
+#define DEBUG_MEMORY_STACK 0 /* XXX: disabled until we have symbol lookup */
 
 
 #if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && !defined(WINCE)
@@ -71,7 +73,11 @@ struct debug_memory_header
    const char *file;
    unsigned line;
    const char *function;
+#if DEBUG_MEMORY_STACK
+   struct debug_stack_frame backtrace[DEBUG_MEMORY_STACK];
+#endif
    size_t size;
+   
    unsigned magic;
 };
 
@@ -136,6 +142,10 @@ debug_malloc(const char *file, unsigned line, const char *function,
    hdr->size = size;
    hdr->magic = DEBUG_MEMORY_MAGIC;
 
+#if DEBUG_MEMORY_STACK
+   debug_backtrace_capture(hdr->backtrace, 0, DEBUG_MEMORY_STACK);
+#endif
+
    ftr = footer_from_header(hdr);
    ftr->magic = DEBUG_MEMORY_MAGIC;
    
@@ -290,6 +300,9 @@ debug_memory_end(unsigned long start_no)
 	 debug_printf("%s:%u:%s: %u bytes at %p not freed\n",
 		      hdr->file, hdr->line, hdr->function,
 		      hdr->size, ptr);
+#if DEBUG_MEMORY_STACK
+	 debug_backtrace_dump(hdr->backtrace, DEBUG_MEMORY_STACK);
+#endif
 	 total_size += hdr->size;
       }
 
diff --git a/src/gallium/auxiliary/util/p_debug_prof.c b/src/gallium/auxiliary/util/u_debug_profile.c
index 5f9772ef917..6d8b244c3ac 100644
--- a/src/gallium/auxiliary/util/p_debug_prof.c
+++ b/src/gallium/auxiliary/util/u_debug_profile.c
@@ -42,7 +42,7 @@
 #include <windows.h>
 #include <winddi.h>
 
-#include "pipe/p_debug.h" 
+#include "util/u_debug.h" 
 #include "util/u_string.h" 
 
 
diff --git a/src/gallium/auxiliary/util/u_debug_stack.c b/src/gallium/auxiliary/util/u_debug_stack.c
new file mode 100644
index 00000000000..76068a65091
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_debug_stack.c
@@ -0,0 +1,97 @@
+/**************************************************************************
+ * 
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE 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.
+ * 
+ **************************************************************************/
+
+/**
+ * @file
+ * Stack backtracing.
+ * 
+ * @author Jose Fonseca <[email protected]>
+ */
+
+#include "u_debug.h"
+#include "u_debug_stack.h"
+
+
+void
+debug_backtrace_capture(struct debug_stack_frame *backtrace,
+                        unsigned start_frame, 
+                        unsigned nr_frames)
+{
+   const void **frame_pointer = NULL;
+   unsigned i = 0;
+
+   if(!nr_frames)
+      return;
+
+#if defined(PIPE_CC_GCC)
+   frame_pointer = ((const void **)__builtin_frame_address(1));
+#elif defined(PIPE_CC_MSVC)
+   __asm {
+      mov frame_pointer, ebp
+   }
+   frame_pointer = (const void **)frame_pointer[0];
+#else
+   frame_pointer = NULL;
+#endif
+  
+   
+#ifdef PIPE_ARCH_X86
+   while(nr_frames) {
+      if(!frame_pointer)
+         break;
+      
+      if(start_frame)
+         --start_frame;
+      else {
+         backtrace[i++].function = frame_pointer[1];
+         --nr_frames;
+      }
+      
+      frame_pointer = (const void **)frame_pointer[0];
+   }
+#endif
+   
+   while(nr_frames) {
+      backtrace[i++].function = NULL;
+      --nr_frames;
+   }
+}
+   
+
+void
+debug_backtrace_dump(const struct debug_stack_frame *backtrace, 
+                     unsigned nr_frames)
+{
+   unsigned i;
+   
+   for(i = 0; i < nr_frames; ++i) {
+      if(!backtrace[i].function)
+         break;
+      debug_printf("\t%p\n", backtrace[i].function);
+   }
+}
+
diff --git a/src/gallium/auxiliary/util/u_debug_stack.h b/src/gallium/auxiliary/util/u_debug_stack.h
new file mode 100644
index 00000000000..f50f04e0f7b
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_debug_stack.h
@@ -0,0 +1,65 @@
+/**************************************************************************
+ * 
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE 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.
+ * 
+ **************************************************************************/
+
+#ifndef U_DEBUG_STACK_H_
+#define U_DEBUG_STACK_H_
+
+
+/**
+ * @file
+ * Stack backtracing.
+ * 
+ * @author Jose Fonseca <[email protected]>
+ */
+
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+struct debug_stack_frame 
+{
+   const void *function;
+};
+   
+
+void
+debug_backtrace_capture(struct debug_stack_frame *backtrace,
+                        unsigned start_frame, 
+                        unsigned nr_frames);
+
+void
+debug_backtrace_dump(const struct debug_stack_frame *backtrace, 
+                     unsigned nr_frames);
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* U_DEBUG_STACK_H_ */
diff --git a/src/gallium/auxiliary/util/u_draw_quad.c b/src/gallium/auxiliary/util/u_draw_quad.c
index f282f3d2891..4110485fb19 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.c
+++ b/src/gallium/auxiliary/util/u_draw_quad.c
@@ -51,9 +51,11 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
    assert(num_attribs <= PIPE_MAX_ATTRIBS);
 
    /* tell pipe about the vertex buffer */
+   memset(&vbuffer, 0, sizeof(vbuffer));
    vbuffer.buffer = vbuf;
    vbuffer.stride = num_attribs * 4 * sizeof(float);  /* vertex size */
    vbuffer.buffer_offset = offset;
+   vbuffer.max_index = num_verts - 1;
    pipe->set_vertex_buffers(pipe, 1, &vbuffer);
 
    /* tell pipe about the vertex attributes */
@@ -127,6 +129,6 @@ util_draw_texquad(struct pipe_context *pipe,
          util_draw_vertex_buffer(pipe, vbuf, 0, PIPE_PRIM_TRIANGLE_FAN, 4, 2);
       }
 
-      pipe_buffer_reference(pipe->screen, &vbuf, NULL);
+      pipe_buffer_reference(&vbuf, NULL);
    }
 }
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.c b/src/gallium/auxiliary/util/u_gen_mipmap.c
index 2b4cdab6cf3..b32ad1cbe98 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.c
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.c
@@ -35,10 +35,11 @@
 
 
 #include "pipe/p_context.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
 #include "pipe/p_shader_tokens.h"
+#include "pipe/p_state.h"
 
 #include "util/u_memory.h"
 #include "util/u_draw_quad.h"
@@ -61,10 +62,7 @@ struct gen_mipmap_state
    struct pipe_depth_stencil_alpha_state depthstencil;
    struct pipe_rasterizer_state rasterizer;
    struct pipe_sampler_state sampler;
-   struct pipe_viewport_state viewport;
 
-   struct pipe_shader_state vert_shader;
-   struct pipe_shader_state frag_shader;
    void *vs;
    void *fs;
 
@@ -78,15 +76,15 @@ struct gen_mipmap_state
 
 enum dtype
 {
-   UBYTE,
-   UBYTE_3_3_2,
-   USHORT,
-   USHORT_4_4_4_4,
-   USHORT_5_6_5,
-   USHORT_1_5_5_5_REV,
-   UINT,
-   FLOAT,
-   HALF_FLOAT
+   DTYPE_UBYTE,
+   DTYPE_UBYTE_3_3_2,
+   DTYPE_USHORT,
+   DTYPE_USHORT_4_4_4_4,
+   DTYPE_USHORT_5_6_5,
+   DTYPE_USHORT_1_5_5_5_REV,
+   DTYPE_UINT,
+   DTYPE_FLOAT,
+   DTYPE_HALF_FLOAT
 };
 
 
@@ -194,7 +192,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
    assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);
    */
 
-   if (datatype == UBYTE && comps == 4) {
+   if (datatype == DTYPE_UBYTE && comps == 4) {
       uint i, j, k;
       const ubyte(*rowA)[4] = (const ubyte(*)[4]) srcRowA;
       const ubyte(*rowB)[4] = (const ubyte(*)[4]) srcRowB;
@@ -207,7 +205,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
       }
    }
-   else if (datatype == UBYTE && comps == 3) {
+   else if (datatype == DTYPE_UBYTE && comps == 3) {
       uint i, j, k;
       const ubyte(*rowA)[3] = (const ubyte(*)[3]) srcRowA;
       const ubyte(*rowB)[3] = (const ubyte(*)[3]) srcRowB;
@@ -219,7 +217,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
       }
    }
-   else if (datatype == UBYTE && comps == 2) {
+   else if (datatype == DTYPE_UBYTE && comps == 2) {
       uint i, j, k;
       const ubyte(*rowA)[2] = (const ubyte(*)[2]) srcRowA;
       const ubyte(*rowB)[2] = (const ubyte(*)[2]) srcRowB;
@@ -230,7 +228,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) >> 2;
       }
    }
-   else if (datatype == UBYTE && comps == 1) {
+   else if (datatype == DTYPE_UBYTE && comps == 1) {
       uint i, j, k;
       const ubyte *rowA = (const ubyte *) srcRowA;
       const ubyte *rowB = (const ubyte *) srcRowB;
@@ -241,7 +239,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
       }
    }
 
-   else if (datatype == USHORT && comps == 4) {
+   else if (datatype == DTYPE_USHORT && comps == 4) {
       uint i, j, k;
       const ushort(*rowA)[4] = (const ushort(*)[4]) srcRowA;
       const ushort(*rowB)[4] = (const ushort(*)[4]) srcRowB;
@@ -254,7 +252,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
       }
    }
-   else if (datatype == USHORT && comps == 3) {
+   else if (datatype == DTYPE_USHORT && comps == 3) {
       uint i, j, k;
       const ushort(*rowA)[3] = (const ushort(*)[3]) srcRowA;
       const ushort(*rowB)[3] = (const ushort(*)[3]) srcRowB;
@@ -266,7 +264,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
       }
    }
-   else if (datatype == USHORT && comps == 2) {
+   else if (datatype == DTYPE_USHORT && comps == 2) {
       uint i, j, k;
       const ushort(*rowA)[2] = (const ushort(*)[2]) srcRowA;
       const ushort(*rowB)[2] = (const ushort(*)[2]) srcRowB;
@@ -277,7 +275,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
       }
    }
-   else if (datatype == USHORT && comps == 1) {
+   else if (datatype == DTYPE_USHORT && comps == 1) {
       uint i, j, k;
       const ushort *rowA = (const ushort *) srcRowA;
       const ushort *rowB = (const ushort *) srcRowB;
@@ -288,7 +286,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
       }
    }
 
-   else if (datatype == FLOAT && comps == 4) {
+   else if (datatype == DTYPE_FLOAT && comps == 4) {
       uint i, j, k;
       const float(*rowA)[4] = (const float(*)[4]) srcRowA;
       const float(*rowB)[4] = (const float(*)[4]) srcRowB;
@@ -305,7 +303,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
                       rowB[j][3] + rowB[k][3]) * 0.25F;
       }
    }
-   else if (datatype == FLOAT && comps == 3) {
+   else if (datatype == DTYPE_FLOAT && comps == 3) {
       uint i, j, k;
       const float(*rowA)[3] = (const float(*)[3]) srcRowA;
       const float(*rowB)[3] = (const float(*)[3]) srcRowB;
@@ -320,7 +318,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
                       rowB[j][2] + rowB[k][2]) * 0.25F;
       }
    }
-   else if (datatype == FLOAT && comps == 2) {
+   else if (datatype == DTYPE_FLOAT && comps == 2) {
       uint i, j, k;
       const float(*rowA)[2] = (const float(*)[2]) srcRowA;
       const float(*rowB)[2] = (const float(*)[2]) srcRowB;
@@ -333,7 +331,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
                       rowB[j][1] + rowB[k][1]) * 0.25F;
       }
    }
-   else if (datatype == FLOAT && comps == 1) {
+   else if (datatype == DTYPE_FLOAT && comps == 1) {
       uint i, j, k;
       const float *rowA = (const float *) srcRowA;
       const float *rowB = (const float *) srcRowB;
@@ -345,7 +343,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
    }
 
 #if 0
-   else if (datatype == HALF_FLOAT && comps == 4) {
+   else if (datatype == HALF_DTYPE_FLOAT && comps == 4) {
       uint i, j, k, comp;
       const half_float(*rowA)[4] = (const half_float(*)[4]) srcRowA;
       const half_float(*rowB)[4] = (const half_float(*)[4]) srcRowB;
@@ -362,7 +360,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          }
       }
    }
-   else if (datatype == HALF_FLOAT && comps == 3) {
+   else if (datatype == DTYPE_HALF_FLOAT && comps == 3) {
       uint i, j, k, comp;
       const half_float(*rowA)[3] = (const half_float(*)[3]) srcRowA;
       const half_float(*rowB)[3] = (const half_float(*)[3]) srcRowB;
@@ -379,7 +377,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          }
       }
    }
-   else if (datatype == HALF_FLOAT && comps == 2) {
+   else if (datatype == DTYPE_HALF_FLOAT && comps == 2) {
       uint i, j, k, comp;
       const half_float(*rowA)[2] = (const half_float(*)[2]) srcRowA;
       const half_float(*rowB)[2] = (const half_float(*)[2]) srcRowB;
@@ -396,7 +394,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          }
       }
    }
-   else if (datatype == HALF_FLOAT && comps == 1) {
+   else if (datatype == DTYPE_HALF_FLOAT && comps == 1) {
       uint i, j, k;
       const half_float *rowA = (const half_float *) srcRowA;
       const half_float *rowB = (const half_float *) srcRowB;
@@ -413,7 +411,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
    }
 #endif
 
-   else if (datatype == UINT && comps == 1) {
+   else if (datatype == DTYPE_UINT && comps == 1) {
       uint i, j, k;
       const uint *rowA = (const uint *) srcRowA;
       const uint *rowB = (const uint *) srcRowB;
@@ -424,7 +422,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
       }
    }
 
-   else if (datatype == USHORT_5_6_5 && comps == 3) {
+   else if (datatype == DTYPE_USHORT_5_6_5 && comps == 3) {
       uint i, j, k;
       const ushort *rowA = (const ushort *) srcRowA;
       const ushort *rowB = (const ushort *) srcRowB;
@@ -449,7 +447,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (blue << 11) | (green << 5) | red;
       }
    }
-   else if (datatype == USHORT_4_4_4_4 && comps == 4) {
+   else if (datatype == DTYPE_USHORT_4_4_4_4 && comps == 4) {
       uint i, j, k;
       const ushort *rowA = (const ushort *) srcRowA;
       const ushort *rowB = (const ushort *) srcRowB;
@@ -479,7 +477,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;
       }
    }
-   else if (datatype == USHORT_1_5_5_5_REV && comps == 4) {
+   else if (datatype == DTYPE_USHORT_1_5_5_5_REV && comps == 4) {
       uint i, j, k;
       const ushort *rowA = (const ushort *) srcRowA;
       const ushort *rowB = (const ushort *) srcRowB;
@@ -509,7 +507,7 @@ do_row(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;
       }
    }
-   else if (datatype == UBYTE_3_3_2 && comps == 3) {
+   else if (datatype == DTYPE_UBYTE_3_3_2 && comps == 3) {
       uint i, j, k;
       const ubyte *rowA = (const ubyte *) srcRowA;
       const ubyte *rowB = (const ubyte *) srcRowB;
@@ -570,7 +568,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
    assert(comps >= 1);
    assert(comps <= 4);
 
-   if ((datatype == UBYTE) && (comps == 4)) {
+   if ((datatype == DTYPE_UBYTE) && (comps == 4)) {
       DECLARE_ROW_POINTERS(ubyte, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -581,7 +579,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(3);
       }
    }
-   else if ((datatype == UBYTE) && (comps == 3)) {
+   else if ((datatype == DTYPE_UBYTE) && (comps == 3)) {
       DECLARE_ROW_POINTERS(ubyte, 3);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -591,7 +589,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(2);
       }
    }
-   else if ((datatype == UBYTE) && (comps == 2)) {
+   else if ((datatype == DTYPE_UBYTE) && (comps == 2)) {
       DECLARE_ROW_POINTERS(ubyte, 2);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -600,7 +598,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(1);
       }
    }
-   else if ((datatype == UBYTE) && (comps == 1)) {
+   else if ((datatype == DTYPE_UBYTE) && (comps == 1)) {
       DECLARE_ROW_POINTERS(ubyte, 1);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -608,7 +606,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(0);
       }
    }
-   else if ((datatype == USHORT) && (comps == 4)) {
+   else if ((datatype == DTYPE_USHORT) && (comps == 4)) {
       DECLARE_ROW_POINTERS(ushort, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -619,7 +617,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(3);
       }
    }
-   else if ((datatype == USHORT) && (comps == 3)) {
+   else if ((datatype == DTYPE_USHORT) && (comps == 3)) {
       DECLARE_ROW_POINTERS(ushort, 3);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -629,7 +627,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(2);
       }
    }
-   else if ((datatype == USHORT) && (comps == 2)) {
+   else if ((datatype == DTYPE_USHORT) && (comps == 2)) {
       DECLARE_ROW_POINTERS(ushort, 2);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -638,7 +636,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(1);
       }
    }
-   else if ((datatype == USHORT) && (comps == 1)) {
+   else if ((datatype == DTYPE_USHORT) && (comps == 1)) {
       DECLARE_ROW_POINTERS(ushort, 1);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -646,7 +644,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_3D(0);
       }
    }
-   else if ((datatype == FLOAT) && (comps == 4)) {
+   else if ((datatype == DTYPE_FLOAT) && (comps == 4)) {
       DECLARE_ROW_POINTERS(float, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -657,7 +655,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_F_3D(3);
       }
    }
-   else if ((datatype == FLOAT) && (comps == 3)) {
+   else if ((datatype == DTYPE_FLOAT) && (comps == 3)) {
       DECLARE_ROW_POINTERS(float, 3);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -667,7 +665,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_F_3D(2);
       }
    }
-   else if ((datatype == FLOAT) && (comps == 2)) {
+   else if ((datatype == DTYPE_FLOAT) && (comps == 2)) {
       DECLARE_ROW_POINTERS(float, 2);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -676,7 +674,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_F_3D(1);
       }
    }
-   else if ((datatype == FLOAT) && (comps == 1)) {
+   else if ((datatype == DTYPE_FLOAT) && (comps == 1)) {
       DECLARE_ROW_POINTERS(float, 1);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -684,7 +682,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_F_3D(0);
       }
    }
-   else if ((datatype == HALF_FLOAT) && (comps == 4)) {
+   else if ((datatype == DTYPE_HALF_FLOAT) && (comps == 4)) {
       DECLARE_ROW_POINTERS(half_float, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -695,7 +693,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_HF_3D(3);
       }
    }
-   else if ((datatype == HALF_FLOAT) && (comps == 3)) {
+   else if ((datatype == DTYPE_HALF_FLOAT) && (comps == 3)) {
       DECLARE_ROW_POINTERS(half_float, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -705,7 +703,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_HF_3D(2);
       }
    }
-   else if ((datatype == HALF_FLOAT) && (comps == 2)) {
+   else if ((datatype == DTYPE_HALF_FLOAT) && (comps == 2)) {
       DECLARE_ROW_POINTERS(half_float, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -714,7 +712,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_HF_3D(1);
       }
    }
-   else if ((datatype == HALF_FLOAT) && (comps == 1)) {
+   else if ((datatype == DTYPE_HALF_FLOAT) && (comps == 1)) {
       DECLARE_ROW_POINTERS(half_float, 4);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -722,7 +720,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          FILTER_HF_3D(0);
       }
    }
-   else if ((datatype == UINT) && (comps == 1)) {
+   else if ((datatype == DTYPE_UINT) && (comps == 1)) {
       const uint *rowA = (const uint *) srcRowA;
       const uint *rowB = (const uint *) srcRowB;
       const uint *rowC = (const uint *) srcRowC;
@@ -738,7 +736,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (float)((double) tmp * 0.125);
       }
    }
-   else if ((datatype == USHORT_5_6_5) && (comps == 3)) {
+   else if ((datatype == DTYPE_USHORT_5_6_5) && (comps == 3)) {
       DECLARE_ROW_POINTERS0(ushort);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -776,7 +774,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (b << 11) | (g << 5) | r;
       }
    }
-   else if ((datatype == USHORT_4_4_4_4) && (comps == 4)) {
+   else if ((datatype == DTYPE_USHORT_4_4_4_4) && (comps == 4)) {
       DECLARE_ROW_POINTERS0(ushort);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -825,7 +823,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (a << 12) | (b << 8) | (g << 4) | r;
       }
    }
-   else if ((datatype == USHORT_1_5_5_5_REV) && (comps == 4)) {
+   else if ((datatype == DTYPE_USHORT_1_5_5_5_REV) && (comps == 4)) {
       DECLARE_ROW_POINTERS0(ushort);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -874,7 +872,7 @@ do_row_3D(enum dtype datatype, uint comps, int srcWidth,
          dst[i] = (a << 15) | (b << 10) | (g << 5) | r;
       }
    }
-   else if ((datatype == UBYTE_3_3_2) && (comps == 3)) {
+   else if ((datatype == DTYPE_UBYTE_3_3_2) && (comps == 3)) {
       DECLARE_ROW_POINTERS0(ushort);
 
       for (i = j = 0, k = k0; i < (uint) dstWidth;
@@ -928,34 +926,34 @@ format_to_type_comps(enum pipe_format pformat,
    case PIPE_FORMAT_X8R8G8B8_UNORM:
    case PIPE_FORMAT_B8G8R8A8_UNORM:
    case PIPE_FORMAT_B8G8R8X8_UNORM:
-      *datatype = UBYTE;
+      *datatype = DTYPE_UBYTE;
       *comps = 4;
       return;
    case PIPE_FORMAT_A1R5G5B5_UNORM:
-      *datatype = USHORT_1_5_5_5_REV;
+      *datatype = DTYPE_USHORT_1_5_5_5_REV;
       *comps = 4;
       return;
    case PIPE_FORMAT_A4R4G4B4_UNORM:
-      *datatype = USHORT_4_4_4_4;
+      *datatype = DTYPE_USHORT_4_4_4_4;
       *comps = 4;
       return;
    case PIPE_FORMAT_R5G6B5_UNORM:
-      *datatype = USHORT_5_6_5;
+      *datatype = DTYPE_USHORT_5_6_5;
       *comps = 3;
       return;
    case PIPE_FORMAT_L8_UNORM:
    case PIPE_FORMAT_A8_UNORM:
    case PIPE_FORMAT_I8_UNORM:
-      *datatype = UBYTE;
+      *datatype = DTYPE_UBYTE;
       *comps = 1;
       return;
    case PIPE_FORMAT_A8L8_UNORM:
-      *datatype = UBYTE;
+      *datatype = DTYPE_UBYTE;
       *comps = 2;
       return;
    default:
       assert(0);
-      *datatype = UBYTE;
+      *datatype = DTYPE_UBYTE;
       *comps = 0;
       break;
    }
@@ -1116,31 +1114,30 @@ make_1d_mipmap(struct gen_mipmap_state *ctx,
 
    for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
       const uint srcLevel = dstLevel - 1;
-      struct pipe_surface *srcSurf, *dstSurf;
+      struct pipe_transfer *srcTrans, *dstTrans;
       void *srcMap, *dstMap;
       
-      srcSurf = screen->get_tex_surface(screen, pt, face, srcLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_READ);
-
-      dstSurf = screen->get_tex_surface(screen, pt, face, dstLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_WRITE);
-
-      srcMap = ((ubyte *) pipe_surface_map(srcSurf,
-                                           PIPE_BUFFER_USAGE_CPU_READ)
-                + srcSurf->offset);
-      dstMap = ((ubyte *) pipe_surface_map(dstSurf,
-                                           PIPE_BUFFER_USAGE_CPU_WRITE)
-                + dstSurf->offset);
+      srcTrans = screen->get_tex_transfer(screen, pt, face, srcLevel, zslice,
+                                          PIPE_TRANSFER_READ, 0, 0,
+                                          pt->width[srcLevel],
+                                          pt->height[srcLevel]);
+      dstTrans = screen->get_tex_transfer(screen, pt, face, dstLevel, zslice,
+                                          PIPE_TRANSFER_WRITE, 0, 0,
+                                          pt->width[dstLevel],
+                                          pt->height[dstLevel]);
+
+      srcMap = (ubyte *) screen->transfer_map(screen, srcTrans);
+      dstMap = (ubyte *) screen->transfer_map(screen, dstTrans);
 
       reduce_1d(pt->format,
-                srcSurf->width, srcMap,
-                dstSurf->width, dstMap);
+                srcTrans->width, srcMap,
+                dstTrans->width, dstMap);
 
-      pipe_surface_unmap(srcSurf);
-      pipe_surface_unmap(dstSurf);
+      screen->transfer_unmap(screen, srcTrans);
+      screen->transfer_unmap(screen, dstTrans);
 
-      pipe_surface_reference(&srcSurf, NULL);
-      pipe_surface_reference(&dstSurf, NULL);
+      screen->tex_transfer_destroy(srcTrans);
+      screen->tex_transfer_destroy(dstTrans);
    }
 }
 
@@ -1160,32 +1157,32 @@ make_2d_mipmap(struct gen_mipmap_state *ctx,
 
    for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
       const uint srcLevel = dstLevel - 1;
-      struct pipe_surface *srcSurf, *dstSurf;
+      struct pipe_transfer *srcTrans, *dstTrans;
       ubyte *srcMap, *dstMap;
       
-      srcSurf = screen->get_tex_surface(screen, pt, face, srcLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_READ);
-      dstSurf = screen->get_tex_surface(screen, pt, face, dstLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_WRITE);
-
-      srcMap = ((ubyte *) pipe_surface_map(srcSurf,
-                                           PIPE_BUFFER_USAGE_CPU_READ)
-                + srcSurf->offset);
-      dstMap = ((ubyte *) pipe_surface_map(dstSurf,
-                                           PIPE_BUFFER_USAGE_CPU_WRITE)
-                + dstSurf->offset);
+      srcTrans = screen->get_tex_transfer(screen, pt, face, srcLevel, zslice,
+                                          PIPE_TRANSFER_READ, 0, 0,
+                                          pt->width[srcLevel],
+                                          pt->height[srcLevel]);
+      dstTrans = screen->get_tex_transfer(screen, pt, face, dstLevel, zslice,
+                                          PIPE_TRANSFER_WRITE, 0, 0,
+                                          pt->width[dstLevel],
+                                          pt->height[dstLevel]);
+
+      srcMap = (ubyte *) screen->transfer_map(screen, srcTrans);
+      dstMap = (ubyte *) screen->transfer_map(screen, dstTrans);
 
       reduce_2d(pt->format,
-                srcSurf->width, srcSurf->height,
-                srcSurf->stride, srcMap,
-                dstSurf->width, dstSurf->height,
-                dstSurf->stride, dstMap);
+                srcTrans->width, srcTrans->height,
+                srcTrans->stride, srcMap,
+                dstTrans->width, dstTrans->height,
+                dstTrans->stride, dstMap);
 
-      pipe_surface_unmap(srcSurf);
-      pipe_surface_unmap(dstSurf);
+      screen->transfer_unmap(screen, srcTrans);
+      screen->transfer_unmap(screen, dstTrans);
 
-      pipe_surface_reference(&srcSurf, NULL);
-      pipe_surface_reference(&dstSurf, NULL);
+      screen->tex_transfer_destroy(srcTrans);
+      screen->tex_transfer_destroy(dstTrans);
    }
 }
 
@@ -1195,6 +1192,7 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
                struct pipe_texture *pt,
                uint face, uint baseLevel, uint lastLevel)
 {
+#if 0
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
    uint dstLevel, zslice = 0;
@@ -1204,37 +1202,36 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
 
    for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
       const uint srcLevel = dstLevel - 1;
-      struct pipe_surface *srcSurf, *dstSurf;
+      struct pipe_transfer *srcTrans, *dstTrans;
       ubyte *srcMap, *dstMap;
       
-      srcSurf = screen->get_tex_surface(screen, pt, face, srcLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_READ);
-      dstSurf = screen->get_tex_surface(screen, pt, face, dstLevel, zslice,
-                                        PIPE_BUFFER_USAGE_CPU_WRITE);
-
-      srcMap = ((ubyte *) pipe_surface_map(srcSurf,
-                                           PIPE_BUFFER_USAGE_CPU_READ)
-                + srcSurf->offset);
-      dstMap = ((ubyte *) pipe_surface_map(dstSurf,
-                                           PIPE_BUFFER_USAGE_CPU_WRITE)
-                + dstSurf->offset);
+      srcTrans = screen->get_tex_transfer(screen, pt, face, srcLevel, zslice,
+                                          PIPE_TRANSFER_READ, 0, 0,
+                                          pt->width[srcLevel],
+                                          pt->height[srcLevel]);
+      dstTrans = screen->get_tex_transfer(screen, pt, face, dstLevel, zslice,
+                                          PIPE_TRANSFER_WRITE, 0, 0,
+                                          pt->width[dstLevel],
+                                          pt->height[dstLevel]);
+
+      srcMap = (ubyte *) screen->transfer_map(screen, srcTrans);
+      dstMap = (ubyte *) screen->transfer_map(screen, dstTrans);
 
-#if 0
       reduce_3d(pt->format,
-                srcSurf->width, srcSurf->height,
-                srcSurf->stride, srcMap,
-                dstSurf->width, dstSurf->height,
-                dstSurf->stride, dstMap);
-#else
-      (void) reduce_3d;
-#endif
+                srcTrans->width, srcTrans->height,
+                srcTrans->stride, srcMap,
+                dstTrans->width, dstTrans->height,
+                dstTrans->stride, dstMap);
 
-      pipe_surface_unmap(srcSurf);
-      pipe_surface_unmap(dstSurf);
+      screen->transfer_unmap(screen, srcTrans);
+      screen->transfer_unmap(screen, dstTrans);
 
-      pipe_surface_reference(&srcSurf, NULL);
-      pipe_surface_reference(&dstSurf, NULL);
+      screen->tex_transfer_destroy(srcTrans);
+      screen->tex_transfer_destroy(dstTrans);
    }
+#else
+   (void) reduce_3d;
+#endif
 }
 
 
@@ -1294,8 +1291,7 @@ util_create_gen_mipmap(struct pipe_context *pipe,
    memset(&ctx->rasterizer, 0, sizeof(ctx->rasterizer));
    ctx->rasterizer.front_winding = PIPE_WINDING_CW;
    ctx->rasterizer.cull_mode = PIPE_WINDING_NONE;
-   ctx->rasterizer.bypass_clipping = 1;
-   /*ctx->rasterizer.bypass_vs = 1;*/
+   ctx->rasterizer.bypass_vs_clip_and_viewport = 1;
    ctx->rasterizer.gl_rasterization_rules = 1;
 
    /* sampler state */
@@ -1306,28 +1302,19 @@ util_create_gen_mipmap(struct pipe_context *pipe,
    ctx->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
    ctx->sampler.normalized_coords = 1;
 
-   /* viewport state (identity, verts are in wincoords) */
-   ctx->viewport.scale[0] = 1.0;
-   ctx->viewport.scale[1] = 1.0;
-   ctx->viewport.scale[2] = 1.0;
-   ctx->viewport.scale[3] = 1.0;
-   ctx->viewport.translate[0] = 0.0;
-   ctx->viewport.translate[1] = 0.0;
-   ctx->viewport.translate[2] = 0.0;
-   ctx->viewport.translate[3] = 0.0;
-
-   /* vertex shader */
+   /* vertex shader - still needed to specify mapping from fragment
+    * shader input semantics to vertex elements 
+    */
    {
       const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
                                       TGSI_SEMANTIC_GENERIC };
       const uint semantic_indexes[] = { 0, 0 };
       ctx->vs = util_make_vertex_passthrough_shader(pipe, 2, semantic_names,
-                                                    semantic_indexes,
-                                                    &ctx->vert_shader);
+                                                    semantic_indexes);
    }
 
    /* fragment shader */
-   ctx->fs = util_make_fragment_tex_shader(pipe, &ctx->frag_shader);
+   ctx->fs = util_make_fragment_tex_shader(pipe);
 
    /* vertex data that doesn't change */
    for (i = 0; i < 4; i++) {
@@ -1369,7 +1356,6 @@ get_next_slot(struct gen_mipmap_state *ctx)
 static unsigned
 set_vertex_data(struct gen_mipmap_state *ctx, float width, float height)
 {
-   void *buf;
    unsigned offset;
 
    ctx->vertices[0][0][0] = 0.0f; /*x*/
@@ -1394,12 +1380,8 @@ set_vertex_data(struct gen_mipmap_state *ctx, float width, float height)
 
    offset = get_next_slot( ctx );
 
-   buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
-                         PIPE_BUFFER_USAGE_CPU_WRITE);
-
-   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
-
-   pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+   pipe_buffer_write(ctx->pipe->screen, ctx->vbuf,
+                     offset, sizeof(ctx->vertices), ctx->vertices);
 
    return offset;
 }
@@ -1417,10 +1399,7 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
    pipe->delete_vs_state(pipe, ctx->vs);
    pipe->delete_fs_state(pipe, ctx->fs);
 
-   FREE((void*) ctx->vert_shader.tokens);
-   FREE((void*) ctx->frag_shader.tokens);
-
-   pipe_buffer_reference(pipe->screen, &ctx->vbuf, NULL);
+   pipe_buffer_reference(&ctx->vbuf, NULL);
 
    FREE(ctx);
 }
@@ -1432,7 +1411,7 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
  */
 void util_gen_mipmap_flush( struct gen_mipmap_state *ctx )
 {
-   pipe_buffer_reference(ctx->pipe->screen, &ctx->vbuf, NULL);
+   pipe_buffer_reference(&ctx->vbuf, NULL);
    ctx->vbuf_slot = 0;
 } 
 
@@ -1476,13 +1455,11 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
    cso_save_framebuffer(ctx->cso);
    cso_save_fragment_shader(ctx->cso);
    cso_save_vertex_shader(ctx->cso);
-   cso_save_viewport(ctx->cso);
 
    /* bind our state */
    cso_set_blend(ctx->cso, &ctx->blend);
    cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
    cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
-   cso_set_viewport(ctx->cso, &ctx->viewport);
 
    cso_set_fragment_shader_handle(ctx->cso, ctx->fs);
    cso_set_vertex_shader_handle(ctx->cso, ctx->vs);
@@ -1528,7 +1505,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
 
       cso_set_sampler_textures(ctx->cso, 1, &pt);
 
-      /* quad coords in window coords (bypassing clipping, viewport mapping) */
+      /* quad coords in window coords (bypassing vs, clip and viewport) */
       offset = set_vertex_data(ctx,
                                (float) pt->width[dstLevel],
                                (float) pt->height[dstLevel]);
@@ -1555,5 +1532,4 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
    cso_restore_framebuffer(ctx->cso);
    cso_restore_fragment_shader(ctx->cso);
    cso_restore_vertex_shader(ctx->cso);
-   cso_restore_viewport(ctx->cso);
 }
diff --git a/src/gallium/auxiliary/util/u_handle_table.c b/src/gallium/auxiliary/util/u_handle_table.c
index 2d15932ce3b..6da7353e259 100644
--- a/src/gallium/auxiliary/util/u_handle_table.c
+++ b/src/gallium/auxiliary/util/u_handle_table.c
@@ -34,7 +34,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #include "util/u_memory.h"
 #include "util/u_handle_table.h"
diff --git a/src/gallium/auxiliary/util/u_hash_table.c b/src/gallium/auxiliary/util/u_hash_table.c
index 0bc8de9632c..2f83e318e44 100644
--- a/src/gallium/auxiliary/util/u_hash_table.c
+++ b/src/gallium/auxiliary/util/u_hash_table.c
@@ -39,7 +39,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #include "cso_cache/cso_hash.h"
 
diff --git a/src/gallium/auxiliary/util/u_keymap.c b/src/gallium/auxiliary/util/u_keymap.c
index 01b17ddb1b3..3f70809efdc 100644
--- a/src/gallium/auxiliary/util/u_keymap.c
+++ b/src/gallium/auxiliary/util/u_keymap.c
@@ -35,7 +35,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_error.h"
 
 #include "cso_cache/cso_hash.h"
diff --git a/src/gallium/auxiliary/util/u_linear.c b/src/gallium/auxiliary/util/u_linear.c
index e999cefe748..6be365e53bb 100644
--- a/src/gallium/auxiliary/util/u_linear.c
+++ b/src/gallium/auxiliary/util/u_linear.c
@@ -1,5 +1,5 @@
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "u_linear.h"
 
 void
diff --git a/src/gallium/auxiliary/util/u_math.h b/src/gallium/auxiliary/util/u_math.h
index ab6f39ac31f..1ecde7a9125 100644
--- a/src/gallium/auxiliary/util/u_math.h
+++ b/src/gallium/auxiliary/util/u_math.h
@@ -40,7 +40,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 
 #ifdef __cplusplus
diff --git a/src/gallium/auxiliary/util/u_memory.h b/src/gallium/auxiliary/util/u_memory.h
index 1a6b596421f..0b18d043adb 100644
--- a/src/gallium/auxiliary/util/u_memory.h
+++ b/src/gallium/auxiliary/util/u_memory.h
@@ -36,7 +36,7 @@
 
 
 #include "util/u_pointer.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 
 #ifdef __cplusplus
@@ -52,11 +52,11 @@ extern "C" {
 #endif
 
 
-#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && defined(DEBUG) 
+#if defined(PIPE_OS_WINDOWS) && defined(DEBUG) 
 
 /* memory debugging */
 
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #define MALLOC( _size ) \
    debug_malloc( __FILE__, __LINE__, __FUNCTION__, _size )
@@ -191,9 +191,11 @@ align_free(void *ptr)
 #if defined(HAVE_POSIX_MEMALIGN)
    FREE(ptr);
 #else
-   void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
-   void *realAddr = *cubbyHole;
-   FREE(realAddr);
+   if (ptr) {
+      void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
+      void *realAddr = *cubbyHole;
+      FREE(realAddr);
+   }
 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 }
 
diff --git a/src/gallium/auxiliary/util/u_mm.c b/src/gallium/auxiliary/util/u_mm.c
index 45ce257b5e5..151a480d34d 100644
--- a/src/gallium/auxiliary/util/u_mm.c
+++ b/src/gallium/auxiliary/util/u_mm.c
@@ -24,7 +24,7 @@
 
 
 #include "pipe/p_compiler.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 
 #include "util/u_memory.h"
 #include "util/u_mm.h"
diff --git a/src/gallium/auxiliary/util/u_rect.c b/src/gallium/auxiliary/util/u_rect.c
index fe81a685be1..74259d453b1 100644
--- a/src/gallium/auxiliary/util/u_rect.c
+++ b/src/gallium/auxiliary/util/u_rect.c
@@ -169,46 +169,35 @@ util_surface_copy(struct pipe_context *pipe,
                   unsigned w, unsigned h)
 {
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_surface *new_src = NULL, *new_dst = NULL;
+   struct pipe_transfer *src_trans, *dst_trans;
    void *dst_map;
    const void *src_map;
 
-   assert(dst->block.size == src->block.size);
-   assert(dst->block.width == src->block.width);
-   assert(dst->block.height == src->block.height);
-
-   if ((src->usage & PIPE_BUFFER_USAGE_CPU_READ) == 0) {
-      /* Need to create new src surface which is CPU readable */
-      assert(src->texture);
-      if (!src->texture)
-         return;
-      new_src = screen->get_tex_surface(screen,
+   assert(src->texture && dst->texture);
+   if (!src->texture || !dst->texture)
+      return;
+   src_trans = screen->get_tex_transfer(screen,
                                         src->texture,
                                         src->face,
                                         src->level,
                                         src->zslice,
-                                        PIPE_BUFFER_USAGE_CPU_READ);
-      src = new_src;
-   }
+                                        PIPE_TRANSFER_READ,
+                                        src_x, src_y, w, h);
 
-   if ((dst->usage & PIPE_BUFFER_USAGE_CPU_WRITE) == 0) {
-      /* Need to create new dst surface which is CPU writable */
-      assert(dst->texture);
-      if (!dst->texture)
-         return;
-      new_dst = screen->get_tex_surface(screen,
+   dst_trans = screen->get_tex_transfer(screen,
                                         dst->texture,
                                         dst->face,
                                         dst->level,
                                         dst->zslice,
-                                        PIPE_BUFFER_USAGE_CPU_WRITE);
-      dst = new_dst;
-   }
+                                        PIPE_TRANSFER_WRITE,
+                                        dst_x, dst_y, w, h);
 
-   src_map = pipe->screen->surface_map(screen,
-                                       src, PIPE_BUFFER_USAGE_CPU_READ);
-   dst_map = pipe->screen->surface_map(screen,
-                                       dst, PIPE_BUFFER_USAGE_CPU_WRITE);
+   assert(dst_trans->block.size == src_trans->block.size);
+   assert(dst_trans->block.width == src_trans->block.width);
+   assert(dst_trans->block.height == src_trans->block.height);
+
+   src_map = pipe->screen->transfer_map(screen, src_trans);
+   dst_map = pipe->screen->transfer_map(screen, dst_trans);
 
    assert(src_map);
    assert(dst_map);
@@ -216,36 +205,25 @@ util_surface_copy(struct pipe_context *pipe,
    if (src_map && dst_map) {
       /* If do_flip, invert src_y position and pass negative src stride */
       pipe_copy_rect(dst_map,
-                     &dst->block,
-                     dst->stride,
-                     dst_x, dst_y,
+                     &dst_trans->block,
+                     dst_trans->stride,
+                     0, 0,
                      w, h,
                      src_map,
-                     do_flip ? -(int) src->stride : src->stride,
-                     src_x,
-                     do_flip ? src_y + h - 1 : src_y);
+                     do_flip ? -(int) src_trans->stride : src_trans->stride,
+                     0,
+                     do_flip ? h - 1 : 0);
    }
 
-   pipe->screen->surface_unmap(pipe->screen, src);
-   pipe->screen->surface_unmap(pipe->screen, dst);
+   pipe->screen->transfer_unmap(pipe->screen, src_trans);
+   pipe->screen->transfer_unmap(pipe->screen, dst_trans);
 
-   if (new_src)
-      screen->tex_surface_release(screen, &new_src);
-   if (new_dst)
-      screen->tex_surface_release(screen, &new_dst);
+   screen->tex_transfer_destroy(src_trans);
+   screen->tex_transfer_destroy(dst_trans);
 }
 
 
 
-static void *
-get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
-{
-   return (char *)dst_map
-      + y / dst->block.height * dst->stride
-      + x / dst->block.width * dst->block.size;
-}
-
-
 #define UBYTE_TO_USHORT(B) ((B) | ((B) << 8))
 
 
@@ -260,42 +238,38 @@ util_surface_fill(struct pipe_context *pipe,
                   unsigned width, unsigned height, unsigned value)
 {
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_surface *new_dst = NULL;
+   struct pipe_transfer *dst_trans;
    void *dst_map;
 
-   if ((dst->usage & PIPE_BUFFER_USAGE_CPU_WRITE) == 0) {
-      /* Need to create new dst surface which is CPU writable */
-      assert(dst->texture);
-      if (!dst->texture)
-         return;
-      new_dst = screen->get_tex_surface(screen,
+   assert(dst->texture);
+   if (!dst->texture)
+      return;
+   dst_trans = screen->get_tex_transfer(screen,
                                         dst->texture,
                                         dst->face,
                                         dst->level,
                                         dst->zslice,
-                                        PIPE_BUFFER_USAGE_CPU_WRITE);
-      dst = new_dst;
-   }
+                                        PIPE_TRANSFER_WRITE,
+                                        dstx, dsty, width, height);
 
-   dst_map = pipe->screen->surface_map(screen,
-                                       dst, PIPE_BUFFER_USAGE_CPU_WRITE);
+   dst_map = pipe->screen->transfer_map(screen, dst_trans);
 
    assert(dst_map);
 
    if (dst_map) {
-      assert(dst->stride > 0);
+      assert(dst_trans->stride > 0);
 
-      switch (dst->block.size) {
+      switch (dst_trans->block.size) {
       case 1:
       case 2:
       case 4:
-         pipe_fill_rect(dst_map, &dst->block, dst->stride,
-                        dstx, dsty, width, height, value);
+         pipe_fill_rect(dst_map, &dst_trans->block, dst_trans->stride,
+                        0, 0, width, height, value);
          break;
       case 8:
          {
             /* expand the 4-byte clear value to an 8-byte value */
-            ushort *row = (ushort *) get_pointer(dst, dst_map, dstx, dsty);
+            ushort *row = (ushort *) dst_map;
             ushort val0 = UBYTE_TO_USHORT((value >>  0) & 0xff);
             ushort val1 = UBYTE_TO_USHORT((value >>  8) & 0xff);
             ushort val2 = UBYTE_TO_USHORT((value >> 16) & 0xff);
@@ -312,7 +286,7 @@ util_surface_fill(struct pipe_context *pipe,
                   row[j*4+2] = val2;
                   row[j*4+3] = val3;
                }
-               row += dst->stride/2;
+               row += dst_trans->stride/2;
             }
          }
          break;
@@ -322,8 +296,6 @@ util_surface_fill(struct pipe_context *pipe,
       }
    }
 
-   pipe->screen->surface_unmap(pipe->screen, dst);
-
-   if (new_dst)
-      screen->tex_surface_release(screen, &new_dst);
+   pipe->screen->transfer_unmap(pipe->screen, dst_trans);
+   screen->tex_transfer_destroy(dst_trans);
 }
diff --git a/src/gallium/auxiliary/util/u_simple_screen.c b/src/gallium/auxiliary/util/u_simple_screen.c
index 089bbbc48a8..8114b53cd0d 100644
--- a/src/gallium/auxiliary/util/u_simple_screen.c
+++ b/src/gallium/auxiliary/util/u_simple_screen.c
@@ -28,6 +28,7 @@
 #include "u_simple_screen.h"
 
 #include "pipe/p_screen.h"
+#include "pipe/p_state.h"
 #include "pipe/internal/p_winsys_screen.h"
 
 
@@ -37,8 +38,12 @@ pass_buffer_create(struct pipe_screen *screen,
                    unsigned usage,
                    unsigned size)
 {
-   return screen->winsys->buffer_create(screen->winsys,
-                                        alignment, usage, size);
+   struct pipe_buffer *buffer =
+      screen->winsys->buffer_create(screen->winsys, alignment, usage, size);
+
+   buffer->screen = screen;
+
+   return buffer;
 }
 
 static struct pipe_buffer *
@@ -46,8 +51,13 @@ pass_user_buffer_create(struct pipe_screen *screen,
                         void *ptr,
                         unsigned bytes)
 {
-   return screen->winsys->user_buffer_create(screen->winsys,
+   struct pipe_buffer *buffer =
+      screen->winsys->user_buffer_create(screen->winsys,
                                              ptr, bytes);
+
+   buffer->screen = screen;
+
+   return buffer;
 }
 
 static struct pipe_buffer *
@@ -57,9 +67,14 @@ pass_surface_buffer_create(struct pipe_screen *screen,
                            unsigned usage,
                            unsigned *stride)
 {
-   return screen->winsys->surface_buffer_create(screen->winsys,
+   struct pipe_buffer *buffer =
+      screen->winsys->surface_buffer_create(screen->winsys,
                                                 width, height,
                                                 format, usage, stride);
+
+   buffer->screen = screen;
+
+   return buffer;
 }
 
 static void *
@@ -79,10 +94,9 @@ pass_buffer_unmap(struct pipe_screen *screen,
 }
 
 static void
-pass_buffer_destroy(struct pipe_screen *screen,
-                    struct pipe_buffer *buf)
+pass_buffer_destroy(struct pipe_buffer *buf)
 {
-   screen->winsys->buffer_destroy(screen->winsys, buf);
+   buf->screen->winsys->buffer_destroy(buf);
 }
 
 
diff --git a/src/gallium/auxiliary/util/u_simple_shaders.c b/src/gallium/auxiliary/util/u_simple_shaders.c
index 706155e99a7..e519c354d25 100644
--- a/src/gallium/auxiliary/util/u_simple_shaders.c
+++ b/src/gallium/auxiliary/util/u_simple_shaders.c
@@ -34,9 +34,8 @@
 
 
 #include "pipe/p_context.h"
-#include "pipe/p_debug.h"
+#include "util/u_debug.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_inlines.h"
 #include "pipe/p_screen.h"
 #include "pipe/p_shader_tokens.h"
 
@@ -56,12 +55,11 @@ void *
 util_make_vertex_passthrough_shader(struct pipe_context *pipe,
                                     uint num_attribs,
                                     const uint *semantic_names,
-                                    const uint *semantic_indexes,
-                                    struct pipe_shader_state *shader)
+                                    const uint *semantic_indexes)
                                     
 {
-   uint maxTokens = 100;
-   struct tgsi_token *tokens;
+   struct pipe_shader_state shader;
+   struct tgsi_token tokens[100];
    struct tgsi_header *header;
    struct tgsi_processor *processor;
    struct tgsi_full_declaration decl;
@@ -69,8 +67,6 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
    const uint procType = TGSI_PROCESSOR_VERTEX;
    uint ti, i;
 
-   tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
-
    /* shader header
     */
    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
@@ -97,7 +93,7 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
       ti += tgsi_build_full_declaration(&decl,
                                         &tokens[ti],
                                         header,
-                                        maxTokens - ti);
+                                        Elements(tokens) - ti);
    }
 
    /* declare outputs */
@@ -112,7 +108,7 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
       ti += tgsi_build_full_declaration(&decl,
                                         &tokens[ti],
                                         header,
-                                        maxTokens - ti);
+                                        Elements(tokens) - ti);
    }
 
    /* emit MOV instructions */
@@ -129,7 +125,7 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
       ti += tgsi_build_full_instruction(&inst,
                                         &tokens[ti],
                                         header,
-                                        maxTokens - ti );
+                                        Elements(tokens) - ti );
    }
 
    /* END instruction */
@@ -140,16 +136,15 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_instruction(&inst,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti );
+                                     Elements(tokens) - ti );
 
 #if 0 /*debug*/
    tgsi_dump(tokens, 0);
 #endif
 
-   shader->tokens = tokens;
-   /*shader->num_tokens = ti;*/
+   shader.tokens = tokens;
 
-   return pipe->create_vs_state(pipe, shader);
+   return pipe->create_vs_state(pipe, &shader);
 }
 
 
@@ -161,11 +156,10 @@ util_make_vertex_passthrough_shader(struct pipe_context *pipe,
  *  END;
  */
 void *
-util_make_fragment_tex_shader(struct pipe_context *pipe,
-                              struct pipe_shader_state *shader)
+util_make_fragment_tex_shader(struct pipe_context *pipe)
 {
-   uint maxTokens = 100;
-   struct tgsi_token *tokens;
+   struct pipe_shader_state shader;
+   struct tgsi_token tokens[100];
    struct tgsi_header *header;
    struct tgsi_processor *processor;
    struct tgsi_full_declaration decl;
@@ -173,8 +167,6 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    const uint procType = TGSI_PROCESSOR_FRAGMENT;
    uint ti;
 
-   tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
-
    /* shader header
     */
    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
@@ -200,7 +192,7 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_declaration(&decl,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti);
+                                     Elements(tokens) - ti);
 
    /* declare color[0] output */
    decl = tgsi_default_full_declaration();
@@ -213,7 +205,7 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_declaration(&decl,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti);
+                                     Elements(tokens) - ti);
 
    /* declare sampler */
    decl = tgsi_default_full_declaration();
@@ -223,7 +215,7 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_declaration(&decl,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti);
+                                     Elements(tokens) - ti);
 
    /* TEX instruction */
    inst = tgsi_default_full_instruction();
@@ -240,7 +232,7 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_instruction(&inst,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti );
+                                     Elements(tokens) - ti );
 
    /* END instruction */
    inst = tgsi_default_full_instruction();
@@ -250,16 +242,15 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_instruction(&inst,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti );
+                                     Elements(tokens) - ti );
 
 #if 0 /*debug*/
    tgsi_dump(tokens, 0);
 #endif
 
-   shader->tokens = tokens;
-   /*shader->num_tokens = ti;*/
+   shader.tokens = tokens;
 
-   return pipe->create_fs_state(pipe, shader);
+   return pipe->create_fs_state(pipe, &shader);
 }
 
 
@@ -270,11 +261,10 @@ util_make_fragment_tex_shader(struct pipe_context *pipe,
  * Make simple fragment color pass-through shader.
  */
 void *
-util_make_fragment_passthrough_shader(struct pipe_context *pipe,
-                                      struct pipe_shader_state *shader)
+util_make_fragment_passthrough_shader(struct pipe_context *pipe)
 {
-   uint maxTokens = 40;
-   struct tgsi_token *tokens;
+   struct pipe_shader_state shader;
+   struct tgsi_token tokens[40];
    struct tgsi_header *header;
    struct tgsi_processor *processor;
    struct tgsi_full_declaration decl;
@@ -282,8 +272,6 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe,
    const uint procType = TGSI_PROCESSOR_FRAGMENT;
    uint ti;
 
-   tokens = (struct tgsi_token *) MALLOC(maxTokens * sizeof(tokens[0]));
-
    /* shader header
     */
    *(struct tgsi_version *) &tokens[0] = tgsi_build_version();
@@ -307,7 +295,7 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_declaration(&decl,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti);
+                                     Elements(tokens) - ti);
 
    /* declare output */
    decl = tgsi_default_full_declaration();
@@ -320,7 +308,7 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_declaration(&decl,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti);
+                                     Elements(tokens) - ti);
 
 
    /* MOVE out[0], in[0]; */
@@ -335,7 +323,7 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_instruction(&inst,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti );
+                                     Elements(tokens) - ti );
 
    /* END instruction */
    inst = tgsi_default_full_instruction();
@@ -345,17 +333,17 @@ util_make_fragment_passthrough_shader(struct pipe_context *pipe,
    ti += tgsi_build_full_instruction(&inst,
                                      &tokens[ti],
                                      header,
-                                     maxTokens - ti );
+                                     Elements(tokens) - ti );
 
-   assert(ti < maxTokens);
+   assert(ti < Elements(tokens));
 
 #if 0 /*debug*/
    tgsi_dump(tokens, 0);
 #endif
 
-   shader->tokens = tokens;
-   /*shader->num_tokens = ti;*/
+   shader.tokens = tokens;
 
-   return pipe->create_fs_state(pipe, shader);
+   return pipe->create_fs_state(pipe, &shader);
 }
 
+
diff --git a/src/gallium/auxiliary/util/u_simple_shaders.h b/src/gallium/auxiliary/util/u_simple_shaders.h
index 8ca4977d715..6f8d96af9bc 100644
--- a/src/gallium/auxiliary/util/u_simple_shaders.h
+++ b/src/gallium/auxiliary/util/u_simple_shaders.h
@@ -46,18 +46,15 @@ extern void *
 util_make_vertex_passthrough_shader(struct pipe_context *pipe,
                                     uint num_attribs,
                                     const uint *semantic_names,
-                                    const uint *semantic_indexes,
-                                    struct pipe_shader_state *shader);
+                                    const uint *semantic_indexes);
 
 
 extern void *
-util_make_fragment_tex_shader(struct pipe_context *pipe,
-                              struct pipe_shader_state *shader);
+util_make_fragment_tex_shader(struct pipe_context *pipe);
 
 
 extern void *
-util_make_fragment_passthrough_shader(struct pipe_context *pipe,
-                                      struct pipe_shader_state *shader);
+util_make_fragment_passthrough_shader(struct pipe_context *pipe);
 
 
 #ifdef __cplusplus
diff --git a/src/gallium/auxiliary/util/u_stream_stdc.c b/src/gallium/auxiliary/util/u_stream_stdc.c
index ca80bef0f3d..0ead45a7491 100644
--- a/src/gallium/auxiliary/util/u_stream_stdc.c
+++ b/src/gallium/auxiliary/util/u_stream_stdc.c
@@ -32,7 +32,7 @@
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX) || defined(PIPE_SUBSYSTEM_WINDOWS_USER)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_SUBSYSTEM_WINDOWS_USER)
 
 #include <stdio.h>
 
diff --git a/src/gallium/auxiliary/util/u_tile.c b/src/gallium/auxiliary/util/u_tile.c
index 32f6b072a00..d31ca9c029e 100644
--- a/src/gallium/auxiliary/util/u_tile.c
+++ b/src/gallium/auxiliary/util/u_tile.c
@@ -28,7 +28,6 @@
 /**
  * RGBA/float tile get/put functions.
  * Usable both by drivers and state trackers.
- * Surfaces should already be in a mapped state.
  */
 
 
@@ -42,58 +41,58 @@
 
 
 /**
- * Move raw block of pixels from surface to user memory.
- * This should be usable by any hw driver that has mappable surfaces.
+ * Move raw block of pixels from transfer object to user memory.
  */
 void
-pipe_get_tile_raw(struct pipe_surface *ps,
+pipe_get_tile_raw(struct pipe_transfer *pt,
                   uint x, uint y, uint w, uint h,
                   void *dst, int dst_stride)
 {
+   struct pipe_screen *screen = pt->texture->screen;
    const void *src;
 
    if (dst_stride == 0)
-      dst_stride = pf_get_nblocksx(&ps->block, w) * ps->block.size;
+      dst_stride = pf_get_nblocksx(&pt->block, w) * pt->block.size;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   src = pipe_surface_map(ps, PIPE_BUFFER_USAGE_CPU_READ);
+   src = screen->transfer_map(screen, pt);
    assert(src);
    if(!src)
       return;
 
-   pipe_copy_rect(dst, &ps->block, dst_stride, 0, 0, w, h, src, ps->stride, x, y);
+   pipe_copy_rect(dst, &pt->block, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
 
-   pipe_surface_unmap(ps);
+   screen->transfer_unmap(screen, pt);
 }
 
 
 /**
- * Move raw block of pixels from user memory to surface.
- * This should be usable by any hw driver that has mappable surfaces.
+ * Move raw block of pixels from user memory to transfer object.
  */
 void
-pipe_put_tile_raw(struct pipe_surface *ps,
+pipe_put_tile_raw(struct pipe_transfer *pt,
                   uint x, uint y, uint w, uint h,
                   const void *src, int src_stride)
 {
+   struct pipe_screen *screen = pt->texture->screen;
    void *dst;
 
    if (src_stride == 0)
-      src_stride = pf_get_nblocksx(&ps->block, w) * ps->block.size;
+      src_stride = pf_get_nblocksx(&pt->block, w) * pt->block.size;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   dst = pipe_surface_map(ps, PIPE_BUFFER_USAGE_CPU_WRITE);
+   dst = screen->transfer_map(screen, pt);
    assert(dst);
    if(!dst)
       return;
 
-   pipe_copy_rect(dst, &ps->block, ps->stride, x, y, w, h, src, src_stride, 0, 0);
+   pipe_copy_rect(dst, &pt->block, pt->stride, x, y, w, h, src, src_stride, 0, 0);
 
-   pipe_surface_unmap(ps);
+   screen->transfer_unmap(screen, pt);
 }
 
 
@@ -883,6 +882,27 @@ ycbcr_get_tile_rgba(const ushort *src,
 }
 
 
+static void
+fake_get_tile_rgba(const ushort *src,
+                   unsigned w, unsigned h,
+                   float *p,
+                   unsigned dst_stride)
+{
+   unsigned i, j;
+
+   for (i = 0; i < h; i++) {
+      float *pRow = p;
+      for (j = 0; j < w; j++, pRow += 4) {
+         pRow[0] =
+         pRow[1] =
+         pRow[2] =
+         pRow[3] = (i ^ j) & 1 ? 1.0f : 0.0f;
+      }
+      p += dst_stride;
+   }
+}
+
+
 void
 pipe_tile_raw_to_rgba(enum pipe_format format,
                       void *src,
@@ -949,55 +969,56 @@ pipe_tile_raw_to_rgba(enum pipe_format format,
       ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, TRUE);
       break;
    default:
-      assert(0);
+      debug_printf("%s: unsupported format %s\n", __FUNCTION__, pf_name(format));
+      fake_get_tile_rgba(src, w, h, dst, dst_stride);
    }
 }
 
 
 void
-pipe_get_tile_rgba(struct pipe_surface *ps,
+pipe_get_tile_rgba(struct pipe_transfer *pt,
                    uint x, uint y, uint w, uint h,
                    float *p)
 {
    unsigned dst_stride = w * 4;
    void *packed;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   packed = MALLOC(pf_get_nblocks(&ps->block, w, h) * ps->block.size);
+   packed = MALLOC(pf_get_nblocks(&pt->block, w, h) * pt->block.size);
 
    if (!packed)
       return;
 
-   if(ps->format == PIPE_FORMAT_YCBCR || ps->format == PIPE_FORMAT_YCBCR_REV)
+   if(pt->format == PIPE_FORMAT_YCBCR || pt->format == PIPE_FORMAT_YCBCR_REV)
       assert((x & 1) == 0);
 
-   pipe_get_tile_raw(ps, x, y, w, h, packed, 0);
+   pipe_get_tile_raw(pt, x, y, w, h, packed, 0);
 
-   pipe_tile_raw_to_rgba(ps->format, packed, w, h, p, dst_stride);
+   pipe_tile_raw_to_rgba(pt->format, packed, w, h, p, dst_stride);
 
    FREE(packed);
 }
 
 
 void
-pipe_put_tile_rgba(struct pipe_surface *ps,
+pipe_put_tile_rgba(struct pipe_transfer *pt,
                    uint x, uint y, uint w, uint h,
                    const float *p)
 {
    unsigned src_stride = w * 4;
    void *packed;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   packed = MALLOC(pf_get_nblocks(&ps->block, w, h) * ps->block.size);
+   packed = MALLOC(pf_get_nblocks(&pt->block, w, h) * pt->block.size);
 
    if (!packed)
       return;
 
-   switch (ps->format) {
+   switch (pt->format) {
    case PIPE_FORMAT_A8R8G8B8_UNORM:
       a8r8g8b8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
       break;
@@ -1051,10 +1072,10 @@ pipe_put_tile_rgba(struct pipe_surface *ps,
       /*z24s8_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);*/
       break;
    default:
-      assert(0);
+      debug_printf("%s: unsupported format %s\n", __FUNCTION__, pf_name(pt->format));
    }
 
-   pipe_put_tile_raw(ps, x, y, w, h, packed, 0);
+   pipe_put_tile_raw(pt, x, y, w, h, packed, 0);
 
    FREE(packed);
 }
@@ -1064,62 +1085,63 @@ pipe_put_tile_rgba(struct pipe_surface *ps,
  * Get a block of Z values, converted to 32-bit range.
  */
 void
-pipe_get_tile_z(struct pipe_surface *ps,
+pipe_get_tile_z(struct pipe_transfer *pt,
                 uint x, uint y, uint w, uint h,
                 uint *z)
 {
+   struct pipe_screen *screen = pt->texture->screen;
    const uint dstStride = w;
    ubyte *map;
    uint *pDest = z;
    uint i, j;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   map = (ubyte *)pipe_surface_map(ps, PIPE_BUFFER_USAGE_CPU_READ);
+   map = (ubyte *)screen->transfer_map(screen, pt);
    if (!map) {
       assert(0);
       return;
    }
 
-   switch (ps->format) {
+   switch (pt->format) {
    case PIPE_FORMAT_Z32_UNORM:
       {
-         const uint *pSrc
-            = (const uint *)(map  + y * ps->stride + x*4);
+         const uint *ptrc
+            = (const uint *)(map  + y * pt->stride + x*4);
          for (i = 0; i < h; i++) {
-            memcpy(pDest, pSrc, 4 * w);
+            memcpy(pDest, ptrc, 4 * w);
             pDest += dstStride;
-            pSrc += ps->stride/4;
+            ptrc += pt->stride/4;
          }
       }
       break;
    case PIPE_FORMAT_S8Z24_UNORM:
    case PIPE_FORMAT_X8Z24_UNORM:
       {
-         const uint *pSrc
-            = (const uint *)(map + y * ps->stride + x*4);
+         const uint *ptrc
+            = (const uint *)(map + y * pt->stride + x*4);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 24-bit Z to 32-bit Z */
-               pDest[j] = (pSrc[j] << 8) | (pSrc[j] & 0xff);
+               pDest[j] = (ptrc[j] << 8) | (ptrc[j] & 0xff);
             }
             pDest += dstStride;
-            pSrc += ps->stride/4;
+            ptrc += pt->stride/4;
          }
       }
       break;
    case PIPE_FORMAT_Z16_UNORM:
       {
-         const ushort *pSrc
-            = (const ushort *)(map + y * ps->stride + x*2);
+         const ushort *ptrc
+            = (const ushort *)(map + y * pt->stride + x*2);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 16-bit Z to 32-bit Z */
-               pDest[j] = (pSrc[j] << 16) | pSrc[j];
+               pDest[j] = (ptrc[j] << 16) | ptrc[j];
             }
             pDest += dstStride;
-            pSrc += ps->stride/2;
+            ptrc += pt->stride/2;
          }
       }
       break;
@@ -1127,64 +1149,65 @@ pipe_get_tile_z(struct pipe_surface *ps,
       assert(0);
    }
 
-   pipe_surface_unmap(ps);
+   screen->transfer_unmap(screen, pt);
 }
 
 
 void
-pipe_put_tile_z(struct pipe_surface *ps,
+pipe_put_tile_z(struct pipe_transfer *pt,
                 uint x, uint y, uint w, uint h,
                 const uint *zSrc)
 {
+   struct pipe_screen *screen = pt->texture->screen;
    const uint srcStride = w;
-   const uint *pSrc = zSrc;
+   const uint *ptrc = zSrc;
    ubyte *map;
    uint i, j;
 
-   if (pipe_clip_tile(x, y, &w, &h, ps))
+   if (pipe_clip_tile(x, y, &w, &h, pt))
       return;
 
-   map = (ubyte *)pipe_surface_map(ps, PIPE_BUFFER_USAGE_CPU_WRITE);
+   map = (ubyte *)screen->transfer_map(screen, pt);
    if (!map) {
       assert(0);
       return;
    }
 
-   switch (ps->format) {
+   switch (pt->format) {
    case PIPE_FORMAT_Z32_UNORM:
       {
-         uint *pDest = (uint *) (map + y * ps->stride + x*4);
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
          for (i = 0; i < h; i++) {
-            memcpy(pDest, pSrc, 4 * w);
-            pDest += ps->stride/4;
-            pSrc += srcStride;
+            memcpy(pDest, ptrc, 4 * w);
+            pDest += pt->stride/4;
+            ptrc += srcStride;
          }
       }
       break;
    case PIPE_FORMAT_S8Z24_UNORM:
    case PIPE_FORMAT_X8Z24_UNORM:
       {
-         uint *pDest = (uint *) (map + y * ps->stride + x*4);
+         uint *pDest = (uint *) (map + y * pt->stride + x*4);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 24-bit Z (0 stencil) */
-               pDest[j] = pSrc[j] >> 8;
+               pDest[j] = ptrc[j] >> 8;
             }
-            pDest += ps->stride/4;
-            pSrc += srcStride;
+            pDest += pt->stride/4;
+            ptrc += srcStride;
          }
       }
       break;
    case PIPE_FORMAT_Z16_UNORM:
       {
-         ushort *pDest = (ushort *) (map + y * ps->stride + x*2);
+         ushort *pDest = (ushort *) (map + y * pt->stride + x*2);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 16-bit Z */
-               pDest[j] = pSrc[j] >> 16;
+               pDest[j] = ptrc[j] >> 16;
             }
-            pDest += ps->stride/2;
-            pSrc += srcStride;
+            pDest += pt->stride/2;
+            ptrc += srcStride;
          }
       }
       break;
@@ -1192,7 +1215,7 @@ pipe_put_tile_z(struct pipe_surface *ps,
       assert(0);
    }
 
-   pipe_surface_unmap(ps);
+   screen->transfer_unmap(screen, pt);
 }
 
 
diff --git a/src/gallium/auxiliary/util/u_tile.h b/src/gallium/auxiliary/util/u_tile.h
index a8ac8053083..1453af38b8a 100644
--- a/src/gallium/auxiliary/util/u_tile.h
+++ b/src/gallium/auxiliary/util/u_tile.h
@@ -30,24 +30,24 @@
 
 #include "pipe/p_compiler.h"
 
-struct pipe_surface;
+struct pipe_transfer;
 
 
 /**
- * Clip tile against surface dims.
+ * Clip tile against transfer dims.
  * \return TRUE if tile is totally clipped, FALSE otherwise
  */
 static INLINE boolean
-pipe_clip_tile(uint x, uint y, uint *w, uint *h, const struct pipe_surface *ps)
+pipe_clip_tile(uint x, uint y, uint *w, uint *h, const struct pipe_transfer *pt)
 {
-   if (x >= ps->width)
+   if (x >= pt->width)
       return TRUE;
-   if (y >= ps->height)
+   if (y >= pt->height)
       return TRUE;
-   if (x + *w > ps->width)
-      *w = ps->width - x;
-   if (y + *h > ps->height)
-      *h = ps->height - y;
+   if (x + *w > pt->width)
+      *w = pt->width - x;
+   if (y + *h > pt->height)
+      *h = pt->height - y;
    return FALSE;
 }
 
@@ -56,34 +56,34 @@ extern "C" {
 #endif
 
 void
-pipe_get_tile_raw(struct pipe_surface *ps,
+pipe_get_tile_raw(struct pipe_transfer *pt,
                   uint x, uint y, uint w, uint h,
                   void *p, int dst_stride);
 
 void
-pipe_put_tile_raw(struct pipe_surface *ps,
+pipe_put_tile_raw(struct pipe_transfer *pt,
                   uint x, uint y, uint w, uint h,
                   const void *p, int src_stride);
 
 
 void
-pipe_get_tile_rgba(struct pipe_surface *ps,
+pipe_get_tile_rgba(struct pipe_transfer *pt,
                    uint x, uint y, uint w, uint h,
                    float *p);
 
 void
-pipe_put_tile_rgba(struct pipe_surface *ps,
+pipe_put_tile_rgba(struct pipe_transfer *pt,
                    uint x, uint y, uint w, uint h,
                    const float *p);
 
 
 void
-pipe_get_tile_z(struct pipe_surface *ps,
+pipe_get_tile_z(struct pipe_transfer *pt,
                 uint x, uint y, uint w, uint h,
                 uint *z);
 
 void
-pipe_put_tile_z(struct pipe_surface *ps,
+pipe_put_tile_z(struct pipe_transfer *pt,
                 uint x, uint y, uint w, uint h,
                 const uint *z);
 
diff --git a/src/gallium/auxiliary/util/u_time.c b/src/gallium/auxiliary/util/u_time.c
index dde2c74fa83..357d9360c90 100644
--- a/src/gallium/auxiliary/util/u_time.c
+++ b/src/gallium/auxiliary/util/u_time.c
@@ -35,7 +35,7 @@
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
 #include <sys/time.h>
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
 #include <windows.h>
@@ -77,7 +77,7 @@ util_time_get_frequency(void)
 void 
 util_time_get(struct util_time *t)
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    gettimeofday(&t->tv, NULL);
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
    LONGLONG temp;
@@ -102,7 +102,7 @@ util_time_add(const struct util_time *t1,
               int64_t usecs,
               struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    t2->tv.tv_sec = t1->tv.tv_sec + usecs / 1000000;
    t2->tv.tv_usec = t1->tv.tv_usec + usecs % 1000000;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
@@ -124,7 +124,7 @@ int64_t
 util_time_diff(const struct util_time *t1, 
                const struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    return (t2->tv.tv_usec - t1->tv.tv_usec) + 
           (t2->tv.tv_sec - t1->tv.tv_sec)*1000000;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
@@ -144,7 +144,7 @@ util_time_micros( void )
    
    util_time_get(&t1);
    
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    return t1.tv.tv_usec + t1.tv.tv_sec*1000000LL;
 #elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
    util_time_get_frequency();
@@ -166,7 +166,7 @@ static INLINE int
 util_time_compare(const struct util_time *t1, 
                   const struct util_time *t2)
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    if (t1->tv.tv_sec < t2->tv.tv_sec)
       return -1;
    else if(t1->tv.tv_sec > t2->tv.tv_sec)
diff --git a/src/gallium/auxiliary/util/u_time.h b/src/gallium/auxiliary/util/u_time.h
index 35d97d16c73..4346ce1fa45 100644
--- a/src/gallium/auxiliary/util/u_time.h
+++ b/src/gallium/auxiliary/util/u_time.h
@@ -38,7 +38,7 @@
 
 #include "pipe/p_config.h"
 
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
 #include <time.h> /* timeval */
 #include <unistd.h> /* usleep */
 #endif
@@ -58,7 +58,7 @@ extern "C" {
  */
 struct util_time 
 {
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
    struct timeval tv;
 #else
    int64_t counter;
@@ -89,7 +89,7 @@ util_time_timeout(const struct util_time *start,
                   const struct util_time *end,
                   const struct util_time *curr);
 
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD)
 #define util_time_sleep usleep
 #else
 void
diff --git a/src/gallium/auxiliary/util/u_timed_winsys.c b/src/gallium/auxiliary/util/u_timed_winsys.c
index f237e12d735..77b2a3a1c87 100644
--- a/src/gallium/auxiliary/util/u_timed_winsys.c
+++ b/src/gallium/auxiliary/util/u_timed_winsys.c
@@ -29,6 +29,7 @@
  * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  */
 
+#include "pipe/p_state.h"
 #include "pipe/internal/p_winsys_screen.h"
 #include "u_timed_winsys.h"
 #include "util/u_memory.h"
@@ -178,13 +179,13 @@ timed_buffer_unmap(struct pipe_winsys *winsys,
 
 
 static void
-timed_buffer_destroy(struct pipe_winsys *winsys,
-                         struct pipe_buffer *buf)
+timed_buffer_destroy(struct pipe_buffer *buf)
 {
+   struct pipe_winsys *winsys = buf->screen->winsys;
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   backend->buffer_destroy( backend, buf );
+   backend->buffer_destroy( buf );
 
    time_finish(winsys, start, 4, __FUNCTION__);
 }