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

1 files changed, 613 insertions, 164 deletions

diff --git a/src/gallium/drivers/trace/tr_screen.c b/src/gallium/drivers/trace/tr_screen.c
index 8789f86b1a..954576d721 100644
--- a/src/gallium/drivers/trace/tr_screen.c
+++ b/src/gallium/drivers/trace/tr_screen.c
@@ -27,12 +27,14 @@
 
 #include "util/u_memory.h"
 
+#include "tr_buffer.h"
 #include "tr_dump.h"
 #include "tr_state.h"
-#include "tr_winsys.h"
 #include "tr_texture.h"
 #include "tr_screen.h"
 
+#include "pipe/p_inlines.h"
+
 
 static const char *
 trace_screen_get_name(struct pipe_screen *_screen)
@@ -40,17 +42,17 @@ trace_screen_get_name(struct pipe_screen *_screen)
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_name");
-   
+
    trace_dump_arg(ptr, screen);
 
    result = screen->get_name(screen);
-   
+
    trace_dump_ret(string, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
@@ -61,80 +63,80 @@ trace_screen_get_vendor(struct pipe_screen *_screen)
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    const char *result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_vendor");
-   
+
    trace_dump_arg(ptr, screen);
-  
+
    result = screen->get_vendor(screen);
-   
+
    trace_dump_ret(string, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static int 
-trace_screen_get_param(struct pipe_screen *_screen, 
+static int
+trace_screen_get_param(struct pipe_screen *_screen,
                        int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    int result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_param");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(int, param);
 
    result = screen->get_param(screen, param);
-   
+
    trace_dump_ret(int, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static float 
-trace_screen_get_paramf(struct pipe_screen *_screen, 
+static float
+trace_screen_get_paramf(struct pipe_screen *_screen,
                         int param)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    float result;
-   
+
    trace_dump_call_begin("pipe_screen", "get_paramf");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(int, param);
 
    result = screen->get_paramf(screen, param);
-   
+
    trace_dump_ret(float, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
-static boolean 
+static boolean
 trace_screen_is_format_supported(struct pipe_screen *_screen,
                                  enum pipe_format format,
                                  enum pipe_texture_target target,
-                                 unsigned tex_usage, 
+                                 unsigned tex_usage,
                                  unsigned geom_flags)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    boolean result;
-   
+
    trace_dump_call_begin("pipe_screen", "is_format_supported");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(format, format);
    trace_dump_arg(int, target);
@@ -142,15 +144,45 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
    trace_dump_arg(uint, geom_flags);
 
    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
-   
+
    trace_dump_ret(bool, result);
-   
+
    trace_dump_call_end();
-   
+
    return result;
 }
 
 
+static void
+trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
+                               struct pipe_surface *_surface,
+                               void *context_private)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
+   struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_surface *surface = tr_surf->surface;
+
+   trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
+   /* XXX: hide, as there is nothing we can do with this
+   trace_dump_arg(ptr, context_private);
+   */
+
+   screen->flush_frontbuffer(screen, surface, context_private);
+
+   trace_dump_call_end();
+}
+
+
+/********************************************************************
+ * texture
+ */
+
+
 static struct pipe_texture *
 trace_screen_texture_create(struct pipe_screen *_screen,
                             const struct pipe_texture *templat)
@@ -158,20 +190,20 @@ trace_screen_texture_create(struct pipe_screen *_screen,
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
    struct pipe_texture *result;
-   
+
    trace_dump_call_begin("pipe_screen", "texture_create");
 
    trace_dump_arg(ptr, screen);
    trace_dump_arg(template, templat);
 
    result = screen->texture_create(screen, templat);
-   
+
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_texture_create(tr_scr, result);
-   
+
    return result;
 }
 
@@ -195,71 +227,60 @@ trace_screen_texture_blanket(struct pipe_screen *_screen,
    trace_dump_arg(ptr, buffer);
 
    result = screen->texture_blanket(screen, templat, ppitch, buffer);
-   
+
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_texture_create(tr_scr, result);
-   
+
    return result;
 }
 
 
-static void 
-trace_screen_texture_release(struct pipe_screen *_screen,
-                             struct pipe_texture **ptexture)
+static void
+trace_screen_texture_destroy(struct pipe_texture *_texture)
 {
-   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_screen *tr_scr = trace_screen(_texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct pipe_texture *texture;
-   
-   assert(ptexture);
-   if(*ptexture) {
-      tr_tex = trace_texture(tr_scr, *ptexture);
-      texture = tr_tex->texture;
-      assert(texture->screen == screen);
-   }
-   else
-      texture = NULL;
-   
-   if (*ptexture) {
-      if (!--(*ptexture)->refcount) {
-         trace_dump_call_begin("pipe_screen", "texture_destroy");
-         
-         trace_dump_arg(ptr, screen);
-         trace_dump_arg(ptr, texture);
-         
-         trace_texture_destroy(tr_scr, *ptexture);
-         
-         trace_dump_call_end();
-      }
-   
-      *ptexture = NULL;
-   }
+   struct pipe_texture *texture = tr_tex->texture;
+
+   assert(texture->screen == screen);
+
+   trace_dump_call_begin("pipe_screen", "texture_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
+
+   trace_dump_call_end();
+
+   trace_texture_destroy(tr_scr, _texture);
 }
 
 
+/********************************************************************
+ * surface
+ */
+
+
 static struct pipe_surface *
 trace_screen_get_tex_surface(struct pipe_screen *_screen,
-                             struct pipe_texture *texture,
+                             struct pipe_texture *_texture,
                              unsigned face, unsigned level,
                              unsigned zslice,
                              unsigned usage)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct pipe_surface *result;
-   
-   assert(texture);
-   tr_tex = trace_texture(tr_scr, texture);
-   texture = tr_tex->texture;
+   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_surface *result = NULL;
+
    assert(texture->screen == screen);
-   
+
    trace_dump_call_begin("pipe_screen", "get_tex_surface");
-   
+
    trace_dump_arg(ptr, screen);
    trace_dump_arg(ptr, texture);
    trace_dump_arg(uint, face);
@@ -270,133 +291,538 @@ trace_screen_get_tex_surface(struct pipe_screen *_screen,
    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 
    trace_dump_ret(ptr, result);
-   
+
    trace_dump_call_end();
-   
+
    result = trace_surface_create(tr_tex, result);
 
    return result;
 }
 
 
-static void 
-trace_screen_tex_surface_release(struct pipe_screen *_screen,
-                                 struct pipe_surface **psurface)
+static void
+trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
+{
+   struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
+   struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_surface *surface = tr_surf->surface;
+
+   trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, surface);
+
+   trace_dump_call_end();
+
+   trace_surface_destroy(tr_tex, _surface);
+}
+
+
+/********************************************************************
+ * transfer
+ */
+
+
+static struct pipe_transfer *
+trace_screen_get_tex_transfer(struct pipe_screen *_screen,
+                              struct pipe_texture *_texture,
+                              unsigned face, unsigned level,
+                              unsigned zslice,
+                              enum pipe_transfer_usage usage,
+                              unsigned x, unsigned y, unsigned w, unsigned h)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
-   struct pipe_surface *surface;
-   
-   assert(psurface);
-   if(*psurface) {
-      tr_tex = trace_texture(tr_scr, (*psurface)->texture);
-      tr_surf = trace_surface(tr_tex, *psurface);
-      surface = tr_surf->surface;
-   }
-   else
-      surface = NULL;
-   
-   if (*psurface) {
-      if (!--(*psurface)->refcount) {
-         trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
-         
-         trace_dump_arg(ptr, screen);
-         trace_dump_arg(ptr, surface);
+   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_transfer *result = NULL;
 
-         trace_surface_destroy(tr_tex, *psurface);
+   assert(texture->screen == screen);
 
-         trace_dump_call_end();
-      }
-   
-      *psurface = NULL;
-   }
+   trace_dump_call_begin("pipe_screen", "get_tex_transfer");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, texture);
+   trace_dump_arg(uint, face);
+   trace_dump_arg(uint, level);
+   trace_dump_arg(uint, zslice);
+   trace_dump_arg(uint, usage);
+
+   trace_dump_arg(uint, x);
+   trace_dump_arg(uint, y);
+   trace_dump_arg(uint, w);
+   trace_dump_arg(uint, h);
+
+   result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
+                                     x, y, w, h);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   result = trace_transfer_create(tr_tex, result);
+
+   return result;
+}
+
+
+static void
+trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
+{
+   struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_tran = trace_transfer(tr_tex, _transfer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_transfer *transfer = tr_tran->transfer;
+
+   trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, transfer);
+
+   trace_dump_call_end();
+
+   trace_transfer_destroy(tr_tex, _transfer);
 }
 
 
 static void *
-trace_screen_surface_map(struct pipe_screen *_screen,
-                         struct pipe_surface *surface,
-                         unsigned flags)
+trace_screen_transfer_map(struct pipe_screen *_screen,
+                          struct pipe_transfer *_transfer)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_trans = trace_transfer(tr_tex, _transfer);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
+   struct pipe_transfer *transfer = tr_trans->transfer;
    void *map;
-   
-   tr_tex = trace_texture(tr_scr, surface->texture);
-   tr_surf = trace_surface(tr_tex, surface);
-   surface = tr_surf->surface;
 
-   map = screen->surface_map(screen, surface, flags);
+   map = screen->transfer_map(screen, transfer);
    if(map) {
-      if(flags & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         assert(!tr_surf->map);
-         tr_surf->map = map;
+      if(transfer->usage != PIPE_TRANSFER_READ) {
+         assert(!tr_trans->map);
+         tr_trans->map = map;
       }
    }
-   
+
    return map;
 }
 
 
-static void 
-trace_screen_surface_unmap(struct pipe_screen *_screen,
-                           struct pipe_surface *surface)
+static void
+trace_screen_transfer_unmap(struct pipe_screen *_screen,
+                           struct pipe_transfer *_transfer)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
+   struct trace_transfer *tr_trans = trace_transfer(tr_tex, _transfer);
    struct pipe_screen *screen = tr_scr->screen;
-   struct trace_texture *tr_tex;
-   struct trace_surface *tr_surf;
-   
-   tr_tex = trace_texture(tr_scr, surface->texture);
-   tr_surf = trace_surface(tr_tex, surface);
-   surface = tr_surf->surface;
-   
-   if(tr_surf->map) {
-      size_t size = surface->nblocksy * surface->stride;
-      
-      trace_dump_call_begin("pipe_winsys", "surface_write");
-      
+   struct pipe_transfer *transfer = tr_trans->transfer;
+
+   if(tr_trans->map) {
+      size_t size = transfer->nblocksy * transfer->stride;
+
+      trace_dump_call_begin("pipe_screen", "transfer_write");
+
       trace_dump_arg(ptr, screen);
-      
-      trace_dump_arg(ptr, surface);
-      
-      trace_dump_arg_begin("data");
-      trace_dump_bytes(tr_surf->map, size);
-      trace_dump_arg_end();
+
+      trace_dump_arg(ptr, transfer);
 
       trace_dump_arg_begin("stride");
-      trace_dump_uint(surface->stride);
+      trace_dump_uint(transfer->stride);
+      trace_dump_arg_end();
+
+      trace_dump_arg_begin("data");
+      trace_dump_bytes(tr_trans->map, size);
       trace_dump_arg_end();
 
       trace_dump_arg_begin("size");
       trace_dump_uint(size);
       trace_dump_arg_end();
-   
+
       trace_dump_call_end();
 
-      tr_surf->map = NULL;
+      tr_trans->map = NULL;
+   }
+
+   screen->transfer_unmap(screen, transfer);
+}
+
+
+/********************************************************************
+ * buffer
+ */
+
+
+static struct pipe_buffer *
+trace_screen_surface_buffer_create(struct pipe_screen *_screen,
+                                   unsigned width, unsigned height,
+                                   enum pipe_format format,
+                                   unsigned usage,
+                                   unsigned *pstride)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   unsigned stride;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "surface_buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(uint, width);
+   trace_dump_arg(uint, height);
+   trace_dump_arg(format, format);
+   trace_dump_arg(uint, usage);
+
+   result = screen->surface_buffer_create(screen,
+                                          width, height,
+                                          format,
+                                          usage,
+                                          pstride);
+
+   stride = *pstride;
+
+   trace_dump_arg(uint, stride);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+static struct pipe_buffer *
+trace_screen_buffer_create(struct pipe_screen *_screen,
+                           unsigned alignment,
+                           unsigned usage,
+                           unsigned size)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(uint, alignment);
+   trace_dump_arg(uint, usage);
+   trace_dump_arg(uint, size);
+
+   result = screen->buffer_create(screen, alignment, usage, size);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   /* Zero the buffer to avoid dumping uninitialized memory */
+   if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+      void *map;
+      map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
+      if(map) {
+         memset(map, 0, result->size);
+         screen->buffer_unmap(screen, result);
+      }
+   }
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+static struct pipe_buffer *
+trace_screen_user_buffer_create(struct pipe_screen *_screen,
+                                void *data,
+                                unsigned size)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *result;
+
+   trace_dump_call_begin("pipe_screen", "user_buffer_create");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg_begin("data");
+   trace_dump_bytes(data, size);
+   trace_dump_arg_end();
+   trace_dump_arg(uint, size);
+
+   result = screen->user_buffer_create(screen, data, size);
+
+   trace_dump_ret(ptr, result);
+
+   trace_dump_call_end();
+
+   if(result) {
+      assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
+      result->usage |= TRACE_BUFFER_USAGE_USER;
+   }
+
+   return trace_buffer_create(tr_scr, result);
+}
+
+
+/**
+ * This function is used to track if data has been changed on a user buffer
+ * without map/unmap being called.
+ */
+void
+trace_screen_user_buffer_update(struct pipe_screen *_screen,
+                                struct pipe_buffer *_buffer)
+{
+#if 0
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   const void *map;
+
+   if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
+      map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
+      if(map) {
+         trace_dump_call_begin("pipe_winsys", "buffer_write");
+
+         trace_dump_arg(ptr, screen);
+
+         trace_dump_arg(ptr, buffer);
+
+         trace_dump_arg_begin("data");
+         trace_dump_bytes(map, buffer->size);
+         trace_dump_arg_end();
+
+         trace_dump_arg_begin("size");
+         trace_dump_uint(buffer->size);
+         trace_dump_arg_end();
+
+         trace_dump_call_end();
+
+         screen->buffer_unmap(screen, buffer);
+      }
+   }
+#endif
+}
+
+
+static void *
+trace_screen_buffer_map(struct pipe_screen *_screen,
+                        struct pipe_buffer *_buffer,
+                        unsigned usage)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+   void *map;
+
+   assert(screen->buffer_map);
+   map = screen->buffer_map(screen, buffer, usage);
+   if(map) {
+      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+         tr_buf->map = map;
+      }
+   }
+
+   return map;
+}
+
+
+static void *
+trace_screen_buffer_map_range(struct pipe_screen *_screen,
+                              struct pipe_buffer *_buffer,
+                              unsigned offset,
+                              unsigned length,
+                              unsigned usage)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+   void *map;
+
+   assert(screen->buffer_map_range);
+   map = screen->buffer_map_range(screen, buffer, offset, length, usage);
+   if(map) {
+      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
+         tr_buf->map = map;
+      }
    }
 
