r300: convert to pipe_resources

Do a very shallow conversion - basically keeping the existing
buffer and texture code intact and using a vtbl struct
inside our resource struct to select between the two implementations.

The buffer and texture treatments could be further merged without
much effort, but try to keep the existing code working at this point.

20 files changed, 630 insertions, 420 deletions

diff --git a/src/gallium/drivers/r300/Makefile b/src/gallium/drivers/r300/Makefile
index a6529b2060..5a8e00f15a 100644
--- a/src/gallium/drivers/r300/Makefile
+++ b/src/gallium/drivers/r300/Makefile
@@ -13,6 +13,7 @@ C_SOURCES = \
 	r300_fs.c \
 	r300_query.c \
 	r300_render.c \
+	r300_resource.c \
 	r300_screen.c \
 	r300_screen_buffer.c \
 	r300_state.c \
diff --git a/src/gallium/drivers/r300/r300_context.c b/src/gallium/drivers/r300/r300_context.c
index d994a46ccf..d25846f7a0 100644
--- a/src/gallium/drivers/r300/r300_context.c
+++ b/src/gallium/drivers/r300/r300_context.c
@@ -35,7 +35,6 @@
 #include "r300_screen.h"
 #include "r300_state_invariant.h"
 #include "r300_texture.h"
-#include "r300_transfer.h"
 
 #include "radeon_winsys.h"
 
@@ -48,7 +47,7 @@ static void r300_destroy_context(struct pipe_context* context)
     draw_destroy(r300->draw);
 
     /* Free the OQ BO. */
-    context->screen->buffer_destroy(r300->oqbo);
+    context->screen->resource_destroy(context->screen, r300->oqbo);
 
     /* If there are any queries pending or not destroyed, remove them now. */
     foreach_s(query, temp, &r300->query_list) {
@@ -71,17 +70,11 @@ static void r300_destroy_context(struct pipe_context* context)
     FREE(r300);
 }
 
-static unsigned int
-r300_is_texture_referenced(struct pipe_context *pipe,
-                           struct pipe_texture *texture,
-                           unsigned face, unsigned level)
-{
-    return 0;
-}
 
 static unsigned int
-r300_is_buffer_referenced(struct pipe_context *pipe,
-                          struct pipe_buffer *buf)
+r300_is_resource_referenced(struct pipe_context *pipe,
+			    struct pipe_resource *buf,
+			    unsigned face, unsigned level)
 {
     /* This only checks to see whether actual hardware buffers are
      * referenced. Since we use managed BOs and transfers, it's actually not
@@ -89,11 +82,6 @@ r300_is_buffer_referenced(struct pipe_context *pipe,
      * buffers are never referenced. 
      */
 
-    /* XXX: that doesn't make sense given that
-     * r300_is_texture_referenced is implemented on top of this
-     * function and hardware can certainly refer to textures
-     * directly...
-     */
     return 0;
 }
 
@@ -197,13 +185,12 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
         draw_set_viewport_state(r300->draw, &r300_viewport_identity);
     }
 
-    r300->context.is_texture_referenced = r300_is_texture_referenced;
-    r300->context.is_buffer_referenced = r300_is_buffer_referenced;
+    r300->context.is_resource_referenced = r300_is_resource_referenced;
 
     r300_setup_atoms(r300);
 
     /* Open up the OQ BO. */
-    r300->oqbo = screen->buffer_create(screen, 4096,
+    r300->oqbo = pipe_buffer_create(screen, 4096,
             PIPE_BUFFER_USAGE_VERTEX, 4096);
     make_empty_list(&r300->query_list);
 
@@ -211,8 +198,6 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
 
     r300_init_query_functions(r300);
 
-    r300_init_transfer_functions(r300);
-
     r300_init_state_functions(r300);
 
     r300->invariant_state.dirty = TRUE;
@@ -222,14 +207,14 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
 
     r300->blitter = util_blitter_create(&r300->context);
 
-    r300->upload_ib = u_upload_create(screen,
+    r300->upload_ib = u_upload_create(&r300->context,
 				      32 * 1024, 16,
 				      PIPE_BUFFER_USAGE_INDEX);
 
     if (r300->upload_ib == NULL)
         goto no_upload_ib;
 
-    r300->upload_vb = u_upload_create(screen,
+    r300->upload_vb = u_upload_create(&r300->context,
 				      128 * 1024, 16,
 				      PIPE_BUFFER_USAGE_VERTEX);
     if (r300->upload_vb == NULL)
diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h
index 0c8fb6860e..fe2b78e654 100644
--- a/src/gallium/drivers/r300/r300_context.h
+++ b/src/gallium/drivers/r300/r300_context.h
@@ -29,6 +29,7 @@
 
 #include "pipe/p_context.h"
 #include "util/u_inlines.h"
+#include "util/u_transfer.h"
 
 #include "r300_screen.h"
 
@@ -236,7 +237,7 @@ enum r300_buffer_tiling {
 
 struct r300_texture {
     /* Parent class */
-    struct pipe_texture tex;
+    struct u_resource b;
 
     /* Offsets into the buffer. */
     unsigned offset[R300_MAX_TEXTURE_LEVELS];
@@ -310,12 +311,12 @@ struct r300_context {
     struct blitter_context* blitter;
 
     /* Vertex buffer for rendering. */
-    struct pipe_buffer* vbo;
+    struct pipe_resource* vbo;
     /* Offset into the VBO. */
     size_t vbo_offset;
 
     /* Occlusion query buffer. */
-    struct pipe_buffer* oqbo;
+    struct pipe_resource* oqbo;
     /* Query list. */
     struct r300_query *query_current;
     struct r300_query query_list;
@@ -408,8 +409,7 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
 /* Context initialization. */
 struct draw_stage* r300_draw_stage(struct r300_context* r300);
 void r300_init_state_functions(struct r300_context* r300);
-void r300_init_surface_functions(struct r300_context* r300);
-void r300_init_tex_functions( struct pipe_context *pipe );
+void r300_init_resource_functions(struct r300_context* r300);
 
 static INLINE boolean CTX_DBG_ON(struct r300_context * ctx, unsigned flags)
 {
diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
index 3ad0e561bc..1592c9dd5a 100644
--- a/src/gallium/drivers/r300/r300_emit.c
+++ b/src/gallium/drivers/r300/r300_emit.c
@@ -151,7 +151,7 @@ static const float * get_shader_constant(
     struct r300_textures_state* texstate =
         (struct r300_textures_state*)r300->textures_state.state;
     static float vec[4] = { 0.0, 0.0, 0.0, 1.0 };
-    struct pipe_texture *tex;
+    struct pipe_resource *tex;
 
     switch(constant->Type) {
         case RC_CONSTANT_EXTERNAL:
@@ -999,7 +999,7 @@ void r300_emit_texture_cache_inval(struct r300_context* r300, unsigned size, voi
 
 void r300_emit_buffer_validate(struct r300_context *r300,
                                boolean do_validate_vertex_buffers,
-                               struct pipe_buffer *index_buffer)
+                               struct pipe_resource *index_buffer)
 {
     struct pipe_framebuffer_state* fb =
         (struct pipe_framebuffer_state*)r300->fb_state.state;
@@ -1008,7 +1008,7 @@ void r300_emit_buffer_validate(struct r300_context *r300,
     struct r300_texture* tex;
     struct pipe_vertex_buffer *vbuf = r300->vertex_buffer;
     struct pipe_vertex_element *velem = r300->velems->velem;
-    struct pipe_buffer *pbuf;
+    struct pipe_resource *pbuf;
     unsigned i;
     boolean invalid = FALSE;
 
diff --git a/src/gallium/drivers/r300/r300_emit.h b/src/gallium/drivers/r300/r300_emit.h
index 7db2fc6a1a..27251a60ab 100644
--- a/src/gallium/drivers/r300/r300_emit.h
+++ b/src/gallium/drivers/r300/r300_emit.h
@@ -102,6 +102,6 @@ void r300_emit_dirty_state(struct r300_context* r300);
 
 void r300_emit_buffer_validate(struct r300_context *r300,
                                boolean do_validate_vertex_buffers,
-                               struct pipe_buffer *index_buffer);
+                               struct pipe_resource *index_buffer);
 
 #endif /* R300_EMIT_H */
diff --git a/src/gallium/drivers/r300/r300_query.c b/src/gallium/drivers/r300/r300_query.c
index ca00b043c5..40164b3ce8 100644
--- a/src/gallium/drivers/r300/r300_query.c
+++ b/src/gallium/drivers/r300/r300_query.c
@@ -76,17 +76,17 @@ static void r300_destroy_query(struct pipe_context* pipe,
 static void r300_begin_query(struct pipe_context* pipe,
                              struct pipe_query* query)
 {
-    uint32_t* map;
+    uint32_t value = ~0U;
     struct r300_context* r300 = r300_context(pipe);
     struct r300_query* q = (struct r300_query*)query;
 
     assert(r300->query_current == NULL);
 
-    map = pipe->screen->buffer_map(pipe->screen, r300->oqbo,
-            PIPE_BUFFER_USAGE_CPU_WRITE);
-    map += q->offset / 4;
-    *map = ~0U;
-    pipe->screen->buffer_unmap(pipe->screen, r300->oqbo);
+    pipe_buffer_write(pipe,
+		      r300->oqbo,
+		      q->offset,
+		      sizeof value,
+		      &value);
 
     q->flushed = FALSE;
     r300->query_current = q;
@@ -110,6 +110,7 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
     struct r300_context* r300 = r300_context(pipe);
     struct r300_screen* r300screen = r300_screen(r300->context.screen);
     struct r300_query *q = (struct r300_query*)query;
+    struct pipe_transfer *transfer;
     unsigned flags = PIPE_BUFFER_USAGE_CPU_READ;
     uint32_t* map;
     uint32_t temp = 0;
@@ -118,10 +119,10 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
     if (q->flushed == FALSE)
         pipe->flush(pipe, 0, NULL);
     if (!wait) {
-        flags |= PIPE_BUFFER_USAGE_DONTBLOCK;
+        flags |= PIPE_TRANSFER_DONTBLOCK;
     }
 
-    map = pipe->screen->buffer_map(pipe->screen, r300->oqbo, flags);
+    map = pipe_buffer_map(pipe, r300->oqbo, flags, &transfer);
     if (!map)
         return FALSE;
     map += q->offset / 4;
@@ -144,7 +145,7 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
         temp += *map;
         map++;
     }
-    pipe->screen->buffer_unmap(pipe->screen, r300->oqbo);
+    pipe_buffer_unmap(pipe, r300->oqbo, transfer);
 
     if (temp == ~0U) {
         /* Our results haven't been written yet... */
diff --git a/src/gallium/drivers/r300/r300_render.c b/src/gallium/drivers/r300/r300_render.c
index 47100c83b0..77ec33e0a8 100644
--- a/src/gallium/drivers/r300/r300_render.c
+++ b/src/gallium/drivers/r300/r300_render.c
@@ -155,8 +155,9 @@ static boolean immd_is_good_idea(struct r300_context *r300,
         if (!checked[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
 
-            if (r300_buffer_is_referenced(r300,
-					  vbuf->buffer)) {
+            if (r300->context.is_resource_referenced(&r300->context,
+						     vbuf->buffer,
+						     0, 0)) {
                 /* It's a very bad idea to map it... */
                 return FALSE;
             }
@@ -191,6 +192,7 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
 
     /* Mapped vertex buffers. */
     uint32_t* map[PIPE_MAX_ATTRIBS] = {0};
+    struct pipe_transfer* transfer[PIPE_MAX_ATTRIBS] = {NULL};
 
     CS_LOCALS(r300);
 
@@ -205,9 +207,10 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
         /* Map the buffer. */
         if (!map[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
-            map[vbi] = (uint32_t*)pipe_buffer_map(r300->context.screen,
+            map[vbi] = (uint32_t*)pipe_buffer_map(&r300->context,
                                                   vbuf->buffer,
-                                                  PIPE_BUFFER_USAGE_CPU_READ);
+                                                  PIPE_BUFFER_USAGE_CPU_READ,
+						  &transfer[vbi]);
             map[vbi] += vbuf->buffer_offset / 4;
             stride[vbi] = vbuf->stride / 4;
         }
@@ -250,7 +253,7 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
 
         if (map[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
-            pipe_buffer_unmap(r300->context.screen, vbuf->buffer);
+            pipe_buffer_unmap(&r300->context, vbuf->buffer, transfer[vbi]);
             map[vbi] = NULL;
         }
     }
@@ -287,7 +290,7 @@ static void r300_emit_draw_arrays(struct r300_context *r300,
 }
 
 static void r300_emit_draw_elements(struct r300_context *r300,
-                                    struct pipe_buffer* indexBuffer,
+                                    struct pipe_resource* indexBuffer,
                                     unsigned indexSize,
                                     unsigned minIndex,
                                     unsigned maxIndex,
@@ -353,23 +356,25 @@ static void r300_emit_draw_elements(struct r300_context *r300,
 }
 
 static void r300_shorten_ubyte_elts(struct r300_context* r300,
-                                    struct pipe_buffer** elts,
+                                    struct pipe_resource** elts,
                                     unsigned count)
 {
+    struct pipe_context* context = &r300->context;
     struct pipe_screen* screen = r300->context.screen;
-    struct pipe_buffer* new_elts;
+    struct pipe_resource* new_elts;
     unsigned char *in_map;
     unsigned short *out_map;
+    struct pipe_transfer *src_transfer, *dst_transfer;
     unsigned i;
 
-    new_elts = screen->buffer_create(screen, 32,
-                                     PIPE_BUFFER_USAGE_INDEX |
-                                     PIPE_BUFFER_USAGE_CPU_WRITE |
-                                     PIPE_BUFFER_USAGE_GPU_READ,
-                                     2 * count);
+    new_elts = pipe_buffer_create(screen, 32,
+				  PIPE_BUFFER_USAGE_INDEX |
+				  PIPE_BUFFER_USAGE_CPU_WRITE |
+				  PIPE_BUFFER_USAGE_GPU_READ,
+				  2 * count);
 
-    in_map = pipe_buffer_map(screen, *elts, PIPE_BUFFER_USAGE_CPU_READ);
-    out_map = pipe_buffer_map(screen, new_elts, PIPE_BUFFER_USAGE_CPU_WRITE);
+    in_map = pipe_buffer_map(context, *elts, PIPE_BUFFER_USAGE_CPU_READ, &src_transfer);
+    out_map = pipe_buffer_map(context, new_elts, PIPE_BUFFER_USAGE_CPU_WRITE, &dst_transfer);
 
     for (i = 0; i < count; i++) {
         *out_map = (unsigned short)*in_map;
@@ -377,15 +382,15 @@ static void r300_shorten_ubyte_elts(struct r300_context* r300,
         out_map++;
     }
 
-    pipe_buffer_unmap(screen, *elts);
-    pipe_buffer_unmap(screen, new_elts);
+    pipe_buffer_unmap(context, *elts, src_transfer);
+    pipe_buffer_unmap(context, new_elts, dst_transfer);
 
     *elts = new_elts;
 }
 
 /* This is the fast-path drawing & emission for HW TCL. */
 void r300_draw_range_elements(struct pipe_context* pipe,
-                              struct pipe_buffer* indexBuffer,
+                              struct pipe_resource* indexBuffer,
                               unsigned indexSize,
                               unsigned minIndex,
                               unsigned maxIndex,
@@ -394,7 +399,7 @@ void r300_draw_range_elements(struct pipe_context* pipe,
                               unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct pipe_buffer* orgIndexBuffer = indexBuffer;
+    struct pipe_resource* orgIndexBuffer = indexBuffer;
 #if defined(ENABLE_ALT_NUM_VERTS)
     boolean alt_num_verts = r300_screen(pipe->screen)->caps->is_r500 &&
                             count > 65536;
@@ -446,13 +451,13 @@ void r300_draw_range_elements(struct pipe_context* pipe,
     }
 
     if (indexBuffer != orgIndexBuffer) {
-        pipe_buffer_reference( &indexBuffer, NULL );
+        pipe_resource_reference( &indexBuffer, NULL );
     }
 }
 
 /* Simple helpers for context setup. Should probably be moved to util. */
 void r300_draw_elements(struct pipe_context* pipe,
-                        struct pipe_buffer* indexBuffer,
+                        struct pipe_resource* indexBuffer,
                         unsigned indexSize, unsigned mode,
                         unsigned start, unsigned count)
 {
@@ -526,6 +531,7 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
                                unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
+    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
     int i;
 
     if (!u_trim_pipe_prim(mode, &count)) {
@@ -533,9 +539,10 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
     }
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        void* buf = pipe_buffer_map(pipe->screen,
+        void* buf = pipe_buffer_map(pipe,
                                     r300->vertex_buffer[i].buffer,
-                                    PIPE_BUFFER_USAGE_CPU_READ);
+                                    PIPE_BUFFER_USAGE_CPU_READ,
+				    &vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, buf);
     }
 
@@ -551,14 +558,15 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
     draw_arrays(r300->draw, mode, start, count);
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        pipe_buffer_unmap(pipe->screen, r300->vertex_buffer[i].buffer);
+        pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
+			  vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
     }
 }
 
 /* SW TCL elements, using Draw. */
 void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
-                                       struct pipe_buffer* indexBuffer,
+                                       struct pipe_resource* indexBuffer,
                                        unsigned indexSize,
                                        unsigned minIndex,
                                        unsigned maxIndex,
@@ -567,6 +575,8 @@ void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
                                        unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
+    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
+    struct pipe_transfer *ib_transfer;
     int i;
     void* indices;
 
@@ -575,14 +585,15 @@ void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
     }
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        void* buf = pipe_buffer_map(pipe->screen,
+        void* buf = pipe_buffer_map(pipe,
                                     r300->vertex_buffer[i].buffer,
-                                    PIPE_BUFFER_USAGE_CPU_READ);
+                                    PIPE_TRANSFER_READ,
+				    &vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, buf);
     }
 
-    indices = pipe_buffer_map(pipe->screen, indexBuffer,
-                              PIPE_BUFFER_USAGE_CPU_READ);
+    indices = pipe_buffer_map(pipe, indexBuffer,
+                              PIPE_TRANSFER_READ, &ib_transfer);
     draw_set_mapped_element_buffer_range(r300->draw, indexSize,
                                          minIndex, maxIndex, indices);
 
@@ -596,11 +607,13 @@ void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
     draw_arrays(r300->draw, mode, start, count);
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        pipe_buffer_unmap(pipe->screen, r300->vertex_buffer[i].buffer);
+        pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
+			  vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
     }
 
-    pipe_buffer_unmap(pipe->screen, indexBuffer);
+    pipe_buffer_unmap(pipe, indexBuffer,
+		      ib_transfer);
     draw_set_mapped_element_buffer_range(r300->draw, 0, start,
                                          start + count - 1, NULL);
 }
@@ -619,11 +632,13 @@ struct r300_render {
     unsigned hwprim;
 
     /* VBO */
-    struct pipe_buffer* vbo;
+    struct pipe_resource* vbo;
     size_t vbo_size;
     size_t vbo_offset;
     size_t vbo_max_used;
     void * vbo_ptr;
+
+   struct pipe_transfer *vbo_transfer;
 };
 
 static INLINE struct r300_render*
@@ -654,7 +669,7 @@ static boolean r300_render_allocate_vertices(struct vbuf_render* render,
 
     if (size + r300render->vbo_offset > r300render->vbo_size)
     {
-        pipe_buffer_reference(&r300->vbo, NULL);
+        pipe_resource_reference(&r300->vbo, NULL);
         r300render->vbo = pipe_buffer_create(screen,
                                              64,
                                              PIPE_BUFFER_USAGE_VERTEX,
@@ -673,10 +688,11 @@ static boolean r300_render_allocate_vertices(struct vbuf_render* render,
 static void* r300_render_map_vertices(struct vbuf_render* render)
 {
     struct r300_render* r300render = r300_render(render);
-    struct pipe_screen* screen = r300render->r300->context.screen;
 
-    r300render->vbo_ptr = pipe_buffer_map(screen, r300render->vbo,
-                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+    r300render->vbo_ptr = pipe_buffer_map(&r300render->r300->context,
+					  r300render->vbo,
+                                          PIPE_BUFFER_USAGE_CPU_WRITE,
+					  &r300render->vbo_transfer);
 
     return ((uint8_t*)r300render->vbo_ptr + r300render->vbo_offset);
 }
@@ -686,7 +702,7 @@ static void r300_render_unmap_vertices(struct vbuf_render* render,
                                              ushort max)
 {
     struct r300_render* r300render = r300_render(render);
-    struct pipe_screen* screen = r300render->r300->context.screen;
+    struct pipe_context* context = &r300render->r300->context;
     CS_LOCALS(r300render->r300);
     BEGIN_CS(2);
     OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, max);
@@ -694,7 +710,7 @@ static void r300_render_unmap_vertices(struct vbuf_render* render,
 
     r300render->vbo_max_used = MAX2(r300render->vbo_max_used,
                                     r300render->vertex_size * (max + 1));
-    pipe_buffer_unmap(screen, r300render->vbo);
+    pipe_buffer_unmap(context, r300render->vbo, r300render->vbo_transfer);
 }
 
 static void r300_render_release_vertices(struct vbuf_render* render)
diff --git a/src/gallium/drivers/r300/r300_render.h b/src/gallium/drivers/r300/r300_render.h
index 27b5e6a963..f8fb6ec02f 100644
--- a/src/gallium/drivers/r300/r300_render.h
+++ b/src/gallium/drivers/r300/r300_render.h
@@ -26,7 +26,7 @@
 uint32_t r300_translate_primitive(unsigned prim);
 
 void r300_draw_range_elements(struct pipe_context* pipe,
-                              struct pipe_buffer* indexBuffer,
+                              struct pipe_resource* indexBuffer,
                               unsigned indexSize,
                               unsigned minIndex,
                               unsigned maxIndex,
@@ -35,7 +35,7 @@ void r300_draw_range_elements(struct pipe_context* pipe,
                               unsigned count);
 
 void r300_draw_elements(struct pipe_context* pipe,
-                        struct pipe_buffer* indexBuffer,
+                        struct pipe_resource* indexBuffer,
                         unsigned indexSize, unsigned mode,
                         unsigned start, unsigned count);
 
@@ -48,7 +48,7 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
                             unsigned count);
 
 void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
-                                    struct pipe_buffer* indexBuffer,
+                                    struct pipe_resource* indexBuffer,
                                     unsigned indexSize,
                                     unsigned minIndex,
                                     unsigned maxIndex,
diff --git a/src/gallium/drivers/r300/r300_resource.c b/src/gallium/drivers/r300/r300_resource.c
new file mode 100644
index 0000000000..a63a79efe2
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_resource.c
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Dave Airlie
+ */
+#include <stdio.h>
+
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_memory.h"
+#include "util/u_upload_mgr.h"
+#include "util/u_math.h"
+
+#include "r300_context.h"
+#include "r300_texture.h"
+#include "r300_transfer.h"
+#include "r300_screen.h"
+#include "r300_state_inlines.h"
+#include "r300_screen_buffer.h"
+
+#include "r300_winsys.h"
+
+
+
+
+
+
+
+
+
+static struct pipe_resource *
+r300_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   if (template->target == PIPE_BUFFER)
+      return r300_buffer_create(screen, template);
+   else
+      return r300_resource_create(screen, template);
+
+}
+
+static struct pipe_resource *
+r300_resource_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   if (template->target == PIPE_BUFFER)
+      return NULL;
+   else
+      return r300_texture_from_handle(screen, template, whandle);
+}
+
+
+
+void
+r300_init_resource_functions(struct r300_context *r300)
+{
+   r300->context.get_transfer = u_get_transfer_vtbl;
+   r300->context.transfer_map = u_transfer_map_vtbl;
+   r300->context.transfer_flush_region = u_transfer_flush_region_vtbl;
+   r300->context.transfer_unmap = u_transfer_unmap_vtbl;
+   r300->context.transfer_destroy = u_transfer_destroy_vtbl;
+   r300->context.transfer_inline_write = u_transfer_inline_write_vtbl;
+}
+
+void
+r300_init_screen_resource_functions(struct r300_screen *r300screen)
+{
+   r300screen->screen.resource_create = r300_resource_create;
+   r300screen->screen.resource_from_handle = r300_resource_from_handle;
+   r300screen->screen.resource_get_handle = u_resource_get_handle_vtbl;
+   r300screen->screen.resource_destroy = u_resource_destroy_vtbl;
+   r300screen->screen.user_buffer_create = r300_user_buffer_create;
+   
+   r300screen->screen.get_tex_surface = r300_get_tex_surface;
+   r300screen->screen.tex_surface_destroy = r300_tex_surface_destroy;
+
+   r300screen->screen.video_surface_create = r300_video_surface_create;
+   r300screen->screen.video_surface_destroy = r300_video_surface_destroy;
+   
+}
diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c
index 3e31688f8e..ec7c65f468 100644
--- a/src/gallium/drivers/r300/r300_screen.c
+++ b/src/gallium/drivers/r300/r300_screen.c
@@ -292,9 +292,8 @@ struct pipe_screen* r300_create_screen(struct r300_winsys_screen *rws)
     r300screen->screen.is_format_supported = r300_is_format_supported;
     r300screen->screen.context_create = r300_create_context;
 
-    r300_init_screen_texture_functions(&r300screen->screen);
+    r300_init_screen_resource_functions(r300screen);
 
-    r300_screen_init_buffer_functions(r300screen);
     return &r300screen->screen;
 }
 
diff --git a/src/gallium/drivers/r300/r300_screen.h b/src/gallium/drivers/r300/r300_screen.h
index 1ccc0bfb7a..9972a7da07 100644
--- a/src/gallium/drivers/r300/r300_screen.h
+++ b/src/gallium/drivers/r300/r300_screen.h
@@ -91,5 +91,7 @@ static INLINE void SCREEN_DBG(struct r300_screen * screen, unsigned flags,
 
 void r300_init_debug(struct r300_screen* ctx);
 
+void r300_init_screen_resource_functions(struct r300_screen *r300screen);
+
 #endif /* R300_SCREEN_H */
 
diff --git a/src/gallium/drivers/r300/r300_screen_buffer.c b/src/gallium/drivers/r300/r300_screen_buffer.c
index b97d0d76a4..b6af4a3301 100644
--- a/src/gallium/drivers/r300/r300_screen_buffer.c
+++ b/src/gallium/drivers/r300/r300_screen_buffer.c
@@ -34,23 +34,31 @@
 
 #include "r300_winsys.h"
 
-boolean r300_buffer_is_referenced(struct r300_context *r300,
-				  struct pipe_buffer *buf)
+static unsigned r300_buffer_is_referenced(struct pipe_context *context,
+					 struct pipe_resource *buf,
+					 unsigned face, unsigned level)
 {
+    struct r300_context *r300 = r300_context(context);
     struct r300_buffer *rbuf = r300_buffer(buf);
+
     if (r300_buffer_is_user_buffer(buf))
-	return FALSE;
+ 	return PIPE_UNREFERENCED;
+
+    if (r300->rws->is_resource_referenced(r300->rws, rbuf->buf))
+        return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
 
-    return r300->rws->is_buffer_referenced(r300->rws, rbuf->buf);
-    
+    return PIPE_UNREFERENCED;
 }
+
+/* External helper, not required to implent u_resource_vtbl:
+ */
 int r300_upload_index_buffer(struct r300_context *r300,
-			     struct pipe_buffer **index_buffer,
+			     struct pipe_resource **index_buffer,
 			     unsigned index_size,
 			     unsigned start,
 			     unsigned count)
 {
-   struct pipe_buffer *upload_buffer = NULL;
+   struct pipe_resource *upload_buffer = NULL;
    unsigned index_offset = start * index_size;
    int ret = 0;
 
@@ -68,10 +76,12 @@ int r300_upload_index_buffer(struct r300_context *r300,
     }
  done:
     //    if (upload_buffer)
-    //	pipe_buffer_reference(&upload_buffer, NULL);
+    //	pipe_resource_reference(&upload_buffer, NULL);
     return ret;
 }
 
+/* External helper, not required to implent u_resource_vtbl:
+ */
 int r300_upload_user_buffers(struct r300_context *r300)
 {
     enum pipe_error ret = PIPE_OK;
@@ -82,9 +92,9 @@ int r300_upload_user_buffers(struct r300_context *r300)
     for (i = 0; i < nr; i++) {
 
 	if (r300_buffer_is_user_buffer(r300->vertex_buffer[i].buffer)) {
-	    struct pipe_buffer *upload_buffer = NULL;
+	    struct pipe_resource *upload_buffer = NULL;
 	    unsigned offset = 0; /*r300->vertex_buffer[i].buffer_offset * 4;*/
-	    unsigned size = r300->vertex_buffer[i].buffer->size;
+	    unsigned size = r300->vertex_buffer[i].buffer->width0;
 	    unsigned upload_offset;
 	    ret = u_upload_buffer(r300->upload_vb,
 				  offset, size,
@@ -93,7 +103,7 @@ int r300_upload_user_buffers(struct r300_context *r300)
 	    if (ret)
 		return ret;
 
-	    pipe_buffer_reference(&r300->vertex_buffer[i].buffer, NULL);
+	    pipe_resource_reference(&r300->vertex_buffer[i].buffer, NULL);
 	    r300->vertex_buffer[i].buffer = upload_buffer;
 	    r300->vertex_buffer[i].buffer_offset = upload_offset;
 	}
@@ -125,70 +135,11 @@ static void r300_winsys_buffer_destroy(struct r300_screen *r300screen,
     }
 }
 
-static struct pipe_buffer *r300_buffer_create(struct pipe_screen *screen,
-					      unsigned alignment,
-					      unsigned usage,
-					      unsigned size)
-{
-    struct r300_screen *r300screen = r300_screen(screen);
-    struct r300_buffer *rbuf;
-
-    rbuf = CALLOC_STRUCT(r300_buffer);
-    if (!rbuf)
-	goto error1;
-
-    rbuf->magic = R300_BUFFER_MAGIC;
-
-    pipe_reference_init(&rbuf->base.reference, 1);
-    rbuf->base.screen = screen;
-    rbuf->base.alignment = alignment;
-    rbuf->base.usage = usage;
-    rbuf->base.size = size;
 
-    rbuf->buf = r300_winsys_buffer_create(r300screen,
-					  alignment,
-					  usage,
-					  size);
-
-    if (!rbuf->buf)
-	goto error2;
-
-    return &rbuf->base;
-error2:
-    FREE(rbuf);
-error1:
-    return NULL;
-}
-
-
-static struct pipe_buffer *r300_user_buffer_create(struct pipe_screen *screen,
-						   void *ptr,
-						   unsigned bytes)
+static void r300_buffer_destroy(struct pipe_screen *screen,
+				struct pipe_resource *buf)
 {
-    struct r300_buffer *rbuf;
-
-    rbuf = CALLOC_STRUCT(r300_buffer);
-    if (!rbuf)
-	goto no_rbuf;
-
-    rbuf->magic = R300_BUFFER_MAGIC;
-
-    pipe_reference_init(&rbuf->base.reference, 1);
-    rbuf->base.screen = screen;
-    rbuf->base.alignment = 1;
-    rbuf->base.usage = 0;
-    rbuf->base.size = bytes;
-
-    rbuf->user_buffer = ptr;
-    return &rbuf->base;
-
-no_rbuf:
-    return NULL;
-}
-
-static void r300_buffer_destroy(struct pipe_buffer *buf)
-{
-    struct r300_screen *r300screen = r300_screen(buf->screen);
+    struct r300_screen *r300screen = r300_screen(screen);
     struct r300_buffer *rbuf = r300_buffer(buf);
 
     r300_winsys_buffer_destroy(r300screen, rbuf);
@@ -197,7 +148,7 @@ static void r300_buffer_destroy(struct pipe_buffer *buf)
 
 static void *
 r300_buffer_map_range(struct pipe_screen *screen,
-		      struct pipe_buffer *buf,
+		      struct pipe_resource *buf,
 		      unsigned offset, unsigned length,
 		      unsigned usage )
 {
@@ -211,11 +162,13 @@ r300_buffer_map_range(struct pipe_screen *screen,
     if (rbuf->user_buffer)
 	return rbuf->user_buffer;
 
-    if (rbuf->base.usage & PIPE_BUFFER_USAGE_CONSTANT)
+    if (rbuf->b.b.usage & PIPE_BUFFER_USAGE_CONSTANT) {
+        usage |= R300_USAGE_FLAG_DONT_SYNC;
 	goto just_map;
+    }
 
     /* check if the mapping is to a range we already flushed */
-    if (usage & PIPE_BUFFER_USAGE_DISCARD) {
+    if (usage & PIPE_TRANSFER_DISCARD) {
 	for (i = 0; i < rbuf->num_ranges; i++) {
 
 	    if ((offset >= rbuf->ranges[i].start) &&
@@ -229,22 +182,36 @@ r300_buffer_map_range(struct pipe_screen *screen,
 		rbuf->num_ranges = 0;
 		rbuf->map = NULL;
 		rbuf->buf = r300_winsys_buffer_create(r300screen,
-						      rbuf->base.alignment,
-						      rbuf->base.usage,
-						      rbuf->base.size);
+						      16,
+						      rbuf->b.b.usage,
+						      rbuf->b.b.width0);
 		break;
 	    }
 	}
     }
+
+    /* XXX: Some sort of discrepancy here - ordinary map() didn't add
+     * this flag, but map_buffer_range always did.
+     *
+     * But
+     *     map_buffer_range(0,size,flags)
+     * should be the same operation as old-style
+     *     map(flags).
+     *
+     * Try to replicate the old behaviour for now...
+     */
+    if (offset != 0 || length != rbuf->b.b.width0)
+        usage |= R300_USAGE_FLAG_DONT_SYNC;
+
 just_map:
-    map = rws->buffer_map(rws, rbuf->buf, usage | R300_USAGE_FLAG_DONT_SYNC);
+    map = rws->buffer_map(rws, rbuf->buf, usage);
    
     return map;
 }
 
 static void 
 r300_buffer_flush_mapped_range( struct pipe_screen *screen,
-				struct pipe_buffer *buf,
+				struct pipe_resource *buf,
 				unsigned offset,
 				unsigned length )
 {
@@ -254,7 +221,7 @@ r300_buffer_flush_mapped_range( struct pipe_screen *screen,
     if (rbuf->user_buffer)
 	return;
 
-    if (rbuf->base.usage & PIPE_BUFFER_USAGE_CONSTANT)
+    if (rbuf->b.b.usage & PIPE_BUFFER_USAGE_CONSTANT)
 	return;
 
     /* mark the range as used */
@@ -271,44 +238,147 @@ r300_buffer_flush_mapped_range( struct pipe_screen *screen,
     rbuf->num_ranges++;
 }
 
-static void *
-r300_buffer_map(struct pipe_screen *screen,
-		struct pipe_buffer *buf,
-		unsigned usage)
+
+static void
+r300_buffer_unmap(struct pipe_screen *screen,
+		  struct pipe_resource *buf)
 {
     struct r300_screen *r300screen = r300_screen(screen);
     struct r300_winsys_screen *rws = r300screen->rws;
     struct r300_buffer *rbuf = r300_buffer(buf);
-    void *map;
 
-   if (rbuf->user_buffer)
-      return rbuf->user_buffer;
+    if (rbuf->buf) {
+        rws->buffer_unmap(rws, rbuf->buf);
+    }
+}
 
-    map = rws->buffer_map(rws, rbuf->buf, usage);
 
-    return map;
+
+
+/* As a first step, keep the original code intact, implement buffer
+ * transfers in terms of the old map/unmap functions.
+ *
+ * Utility functions for transfer create/destroy are hooked in and
+ * just record the arguments to those functions.
+ */
+static void *
+r300_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+   uint8_t *map = r300_buffer_map_range( pipe->screen,
+					 transfer->resource,
+					 transfer->box.x,
+					 transfer->box.width,
+					 transfer->usage );
+   if (map == NULL)
+      return NULL;
+
+   /* map_buffer() returned a pointer to the beginning of the buffer,
+    * but transfers are expected to return a pointer to just the
+    * region specified in the box.
+    */
+   return map + transfer->box.x;
 }
 
-static void
-r300_buffer_unmap(struct pipe_screen *screen,
-		  struct pipe_buffer *buf)
+
+
+static void r300_buffer_transfer_flush_region( struct pipe_context *pipe,
+					       struct pipe_transfer *transfer,
+					       const struct pipe_box *box)
+{
+   assert(box->x + box->width <= transfer->box.width);
+
+   r300_buffer_flush_mapped_range(pipe->screen,
+				  transfer->resource,
+				  transfer->box.x + box->x,
+				  box->width);
+}
+
+static void r300_buffer_transfer_unmap( struct pipe_context *pipe,
+			    struct pipe_transfer *transfer )
+{
+   r300_buffer_unmap(pipe->screen,
+		     transfer->resource);
+}
+
+
+
+
+struct u_resource_vtbl r300_buffer_vtbl = 
+{
+   u_default_resource_get_handle,      /* get_handle */
+   r300_buffer_destroy,		     /* resource_destroy */
+   r300_buffer_is_referenced,	     /* is_resource_referenced */
+   u_default_get_transfer,	     /* get_transfer */
+   u_default_transfer_destroy,	     /* transfer_destroy */
+   r300_buffer_transfer_map,	     /* transfer_map */
+   r300_buffer_transfer_flush_region,  /* transfer_flush_region */
+   r300_buffer_transfer_unmap,	     /* transfer_unmap */
+   u_default_transfer_inline_write   /* transfer_inline_write */
+};
+
+
+
+
+struct pipe_resource *r300_buffer_create(struct pipe_screen *screen,
+					 const struct pipe_resource *template)
 {
     struct r300_screen *r300screen = r300_screen(screen);
-    struct r300_winsys_screen *rws = r300screen->rws;
-    struct r300_buffer *rbuf = r300_buffer(buf);
+    struct r300_buffer *rbuf;
 
-    if (rbuf->buf) {
-        rws->buffer_unmap(rws, rbuf->buf);
-    }
+    rbuf = CALLOC_STRUCT(r300_buffer);
+    if (!rbuf)
+	goto error1;
+
+    rbuf->magic = R300_BUFFER_MAGIC;
+
+    rbuf->b.b = *template;
+    rbuf->b.vtbl = &r300_buffer_vtbl;
+    pipe_reference_init(&rbuf->b.b.reference, 1);
+    rbuf->b.b.screen = screen;
+
+    rbuf->buf = r300_winsys_buffer_create(r300screen,
+					  16,
+					  rbuf->b.b.usage,
+					  rbuf->b.b.width0);
+
+    if (!rbuf->buf)
+	goto error2;
+
+    return &rbuf->b.b;
+error2:
+    FREE(rbuf);
+error1:
+    return NULL;
 }
 
-void r300_screen_init_buffer_functions(struct r300_screen *r300screen)
+
+struct pipe_resource *r300_user_buffer_create(struct pipe_screen *screen,
+					      void *ptr,
+					      unsigned bytes,
+					      unsigned usage)
 {
-    r300screen->screen.buffer_create = r300_buffer_create;
-    r300screen->screen.user_buffer_create = r300_user_buffer_create;
-    r300screen->screen.buffer_map = r300_buffer_map;
-    r300screen->screen.buffer_map_range = r300_buffer_map_range;
-    r300screen->screen.buffer_flush_mapped_range = r300_buffer_flush_mapped_range;
-    r300screen->screen.buffer_unmap = r300_buffer_unmap;
-    r300screen->screen.buffer_destroy = r300_buffer_destroy;
+    struct r300_buffer *rbuf;
+
+    rbuf = CALLOC_STRUCT(r300_buffer);
+    if (!rbuf)
+	goto no_rbuf;
+
+    rbuf->magic = R300_BUFFER_MAGIC;
+
+    pipe_reference_init(&rbuf->b.b.reference, 1);
+    rbuf->b.vtbl = &r300_buffer_vtbl;
+    rbuf->b.b.screen = screen;
+    rbuf->b.b.format = PIPE_FORMAT_R8_UNORM;
+    rbuf->b.b.usage = usage;
+    rbuf->b.b.width0 = bytes;
+    rbuf->b.b.height0 = 1;
+    rbuf->b.b.depth0 = 1;
+
+    rbuf->user_buffer = ptr;
+    return &rbuf->b.b;
+
+no_rbuf:
+    return NULL;
 }
+
diff --git a/src/gallium/drivers/r300/r300_screen_buffer.h b/src/gallium/drivers/r300/r300_screen_buffer.h
index 0cf349c25c..93009ea02f 100644
--- a/src/gallium/drivers/r300/r300_screen_buffer.h
+++ b/src/gallium/drivers/r300/r300_screen_buffer.h
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include "pipe/p_compiler.h"
 #include "pipe/p_state.h"
+#include "util/u_transfer.h"
 #include "r300_screen.h"
 
 #include "r300_winsys.h"
@@ -18,7 +19,7 @@ struct r300_buffer_range {
 
 struct r300_buffer
 {
-    struct pipe_buffer base;
+    struct u_resource b;
 
     uint32_t magic;
 
@@ -32,7 +33,7 @@ struct r300_buffer
 };
 
 static INLINE struct r300_buffer *
-r300_buffer(struct pipe_buffer *buffer)
+r300_buffer(struct pipe_resource *buffer)
 {
     if (buffer) {
 	assert(((struct r300_buffer *)buffer)->magic == R300_BUFFER_MAGIC);
@@ -42,13 +43,13 @@ r300_buffer(struct pipe_buffer *buffer)
 }
 
 static INLINE boolean 
-r300_buffer_is_user_buffer(struct pipe_buffer *buffer)
+r300_buffer_is_user_buffer(struct pipe_resource *buffer)
 {
     return r300_buffer(buffer)->user_buffer ? true : false;
 }
 
 static INLINE boolean r300_add_buffer(struct r300_winsys_screen *rws,
-				      struct pipe_buffer *buffer,
+				      struct pipe_resource *buffer,
 				      int rd, int wr)
 {
     struct r300_buffer *buf = r300_buffer(buffer);
@@ -67,7 +68,6 @@ static INLINE boolean r300_add_texture(struct r300_winsys_screen *rws,
     return rws->add_buffer(rws, tex->buffer, rd, wr);
 }
 
-void r300_screen_init_buffer_functions(struct r300_screen *r300screen);
 
 static INLINE void r300_buffer_write_reloc(struct r300_winsys_screen *rws,
 				      struct r300_buffer *buf,
@@ -89,11 +89,18 @@ static INLINE void r300_texture_write_reloc(struct r300_winsys_screen *rws,
 int r300_upload_user_buffers(struct r300_context *r300);
 
 int r300_upload_index_buffer(struct r300_context *r300,
-			     struct pipe_buffer **index_buffer,
+			     struct pipe_resource **index_buffer,
 			     unsigned index_size,
 			     unsigned start,
 			     unsigned count);
 
-boolean r300_buffer_is_referenced(struct r300_context *r300,
-				  struct pipe_buffer *buf);
+
+struct pipe_resource *r300_buffer_create(struct pipe_screen *screen,
+					 const struct pipe_resource *template);
+
+struct pipe_resource *r300_user_buffer_create(struct pipe_screen *screen,
+					      void *ptr,
+					      unsigned bytes,
+					      unsigned usage);
+
 #endif
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index d7d654dc31..e5349abb61 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -986,7 +986,7 @@ static void r300_set_fragment_sampler_views(struct pipe_context* pipe,
 
 static struct pipe_sampler_view *
 r300_create_sampler_view(struct pipe_context *pipe,
-                         struct pipe_texture *texture,
+                         struct pipe_resource *texture,
                          const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -995,7 +995,7 @@ r300_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -1007,7 +1007,7 @@ static void
 r300_sampler_view_destroy(struct pipe_context *pipe,
                           struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
@@ -1081,14 +1081,14 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
         return;
 
     for (i = 0; i < count; i++) {
-	pipe_buffer_reference(&r300->vertex_buffer[i].buffer, buffers[i].buffer);
+	pipe_resource_reference(&r300->vertex_buffer[i].buffer, buffers[i].buffer);
 	if (r300_buffer_is_user_buffer(buffers[i].buffer))
 	    any_user_buffer = true;
         max_index = MIN2(buffers[i].max_index, max_index);
     }
 
     for ( ; i < r300->vertex_buffer_count; i++)
-	pipe_buffer_reference(&r300->vertex_buffer[i].buffer, NULL);
+	pipe_resource_reference(&r300->vertex_buffer[i].buffer, NULL);
 
     memcpy(r300->vertex_buffer, buffers,
 	   sizeof(struct pipe_vertex_buffer) * count);
@@ -1413,21 +1413,22 @@ static void r300_delete_vs_state(struct pipe_context* pipe, void* shader)
 
 static void r300_set_constant_buffer(struct pipe_context *pipe,
                                      uint shader, uint index,
-                                     struct pipe_buffer *buf)
+                                     struct pipe_resource *buf)
 {
     struct r300_context* r300 = r300_context(pipe);
     struct r300_screen *r300screen = r300_screen(pipe->screen);
+    struct pipe_transfer *tr;
     void *mapped;
     int max_size = 0;
 
-    if (buf == NULL || buf->size == 0 ||
-        (mapped = pipe_buffer_map(pipe->screen, buf, PIPE_BUFFER_USAGE_CPU_READ)) == NULL)
+    if (buf == NULL || buf->width0 == 0 ||
+        (mapped = pipe_buffer_map(pipe, buf, PIPE_BUFFER_USAGE_CPU_READ, &tr)) == NULL)
     {
         r300->shader_constants[shader].count = 0;
         return;
     }
 
-    assert((buf->size % 4 * sizeof(float)) == 0);
+    assert((buf->width0 % 4 * sizeof(float)) == 0);
 
     /* Check the size of the constant buffer. */
     switch (shader) {
@@ -1449,15 +1450,15 @@ static void r300_set_constant_buffer(struct pipe_context *pipe,
     }
 
     /* XXX Subtract immediates and RC_STATE_* variables. */
-    if (buf->size > (sizeof(float) * 4 * max_size)) {
+    if (buf->width0 > (sizeof(float) * 4 * max_size)) {
         debug_printf("r300: Max size of the constant buffer is "
                       "%i*4 floats.\n", max_size);
         abort();
     }
 
-    memcpy(r300->shader_constants[shader].constants, mapped, buf->size);
-    r300->shader_constants[shader].count = buf->size / (4 * sizeof(float));
-    pipe_buffer_unmap(pipe->screen, buf);
+    memcpy(r300->shader_constants[shader].constants, mapped, buf->width0);
+    r300->shader_constants[shader].count = buf->width0 / (4 * sizeof(float));
+    pipe_buffer_unmap(pipe, buf, tr);
 
     if (shader == PIPE_SHADER_VERTEX) {
         if (r300screen->caps->has_tcl) {
diff --git a/src/gallium/drivers/r300/r300_state_derived.c b/src/gallium/drivers/r300/r300_state_derived.c
index 7947ec6641..fc212d2083 100644
--- a/src/gallium/drivers/r300/r300_state_derived.c
+++ b/src/gallium/drivers/r300/r300_state_derived.c
@@ -355,7 +355,7 @@ static void r300_merge_textures_and_samplers(struct r300_context* r300)
                                     R300_TXO_MICRO_TILE(tex->microtile);
 
             /* to emulate 1D textures through 2D ones correctly */
-            if (tex->tex.target == PIPE_TEXTURE_1D) {
+            if (tex->b.b.target == PIPE_TEXTURE_1D) {
                 texstate->filter[0] &= ~R300_TX_WRAP_T_MASK;
                 texstate->filter[0] |= R300_TX_WRAP_T(R300_TX_CLAMP_TO_EDGE);
             }
@@ -367,7 +367,7 @@ static void r300_merge_textures_and_samplers(struct r300_context* r300)
             } else {
                 /* determine min/max levels */
                 /* the MAX_MIP level is the largest (finest) one */
-                max_level = MIN2(sampler->max_lod, tex->tex.last_level);
+                max_level = MIN2(sampler->max_lod, tex->b.b.last_level);
                 min_level = MIN2(sampler->min_lod, max_level);
                 texstate->format[0] |= R300_TX_NUM_LEVELS(max_level);
                 texstate->filter[0] |= R300_TX_MAX_MIP_LEVEL(min_level);
diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index 7c7656068b..21c51f9cb8 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -29,6 +29,7 @@
 
 #include "r300_context.h"
 #include "r300_texture.h"
+#include "r300_transfer.h"
 #include "r300_screen.h"
 #include "r300_state_inlines.h"
 
@@ -500,7 +501,7 @@ boolean r300_is_sampler_format_supported(enum pipe_format format)
 static void r300_setup_texture_state(struct r300_screen* screen, struct r300_texture* tex)
 {
     struct r300_texture_format_state* state = &tex->state;
-    struct pipe_texture *pt = &tex->tex;
+    struct pipe_resource *pt = &tex->b.b;
     unsigned i;
     boolean is_r500 = screen->caps->is_r500;
 
@@ -540,28 +541,28 @@ static void r300_setup_texture_state(struct r300_screen* screen, struct r300_tex
                pt->width0, pt->height0, pt->last_level);
 
     /* Set framebuffer state. */
-    if (util_format_is_depth_or_stencil(tex->tex.format)) {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+    if (util_format_is_depth_or_stencil(tex->b.b.format)) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.depthpitch[i] =
                 tex->pitch[i] |
                 R300_DEPTHMACROTILE(tex->mip_macrotile[i]) |
                 R300_DEPTHMICROTILE(tex->microtile);
         }
-        tex->fb_state.zb_format = r300_translate_zsformat(tex->tex.format);
+        tex->fb_state.zb_format = r300_translate_zsformat(tex->b.b.format);
     } else {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.colorpitch[i] =
                 tex->pitch[i] |
-                r300_translate_colorformat(tex->tex.format) |
+                r300_translate_colorformat(tex->b.b.format) |
                 R300_COLOR_TILE(tex->mip_macrotile[i]) |
                 R300_COLOR_MICROTILE(tex->microtile);
         }
-        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->tex.format);
+        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->b.b.format);
     }
 }
 
 void r300_texture_reinterpret_format(struct pipe_screen *screen,
-                                     struct pipe_texture *tex,
+                                     struct pipe_resource *tex,
                                      enum pipe_format new_format)
 {
     struct r300_screen *r300screen = r300_screen(screen);
@@ -579,7 +580,7 @@ unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
 {
     unsigned offset = tex->offset[level];
 
-    switch (tex->tex.target) {
+    switch (tex->b.b.target) {
         case PIPE_TEXTURE_3D:
             assert(face == 0);
             return offset + zslice * tex->layer_size[level];
@@ -603,7 +604,7 @@ static unsigned r300_texture_get_tile_size(struct r300_texture* tex,
 {
     unsigned pixsize, tile_size;
 
-    pixsize = util_format_get_blocksize(tex->tex.format);
+    pixsize = util_format_get_blocksize(tex->b.b.format);
     tile_size = microblock_table[util_logbase2(pixsize)][tex->microtile][dim];
 
     if (macrotile) {
@@ -624,9 +625,9 @@ static boolean r300_texture_macro_switch(struct r300_texture *tex,
 
     tile = r300_texture_get_tile_size(tex, dim, TRUE);
     if (dim == TILE_WIDTH) {
-        texdim = u_minify(tex->tex.width0, level);
+        texdim = u_minify(tex->b.b.width0, level);
     } else {
-        texdim = u_minify(tex->tex.height0, level);
+        texdim = u_minify(tex->b.b.height0, level);
     }
 
     /* See TX_FILTER1_n.MACRO_SWITCH. */
@@ -650,22 +651,22 @@ unsigned r300_texture_get_stride(struct r300_screen* screen,
         return tex->stride_override;
 
     /* Check the level. */
-    if (level > tex->tex.last_level) {
+    if (level > tex->b.b.last_level) {
         SCREEN_DBG(screen, DBG_TEX, "%s: level (%u) > last_level (%u)\n",
-                   __FUNCTION__, level, tex->tex.last_level);
+                   __FUNCTION__, level, tex->b.b.last_level);
         return 0;
     }
 
-    width = u_minify(tex->tex.width0, level);
+    width = u_minify(tex->b.b.width0, level);
 
-    if (!util_format_is_compressed(tex->tex.format)) {
+    if (!util_format_is_compressed(tex->b.b.format)) {
         tile_width = r300_texture_get_tile_size(tex, TILE_WIDTH,
                                                 tex->mip_macrotile[level]);
         width = align(width, tile_width);
 
-        return util_format_get_stride(tex->tex.format, width);
+        return util_format_get_stride(tex->b.b.format, width);
     } else {
-        return align(util_format_get_stride(tex->tex.format, width), 32);
+        return align(util_format_get_stride(tex->b.b.format, width), 32);
     }
 }
 
@@ -674,21 +675,21 @@ static unsigned r300_texture_get_nblocksy(struct r300_texture* tex,
 {
     unsigned height, tile_height;
 
-    height = u_minify(tex->tex.height0, level);
+    height = u_minify(tex->b.b.height0, level);
 
-    if (!util_format_is_compressed(tex->tex.format)) {
+    if (!util_format_is_compressed(tex->b.b.format)) {
         tile_height = r300_texture_get_tile_size(tex, TILE_HEIGHT,
                                                  tex->mip_macrotile[level]);
         height = align(height, tile_height);
     }
 
-    return util_format_get_nblocksy(tex->tex.format, height);
+    return util_format_get_nblocksy(tex->b.b.format, height);
 }
 
 static void r300_setup_miptree(struct r300_screen* screen,
                                struct r300_texture* tex)
 {
-    struct pipe_texture* base = &tex->tex;
+    struct pipe_resource* base = &tex->b.b;
     unsigned stride, size, layer_size, nblocksy, i;
     boolean rv350_mode = screen->caps->family >= CHIP_FAMILY_RV350;
 
@@ -726,22 +727,22 @@ static void r300_setup_miptree(struct r300_screen* screen,
 
 static void r300_setup_flags(struct r300_texture* tex)
 {
-    tex->is_npot = !util_is_power_of_two(tex->tex.width0) ||
-                   !util_is_power_of_two(tex->tex.height0);
+    tex->is_npot = !util_is_power_of_two(tex->b.b.width0) ||
+                   !util_is_power_of_two(tex->b.b.height0);
 }
 
 static void r300_setup_tiling(struct pipe_screen *screen,
                               struct r300_texture *tex)
 {
-    enum pipe_format format = tex->tex.format;
+    enum pipe_format format = tex->b.b.format;
     boolean rv350_mode = r300_screen(screen)->caps->family >= CHIP_FAMILY_RV350;
 
     if (util_format_is_compressed(format)) {
         return;
     }
 
-    if (tex->tex.width0 == 1 ||
-        tex->tex.height0 == 1) {
+    if (tex->b.b.width0 == 1 ||
+        tex->b.b.height0 == 1) {
         return;
     }
 
@@ -767,9 +768,73 @@ static void r300_setup_tiling(struct pipe_screen *screen,
     }
 }
 
+
+static unsigned r300_texture_is_referenced(struct pipe_context *context,
+					 struct pipe_resource *texture,
+					 unsigned face, unsigned level)
+{
+    struct r300_context *r300 = r300_context(context);
+    struct r300_texture *rtex = (struct r300_texture *)texture;
+
+    if (r300->rws->is_resource_referenced(r300->rws, rtex->buffer))
+        return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+
+    return PIPE_UNREFERENCED;
+}
+
+static void r300_texture_destroy(struct pipe_screen *screen,
+				 struct pipe_resource* texture)
+{
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
+
+    rws->buffer_reference(rws, &tex->buffer, NULL);
+    FREE(tex);
+}
+
+
+
+
+static boolean
+    r300_texture_get_handle(struct pipe_screen* screen,
+                            struct pipe_resource *texture,
+                            struct winsys_handle *whandle)
+{
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    unsigned stride;
+
+    if (!tex) {
+        return FALSE;
+    }
+
+    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
+
+    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
+
+    return TRUE;
+}
+
+
+
+struct u_resource_vtbl r300_texture_vtbl = 
+{
+   r300_texture_get_handle,	      /* get_handle */
+   r300_texture_destroy,	      /* resource_destroy */
+   r300_texture_is_referenced,	      /* is_resource_referenced */
+   r300_texture_get_transfer,	      /* get_transfer */
+   r300_texture_transfer_destroy,     /* transfer_destroy */
+   r300_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   r300_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
 /* Create a new texture. */
-static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
-                                         const struct pipe_texture* template)
+struct pipe_resource* r300_texture_create(struct pipe_screen* screen,
+					  const struct pipe_resource* template)
 {
     struct r300_texture* tex = CALLOC_STRUCT(r300_texture);
     struct r300_screen* rscreen = r300_screen(screen);
@@ -779,9 +844,10 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    tex->tex = *template;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *template;
+    tex->b.vtbl = &r300_texture_vtbl;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     r300_setup_flags(tex);
     if (!(template->tex_usage & R300_TEXTURE_USAGE_TRANSFER)) {
@@ -803,24 +869,19 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    return (struct pipe_texture*)tex;
+    return (struct pipe_resource*)tex;
 }
 
-static void r300_texture_destroy(struct pipe_texture* texture)
-{
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
 
-    rws->buffer_reference(rws, &tex->buffer, NULL);
-    FREE(tex);
-}
 
-static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
-                                                 struct pipe_texture* texture,
-                                                 unsigned face,
-                                                 unsigned level,
-                                                 unsigned zslice,
-                                                 unsigned flags)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
+					  struct pipe_resource* texture,
+					  unsigned face,
+					  unsigned level,
+					  unsigned zslice,
+					  unsigned flags)
 {
     struct r300_texture* tex = (struct r300_texture*)texture;
     struct pipe_surface* surface = CALLOC_STRUCT(pipe_surface);
@@ -830,7 +891,7 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
 
     if (surface) {
         pipe_reference_init(&surface->reference, 1);
-        pipe_texture_reference(&surface->texture, texture);
+        pipe_resource_reference(&surface->texture, texture);
         surface->format = texture->format;
         surface->width = u_minify(texture->width0, level);
         surface->height = u_minify(texture->height0, level);
@@ -845,17 +906,18 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
     return surface;
 }
 
-static void r300_tex_surface_destroy(struct pipe_surface* s)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+void r300_tex_surface_destroy(struct pipe_surface* s)
 {
-    pipe_texture_reference(&s->texture, NULL);
+    pipe_resource_reference(&s->texture, NULL);
     FREE(s);
 }
 
-
-static struct pipe_texture*
-    r300_texture_from_handle(struct pipe_screen* screen,
-                             const struct pipe_texture* base,
-                             struct winsys_handle *whandle)
+struct pipe_resource*
+r300_texture_from_handle(struct pipe_screen* screen,
+			  const struct pipe_resource* base,
+			  struct winsys_handle *whandle)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen*)screen->winsys;
     struct r300_screen* rscreen = r300_screen(screen);
@@ -880,9 +942,9 @@ static struct pipe_texture*
         return NULL;
     }
 
-    tex->tex = *base;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *base;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     tex->stride_override = stride;
     tex->pitch[0] = stride / util_format_get_blocksize(base->format);
@@ -893,36 +955,19 @@ static struct pipe_texture*
     /* one ref already taken */
     tex->buffer = buffer;
 
-    return (struct pipe_texture*)tex;
+    return (struct pipe_resource*)tex;
 }
 
-static boolean
-    r300_texture_get_handle(struct pipe_screen* screen,
-                            struct pipe_texture *texture,
-                            struct winsys_handle *whandle)
-{
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    unsigned stride;
-
-    if (!tex) {
-        return FALSE;
-    }
-
-    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
 
-    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
 
-    return TRUE;
-}
 
-static struct pipe_video_surface *
+struct pipe_video_surface *
 r300_video_surface_create(struct pipe_screen *screen,
                           enum pipe_video_chroma_format chroma_format,
                           unsigned width, unsigned height)
 {
     struct r300_video_surface *r300_vsfc;
-    struct pipe_texture template;
+    struct pipe_resource template;
 
     assert(screen);
     assert(width && height);
@@ -937,7 +982,7 @@ r300_video_surface_create(struct pipe_screen *screen,
     r300_vsfc->base.width = width;
     r300_vsfc->base.height = height;
 
-    memset(&template, 0, sizeof(struct pipe_texture));
+    memset(&template, 0, sizeof template);
     template.target = PIPE_TEXTURE_2D;
     template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
     template.last_level = 0;
@@ -947,7 +992,7 @@ r300_video_surface_create(struct pipe_screen *screen,
     template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER |
                          PIPE_TEXTURE_USAGE_RENDER_TARGET;
 
-    r300_vsfc->tex = screen->texture_create(screen, &template);
+    r300_vsfc->tex = screen->resource_create(screen, &template);
     if (!r300_vsfc->tex)
     {
         FREE(r300_vsfc);
@@ -957,45 +1002,9 @@ r300_video_surface_create(struct pipe_screen *screen,
     return &r300_vsfc->base;
 }
 
-static void r300_video_surface_destroy(struct pipe_video_surface *vsfc)
+void r300_video_surface_destroy(struct pipe_video_surface *vsfc)
 {
     struct r300_video_surface *r300_vsfc = r300_video_surface(vsfc);
-    pipe_texture_reference(&r300_vsfc->tex, NULL);
+    pipe_resource_reference(&r300_vsfc->tex, NULL);
     FREE(r300_vsfc);
 }
-
-void r300_init_screen_texture_functions(struct pipe_screen* screen)
-{
-    screen->texture_create = r300_texture_create;
-    screen->texture_from_handle = r300_texture_from_handle;
-    screen->texture_get_handle = r300_texture_get_handle;
-    screen->texture_destroy = r300_texture_destroy;
-    screen->get_tex_surface = r300_get_tex_surface;
-    screen->tex_surface_destroy = r300_tex_surface_destroy;
-
-    screen->video_surface_create = r300_video_surface_create;
-    screen->video_surface_destroy= r300_video_surface_destroy;
-}
-
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture* texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned* stride)
-{
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_winsys_buffer *buf;
-
-    if (!tex) {
-        return FALSE;
-    }
-
-    rws->buffer_reference(rws, &buf, tex->buffer);
-
-    if (stride) {
-        *stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
-    }
-
-    *buffer = buf;
-    return TRUE;
-}
diff --git a/src/gallium/drivers/r300/r300_texture.h b/src/gallium/drivers/r300/r300_texture.h
index 60c7fa8342..e33b1c29ec 100644
--- a/src/gallium/drivers/r300/r300_texture.h
+++ b/src/gallium/drivers/r300/r300_texture.h
@@ -30,8 +30,6 @@
 
 struct r300_texture;
 
-void r300_init_screen_texture_functions(struct pipe_screen* screen);
-
 unsigned r300_texture_get_stride(struct r300_screen* screen,
                                  struct r300_texture* tex, unsigned level);
 
@@ -39,7 +37,7 @@ unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
                                  unsigned zslice, unsigned face);
 
 void r300_texture_reinterpret_format(struct pipe_screen *screen,
-                                     struct pipe_texture *tex,
+                                     struct pipe_resource *tex,
                                      enum pipe_format new_format);
 
 boolean r300_is_colorbuffer_format_supported(enum pipe_format format);
@@ -51,7 +49,7 @@ boolean r300_is_sampler_format_supported(enum pipe_format format);
 struct r300_video_surface
 {
     struct pipe_video_surface   base;
-    struct pipe_texture         *tex;
+    struct pipe_resource         *tex;
 };
 
 static INLINE struct r300_video_surface *
@@ -60,11 +58,32 @@ r300_video_surface(struct pipe_video_surface *pvs)
     return (struct r300_video_surface *)pvs;
 }
 
-/* Used internally for texture_is_referenced()
- */
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture *texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned* stride);
+
+
+struct pipe_resource*
+r300_texture_from_handle(struct pipe_screen* screen,
+			 const struct pipe_resource* base,
+			 struct winsys_handle *whandle);
+
+struct pipe_resource*
+r300_texture_create(struct pipe_screen* screen,
+		    const struct pipe_resource* template);
+
+struct pipe_video_surface *
+r300_video_surface_create(struct pipe_screen *screen,
+                          enum pipe_video_chroma_format chroma_format,
+                          unsigned width, unsigned height);
+
+void r300_video_surface_destroy(struct pipe_video_surface *vsfc);
+
+
+struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
+					  struct pipe_resource* texture,
+					  unsigned face,
+					  unsigned level,
+					  unsigned zslice,
+					  unsigned flags);
+
+void r300_tex_surface_destroy(struct pipe_surface* s);
 
 #endif /* R300_TEXTURE_H */
diff --git a/src/gallium/drivers/r300/r300_transfer.c b/src/gallium/drivers/r300/r300_transfer.c
index fdac467347..e3b6f04a09 100644
--- a/src/gallium/drivers/r300/r300_transfer.c
+++ b/src/gallium/drivers/r300/r300_transfer.c
@@ -38,9 +38,6 @@ struct r300_transfer {
     /* Pipe context. */
     struct pipe_context *ctx;
 
-    /* Parameters of get_transfer. */
-    unsigned x, y, level, zslice, face;
-
     /* Offset from start of buffer. */
     unsigned offset;
 
@@ -48,7 +45,7 @@ struct r300_transfer {
     struct r300_texture *detiled_texture;
 
     /* Transfer and format flags. */
-    unsigned buffer_usage, render_target_usage;
+    unsigned render_target_usage;
 };
 
 /* Convenience cast wrapper. */
@@ -64,22 +61,24 @@ static void r300_copy_from_tiled_texture(struct pipe_context *ctx,
 {
     struct pipe_screen *screen = ctx->screen;
     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
-    struct pipe_texture *tex = transfer->texture;
+    struct pipe_resource *tex = transfer->resource;
     struct pipe_surface *src, *dst;
 
-    src = screen->get_tex_surface(screen, tex, r300transfer->face,
-                                  r300transfer->level, r300transfer->zslice,
+    src = screen->get_tex_surface(screen, tex,
+				  transfer->sr.face,
+                                  transfer->sr.level,
+				  transfer->box.z,
                                   PIPE_BUFFER_USAGE_GPU_READ |
                                   PIPE_BUFFER_USAGE_PIXEL);
 
-    dst = screen->get_tex_surface(screen, &r300transfer->detiled_texture->tex,
+    dst = screen->get_tex_surface(screen, &r300transfer->detiled_texture->b.b,
                                   0, 0, 0,
                                   PIPE_BUFFER_USAGE_GPU_WRITE |
-                                  PIPE_BUFFER_USAGE_PIXEL |
-                                  r300transfer->buffer_usage);
+                                  PIPE_BUFFER_USAGE_PIXEL);
 
-    ctx->surface_copy(ctx, dst, 0, 0, src, r300transfer->x, r300transfer->y,
-                      transfer->width, transfer->height);
+    ctx->surface_copy(ctx, dst, 0, 0, src, 
+		      transfer->box.x, transfer->box.y,
+                      transfer->box.width, transfer->box.height);
 
     pipe_surface_reference(&src, NULL);
     pipe_surface_reference(&dst, NULL);
@@ -91,16 +90,18 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
 {
     struct pipe_screen *screen = ctx->screen;
     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
-    struct pipe_texture *tex = transfer->texture;
+    struct pipe_resource *tex = transfer->resource;
     struct pipe_surface *src, *dst;
 
-    src = screen->get_tex_surface(screen, &r300transfer->detiled_texture->tex,
+    src = screen->get_tex_surface(screen, &r300transfer->detiled_texture->b.b,
                                   0, 0, 0,
                                   PIPE_BUFFER_USAGE_GPU_READ |
                                   PIPE_BUFFER_USAGE_PIXEL);
 
-    dst = screen->get_tex_surface(screen, tex, r300transfer->face,
-                                  r300transfer->level, r300transfer->zslice,
+    dst = screen->get_tex_surface(screen, tex,
+				  transfer->sr.face,
+                                  transfer->sr.level,
+				  transfer->box.z,
                                   PIPE_BUFFER_USAGE_GPU_WRITE |
                                   PIPE_BUFFER_USAGE_PIXEL);
 
@@ -109,8 +110,10 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
      * Reproducible with perf/copytex. */
     ctx->flush(ctx, 0, NULL);
 
-    ctx->surface_copy(ctx, dst, r300transfer->x, r300transfer->y, src, 0, 0,
-                      transfer->width, transfer->height);
+    ctx->surface_copy(ctx, dst,
+		      transfer->box.x, transfer->box.y,
+		      src, 0, 0,
+                      transfer->box.width, transfer->box.height);
 
     /* XXX this flush fixes a few piglit tests (e.g. glean/pixelFormats). */
     ctx->flush(ctx, 0, NULL);
@@ -119,36 +122,30 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
     pipe_surface_reference(&dst, NULL);
 }
 
-static struct pipe_transfer*
-r300_get_transfer(struct pipe_context *ctx,
-                      struct pipe_texture *texture,
-                      unsigned face, unsigned level, unsigned zslice,
-                      enum pipe_transfer_usage usage, unsigned x, unsigned y,
-                      unsigned w, unsigned h)
+struct pipe_transfer*
+r300_texture_get_transfer(struct pipe_context *ctx,
+			  struct pipe_resource *texture,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
 {
     struct r300_texture *tex = (struct r300_texture *)texture;
     struct r300_screen *r300screen = r300_screen(ctx->screen);
     struct r300_transfer *trans;
-    struct pipe_texture template;
+    struct pipe_resource template;
 
     trans = CALLOC_STRUCT(r300_transfer);
     if (trans) {
         /* Initialize the transfer object. */
-        pipe_texture_reference(&trans->transfer.texture, texture);
+        pipe_resource_reference(&trans->transfer.resource, texture);
+        trans->transfer.sr = sr;
         trans->transfer.usage = usage;
-        trans->transfer.width = w;
-        trans->transfer.height = h;
+        trans->transfer.box = *box;
         trans->ctx = ctx;
-        trans->x = x;
-        trans->y = y;
-        trans->level = level;
-        trans->zslice = zslice;
-        trans->face = face;
 
         /* If the texture is tiled, we must create a temporary detiled texture
          * for this transfer. */
         if (tex->microtile || tex->macrotile) {
-            trans->buffer_usage = pipe_transfer_buffer_flags(&trans->transfer);
             trans->render_target_usage =
                 util_format_is_depth_or_stencil(texture->format) ?
                 PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
@@ -156,8 +153,8 @@ r300_get_transfer(struct pipe_context *ctx,
 
             template.target = PIPE_TEXTURE_2D;
             template.format = texture->format;
-            template.width0 = w;
-            template.height0 = h;
+            template.width0 = box->width;
+            template.height0 = box->height;
             template.depth0 = 0;
             template.last_level = 0;
             template.nr_samples = 0;
@@ -177,14 +174,19 @@ r300_get_transfer(struct pipe_context *ctx,
 
             /* Create the temporary texture. */
             trans->detiled_texture = (struct r300_texture*)
-               ctx->screen->texture_create(ctx->screen,
+               ctx->screen->resource_create(ctx->screen,
                                            &template);
 
             assert(!trans->detiled_texture->microtile &&
                    !trans->detiled_texture->macrotile);
 
             /* Set the stride.
-             * Parameters x, y, level, zslice, and face remain zero. */
+	     *
+	     * Even though we are using an internal texture for this,
+	     * the transfer sr, box and usage parameters still reflect
+	     * the arguments received to get_transfer.  We just do the
+	     * right thing internally.
+	     */
             trans->transfer.stride =
                 r300_texture_get_stride(r300screen, trans->detiled_texture, 0);
 
@@ -194,21 +196,16 @@ r300_get_transfer(struct pipe_context *ctx,
                 r300_copy_from_tiled_texture(ctx, trans);
             }
         } else {
-            trans->transfer.x = x;
-            trans->transfer.y = y;
             trans->transfer.stride =
-                r300_texture_get_stride(r300screen, tex, level);
-            trans->transfer.level = level;
-            trans->transfer.zslice = zslice;
-            trans->transfer.face = face;
-            trans->offset = r300_texture_get_offset(tex, level, zslice, face);
+                r300_texture_get_stride(r300screen, tex, sr.level);
+            trans->offset = r300_texture_get_offset(tex, sr.level, box->z, sr.face);
         }
     }
     return &trans->transfer;
 }
 
-static void r300_transfer_destroy(struct pipe_context *ctx,
-                                      struct pipe_transfer *trans)
+void r300_texture_transfer_destroy(struct pipe_context *ctx,
+				   struct pipe_transfer *trans)
 {
     struct r300_transfer *r300transfer = r300_transfer(trans);
 
@@ -217,49 +214,49 @@ static void r300_transfer_destroy(struct pipe_context *ctx,
             r300_copy_into_tiled_texture(r300transfer->ctx, r300transfer);
         }
 
-        pipe_texture_reference(
-            (struct pipe_texture**)&r300transfer->detiled_texture, NULL);
+        pipe_resource_reference(
+            (struct pipe_resource**)&r300transfer->detiled_texture, NULL);
     }
-    pipe_texture_reference(&trans->texture, NULL);
+    pipe_resource_reference(&trans->resource, NULL);
     FREE(trans);
 }
 
-static void* r300_transfer_map(struct pipe_context *ctx,
-                               struct pipe_transfer *transfer)
+void* r300_texture_transfer_map(struct pipe_context *ctx,
+				struct pipe_transfer *transfer)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
     struct r300_transfer *r300transfer = r300_transfer(transfer);
-    struct r300_texture *tex = (struct r300_texture*)transfer->texture;
+    struct r300_texture *tex = (struct r300_texture*)transfer->resource;
     char *map;
-    enum pipe_format format = tex->tex.format;
+    enum pipe_format format = tex->b.b.format;
 
     if (r300transfer->detiled_texture) {
         /* The detiled texture is of the same size as the region being mapped
          * (no offset needed). */
         return rws->buffer_map(rws,
                                r300transfer->detiled_texture->buffer,
-                               pipe_transfer_buffer_flags(transfer));
+                               transfer->usage);
     } else {
         /* Tiling is disabled. */
         map = rws->buffer_map(rws, tex->buffer,
-                              pipe_transfer_buffer_flags(transfer));
+                              transfer->usage);
 
         if (!map) {
             return NULL;
         }
 
         return map + r300_transfer(transfer)->offset +
-            transfer->y / util_format_get_blockheight(format) * transfer->stride +
-            transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+            transfer->box.y / util_format_get_blockheight(format) * transfer->stride +
+            transfer->box.x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
     }
 }
 
-static void r300_transfer_unmap(struct pipe_context *ctx,
-                                struct pipe_transfer *transfer)
+void r300_texture_transfer_unmap(struct pipe_context *ctx,
+				 struct pipe_transfer *transfer)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
     struct r300_transfer *r300transfer = r300_transfer(transfer);
-    struct r300_texture *tex = (struct r300_texture*)transfer->texture;
+    struct r300_texture *tex = (struct r300_texture*)transfer->resource;
 
     if (r300transfer->detiled_texture) {
 	rws->buffer_unmap(rws, r300transfer->detiled_texture->buffer);
@@ -268,13 +265,3 @@ static void r300_transfer_unmap(struct pipe_context *ctx,
     }
 }
 
-
-void r300_init_transfer_functions( struct r300_context *r300ctx )
-{
-   struct pipe_context *ctx = &r300ctx->context;
-
-   ctx->get_transfer = r300_get_transfer;
-   ctx->transfer_destroy = r300_transfer_destroy;
-   ctx->transfer_map = r300_transfer_map;
-   ctx->transfer_unmap = r300_transfer_unmap;
-}
diff --git a/src/gallium/drivers/r300/r300_transfer.h b/src/gallium/drivers/r300/r300_transfer.h
index 79baf6d048..d72e54e5ed 100644
--- a/src/gallium/drivers/r300/r300_transfer.h
+++ b/src/gallium/drivers/r300/r300_transfer.h
@@ -28,6 +28,24 @@
 
 struct r300_context;
 
-void r300_init_transfer_functions(struct r300_context *r300ctx);
+struct pipe_transfer*
+r300_texture_get_transfer(struct pipe_context *ctx,
+			  struct pipe_resource *texture,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box);
+
+void
+r300_texture_transfer_destroy(struct pipe_context *ctx,
+			      struct pipe_transfer *trans);
+
+void*
+r300_texture_transfer_map(struct pipe_context *ctx,
+			  struct pipe_transfer *transfer);
+
+void
+r300_texture_transfer_unmap(struct pipe_context *ctx,
+			    struct pipe_transfer *transfer);
+
 
 #endif
diff --git a/src/gallium/drivers/r300/r300_winsys.h b/src/gallium/drivers/r300/r300_winsys.h
index e5183a8239..e478802c2f 100644
--- a/src/gallium/drivers/r300/r300_winsys.h
+++ b/src/gallium/drivers/r300/r300_winsys.h
@@ -38,11 +38,6 @@ struct pipe_screen* r300_create_screen(struct r300_winsys_screen *rws);
 struct r300_winsys_buffer;
 
 
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture* texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned *stride);
-
 enum r300_value_id {
     R300_VID_PCI_ID,
     R300_VID_GB_PIPES,
@@ -99,7 +94,7 @@ struct r300_winsys_screen {
 			       unsigned offset,
 			       unsigned length);
 
-    /* Add a pipe_buffer to the list of buffer objects to validate. */
+    /* Add a pipe_resource to the list of buffer objects to validate. */
     boolean (*add_buffer)(struct r300_winsys_screen *winsys,
                           struct r300_winsys_buffer *buf,
                           uint32_t rd,
@@ -163,7 +158,7 @@ struct r300_winsys_screen {
 				 unsigned stride,
 				 struct winsys_handle *whandle);
 
-    boolean (*is_buffer_referenced)(struct r300_winsys_screen *winsys,
+    boolean (*is_resource_referenced)(struct r300_winsys_screen *winsys,
                                     struct r300_winsys_buffer *buffer);