-   screen->surface_unmap(screen, surface);
+   return map;
+}
+
+
+static void
+buffer_write(struct pipe_screen *screen,
+             struct pipe_buffer *buffer,
+             unsigned offset,
+             const char *map,
+             unsigned size)
+{
+   assert(map);
+
+   trace_dump_call_begin("pipe_screen", "buffer_write");
+
+   trace_dump_arg(ptr, screen);
+
+   trace_dump_arg(ptr, buffer);
+
+   trace_dump_arg(uint, offset);
+
+   trace_dump_arg_begin("data");
+   trace_dump_bytes(map + offset, size);
+   trace_dump_arg_end();
+
+   trace_dump_arg(uint, size);
+
+   trace_dump_call_end();
+
+}
+
+
+static void
+trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
+                                       struct pipe_buffer *_buffer,
+                                       unsigned offset,
+                                       unsigned length)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   assert(tr_buf->map);
+   buffer_write(screen, buffer, offset, tr_buf->map, length);
+   tr_buf->range_flushed = TRUE;
+   screen->buffer_flush_mapped_range(screen, buffer, offset, length);
+}
+
+
+static void
+trace_screen_buffer_unmap(struct pipe_screen *_screen,
+                          struct pipe_buffer *_buffer)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   if (tr_buf->map && !tr_buf->range_flushed)
+      buffer_write(screen, buffer, tr_buf->map, 0, buffer->size);
+   tr_buf->map = NULL;
+   tr_buf->range_flushed = FALSE;
+   screen->buffer_unmap(screen, buffer);
+}
+
+
+static void
+trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
+{
+   struct trace_screen *tr_scr = trace_screen(_buffer->screen);
+   struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
+   struct pipe_screen *screen = tr_scr->screen;
+   struct pipe_buffer *buffer = tr_buf->buffer;
+
+   trace_dump_call_begin("pipe_screen", "buffer_destroy");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, buffer);
+
+   trace_dump_call_end();
+
+   trace_buffer_destroy(tr_scr, _buffer);
+}
+
+
+/********************************************************************
+ * fence
+ */
+
+
+static void
+trace_screen_fence_reference(struct pipe_screen *_screen,
+                             struct pipe_fence_handle **dst,
+                             struct pipe_fence_handle *src)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+
+   trace_dump_call_begin("pipe_screen", "fence_reference");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, dst);
+   trace_dump_arg(ptr, src);
+
+   screen->fence_reference(screen, dst, src);
+
+   trace_dump_call_end();
+}
+
+
+static int
+trace_screen_fence_signalled(struct pipe_screen *_screen,
+                             struct pipe_fence_handle *fence,
+                             unsigned flag)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   int result;
+
+   trace_dump_call_begin("pipe_screen", "fence_signalled");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
+
+   result = screen->fence_signalled(screen, fence, flag);
+
+   trace_dump_ret(int, result);
+
+   trace_dump_call_end();
+
+   return result;
 }
 
 
+static int
+trace_screen_fence_finish(struct pipe_screen *_screen,
+                          struct pipe_fence_handle *fence,
+                          unsigned flag)
+{
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct pipe_screen *screen = tr_scr->screen;
+   int result;
+
+   trace_dump_call_begin("pipe_screen", "fence_finish");
+
+   trace_dump_arg(ptr, screen);
+   trace_dump_arg(ptr, fence);
+   trace_dump_arg(uint, flag);
+
+   result = screen->fence_finish(screen, fence, flag);
+
+   trace_dump_ret(int, result);
+
+   trace_dump_call_end();
+
+   return result;
+}
+
+
+/********************************************************************
+ * screen
+ */
+
 static void
 trace_screen_destroy(struct pipe_screen *_screen)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
-   
+
    trace_dump_call_begin("pipe_screen", "destroy");
-   
+
    trace_dump_arg(ptr, screen);
 
    screen->destroy(screen);
-   
+
    trace_dump_call_end();
 
    trace_dump_trace_end();
@@ -410,21 +836,27 @@ trace_screen_create(struct pipe_screen *screen)
 {
    struct trace_screen *tr_scr;
    struct pipe_winsys *winsys;
-   
+
    if(!screen)
       goto error1;
 
    if(!trace_dump_trace_begin())
       goto error1;
 
+   trace_dump_call_begin("", "pipe_screen_create");
+
    tr_scr = CALLOC_STRUCT(trace_screen);
    if(!tr_scr)
       goto error2;
 
+#if 0
    winsys = trace_winsys_create(screen->winsys);
    if(!winsys)
       goto error3;
-   
+#else
+   winsys = screen->winsys;
+#endif
+
    tr_scr->base.winsys = winsys;
    tr_scr->base.destroy = trace_screen_destroy;
    tr_scr->base.get_name = trace_screen_get_name;
@@ -434,26 +866,43 @@ trace_screen_create(struct pipe_screen *screen)
    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
    tr_scr->base.texture_create = trace_screen_texture_create;
    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
-   tr_scr->base.texture_release = trace_screen_texture_release;
+   tr_scr->base.texture_destroy = trace_screen_texture_destroy;
    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
-   tr_scr->base.tex_surface_release = trace_screen_tex_surface_release;
-   tr_scr->base.surface_map = trace_screen_surface_map;
-   tr_scr->base.surface_unmap = trace_screen_surface_unmap;
-   
+   tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
+   tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
+   tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
+   tr_scr->base.transfer_map = trace_screen_transfer_map;
+   tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
+   tr_scr->base.buffer_create = trace_screen_buffer_create;
+   tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
+   tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
+   if (screen->buffer_map)
+      tr_scr->base.buffer_map = trace_screen_buffer_map;
+   if (screen->buffer_map_range)
+      tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
+   if (screen->buffer_flush_mapped_range)
+      tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
+   if (screen->buffer_unmap)
+      tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
+   tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
+   tr_scr->base.fence_reference = trace_screen_fence_reference;
+   tr_scr->base.fence_signalled = trace_screen_fence_signalled;
+   tr_scr->base.fence_finish = trace_screen_fence_finish;
+   tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
    tr_scr->screen = screen;
 
-   trace_dump_call_begin("", "pipe_screen_create");
-   trace_dump_arg_begin("winsys");
-   trace_dump_ptr(screen->winsys);
-   trace_dump_arg_end();
    trace_dump_ret(ptr, screen);
    trace_dump_call_end();
 
    return &tr_scr->base;
 
+#if 0
 error3:
    FREE(tr_scr);
+#endif
 error2:
+   trace_dump_ret(ptr, screen);
+   trace_dump_call_end();
    trace_dump_trace_end();
 error1:
    return screen;