gallium: make p_winsys internal

move it to pipe/internal/p_winsys_screen.h and start converting
the state trackers to the screen usage

src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c

@@ -44,7 +44,7 @@
 #include "pipe/p_compiler.h"
 #include "pipe/p_error.h"
 #include "pipe/p_debug.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_thread.h"
 #include "util/u_memory.h"
 #include "util/u_double_list.h"

src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c

@@ -36,7 +36,7 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_debug.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_thread.h"
 #include "util/u_memory.h"
 #include "util/u_double_list.h"

src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c

@@ -35,7 +35,7 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_debug.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_thread.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"

src/gallium/auxiliary/pipebuffer/pb_winsys.c

@@ -34,7 +34,7 @@
  */
 
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_memory.h"
 
 #include "pb_buffer.h"
@@ -184,8 +184,8 @@ pb_winsys_buffer_destroy(struct pipe_winsys *winsys,
 void 
 pb_init_winsys(struct pipe_winsys *winsys)
 {
-   winsys->_user_buffer_create = pb_winsys_user_buffer_create;
-   winsys->_buffer_map = pb_winsys_buffer_map;
-   winsys->_buffer_unmap = pb_winsys_buffer_unmap;
-   winsys->_buffer_destroy = pb_winsys_buffer_destroy;
+   winsys->user_buffer_create = pb_winsys_user_buffer_create;
+   winsys->buffer_map = pb_winsys_buffer_map;
+   winsys->buffer_unmap = pb_winsys_buffer_unmap;
+   winsys->buffer_destroy = pb_winsys_buffer_destroy;
 }

src/gallium/auxiliary/util/u_blit.c

@@ -37,7 +37,6 @@
 #include "pipe/p_debug.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
 #include "pipe/p_shader_tokens.h"
 
 #include "util/u_blit.h"

src/gallium/auxiliary/util/u_draw_quad.c

@@ -29,7 +29,6 @@
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
 #include "util/u_draw_quad.h"
 
 

src/gallium/auxiliary/util/u_gen_mipmap.c

@@ -38,7 +38,6 @@
 #include "pipe/p_debug.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
 #include "pipe/p_shader_tokens.h"
 
 #include "util/u_memory.h"

src/gallium/auxiliary/util/u_simple_shaders.c

@@ -37,7 +37,7 @@
 #include "pipe/p_debug.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/p_screen.h"
 #include "pipe/p_shader_tokens.h"
 
 #include "util/u_memory.h"

src/gallium/auxiliary/util/u_timed_winsys.c

@@ -29,7 +29,7 @@
  * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  */
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "u_timed_winsys.h"
 #include "util/u_memory.h"
 #include "util/u_time.h"
@@ -122,7 +122,7 @@ timed_buffer_create(struct pipe_winsys *winsys,
    uint64_t start = time_start();
 
    struct pipe_buffer *buf =
-      backend->_buffer_create( backend, alignment, usage, size );
+      backend->buffer_create( backend, alignment, usage, size );
 
    time_finish(winsys, start, 0, __FUNCTION__);
    
@@ -140,7 +140,7 @@ timed_user_buffer_create(struct pipe_winsys *winsys,
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   struct pipe_buffer *buf = backend->_user_buffer_create( backend, data, bytes );
+   struct pipe_buffer *buf = backend->user_buffer_create( backend, data, bytes );
 
    time_finish(winsys, start, 1, __FUNCTION__);
    
@@ -156,7 +156,7 @@ timed_buffer_map(struct pipe_winsys *winsys,
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   void *map = backend->_buffer_map( backend, buf, flags );
+   void *map = backend->buffer_map( backend, buf, flags );
 
    time_finish(winsys, start, 2, __FUNCTION__);
    
@@ -171,7 +171,7 @@ timed_buffer_unmap(struct pipe_winsys *winsys,
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   backend->_buffer_unmap( backend, buf );
+   backend->buffer_unmap( backend, buf );
 
    time_finish(winsys, start, 3, __FUNCTION__);
 }
@@ -184,7 +184,7 @@ timed_buffer_destroy(struct pipe_winsys *winsys,
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   backend->_buffer_destroy( backend, buf );
+   backend->buffer_destroy( backend, buf );
 
    time_finish(winsys, start, 4, __FUNCTION__);
 }
@@ -216,7 +216,7 @@ timed_surface_buffer_create(struct pipe_winsys *winsys,
    struct pipe_winsys *backend = timed_winsys(winsys)->backend;
    uint64_t start = time_start();
 
-   struct pipe_buffer *ret = backend->_surface_buffer_create( backend, width, height, 
+   struct pipe_buffer *ret = backend->surface_buffer_create( backend, width, height, 
                                                              format, usage, stride );
 
    time_finish(winsys, start, 7, __FUNCTION__);
@@ -296,12 +296,12 @@ struct pipe_winsys *u_timed_winsys_create( struct pipe_winsys *backend )
 {
    struct timed_winsys *ws = CALLOC_STRUCT(timed_winsys);
    
-   ws->base._user_buffer_create = timed_user_buffer_create;
-   ws->base._buffer_map = timed_buffer_map;
-   ws->base._buffer_unmap = timed_buffer_unmap;
-   ws->base._buffer_destroy = timed_buffer_destroy;
-   ws->base._buffer_create = timed_buffer_create;
-   ws->base._surface_buffer_create = timed_surface_buffer_create;
+   ws->base.user_buffer_create = timed_user_buffer_create;
+   ws->base.buffer_map = timed_buffer_map;
+   ws->base.buffer_unmap = timed_buffer_unmap;
+   ws->base.buffer_destroy = timed_buffer_destroy;
+   ws->base.buffer_create = timed_buffer_create;
+   ws->base.surface_buffer_create = timed_surface_buffer_create;
    ws->base.flush_frontbuffer = timed_flush_frontbuffer;
    ws->base.get_name = timed_get_name;
    ws->base.fence_reference = timed_fence_reference;

src/gallium/drivers/cell/ppu/cell_context.c

@@ -36,7 +36,7 @@
 #include "pipe/p_defines.h"
 #include "pipe/p_format.h"
 #include "util/u_memory.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_screen.h"
 
 #include "draw/draw_context.h"

src/gallium/drivers/cell/ppu/cell_draw_arrays.c

@@ -33,7 +33,7 @@
 
 #include "pipe/p_defines.h"
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 
 #include "cell_context.h"
@@ -52,7 +52,7 @@ cell_map_constant_buffers(struct cell_context *sp)
    uint i;
    for (i = 0; i < 2; i++) {
       if (sp->constants[i].size) {
-         sp->mapped_constants[i] = ws->_buffer_map(ws, sp->constants[i].buffer,
+         sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer,
                                                    PIPE_BUFFER_USAGE_CPU_READ);
          cell_flush_buffer_range(sp, sp->mapped_constants[i], 
                                  sp->constants[i].buffer->size);
@@ -71,7 +71,7 @@ cell_unmap_constant_buffers(struct cell_context *sp)
    uint i;
    for (i = 0; i < 2; i++) {
       if (sp->constants[i].size)
-         ws->_buffer_unmap(ws, sp->constants[i].buffer);
+         ws->buffer_unmap(ws, sp->constants[i].buffer);
       sp->mapped_constants[i] = NULL;
    }
 }

src/gallium/drivers/cell/ppu/cell_screen.c

@@ -27,7 +27,7 @@
 
 
 #include "util/u_memory.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_screen.h"
 

src/gallium/drivers/cell/ppu/cell_state_shader.c

@@ -28,7 +28,7 @@
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "draw/draw_context.h"
 #include "tgsi/tgsi_parse.h"
 

src/gallium/drivers/cell/ppu/cell_texture.c

@@ -34,7 +34,7 @@
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
@@ -112,7 +112,7 @@ cell_texture_create(struct pipe_screen *screen,
 
    cell_texture_layout(ct);
 
-   ct->buffer = ws->_buffer_create(ws, 32, PIPE_BUFFER_USAGE_PIXEL,
+   ct->buffer = ws->buffer_create(ws, 32, PIPE_BUFFER_USAGE_PIXEL,
                                    ct->buffer_size);
 
    if (!ct->buffer) {
@@ -324,11 +324,11 @@ cell_twiddle_texture(struct pipe_screen *screen,
             /* allocate buffer for tiled data now */
             struct pipe_winsys *ws = screen->winsys;
             uint bytes = bufWidth * bufHeight * 4 * numFaces;
-            ct->tiled_buffer[level] = ws->_buffer_create(ws, 16,
+            ct->tiled_buffer[level] = ws->buffer_create(ws, 16,
                                                          PIPE_BUFFER_USAGE_PIXEL,
                                                          bytes);
             /* and map it */
-            ct->tiled_mapped[level] = ws->_buffer_map(ws, ct->tiled_buffer[level],
+            ct->tiled_mapped[level] = ws->buffer_map(ws, ct->tiled_buffer[level],
                                                       PIPE_BUFFER_USAGE_GPU_READ);
          }
          dst = (uint *) ((ubyte *) ct->tiled_mapped[level] + offset);

src/gallium/drivers/cell/ppu/cell_vertex_shader.c

@@ -31,7 +31,7 @@
 
 #include "pipe/p_defines.h"
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 
 #include "cell_context.h"

src/gallium/drivers/failover/fo_context.c

@@ -27,7 +27,7 @@
 
 
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_memory.h"
 #include "pipe/p_context.h"
 

src/gallium/drivers/i915simple/i915_context.c

@@ -34,7 +34,7 @@
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_memory.h"
 #include "pipe/p_screen.h"

src/gallium/drivers/i915simple/i915_debug.c

@@ -30,7 +30,7 @@
 #include "i915_winsys.h"
 #include "i915_debug.h"
 #include "i915_batch.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_debug.h"
 
 

src/gallium/drivers/i915simple/i915_debug.h

@@ -72,7 +72,7 @@ void i915_print_ureg(const char *msg, unsigned ureg);
 
 #if defined(DEBUG) && defined(FILE_DEBUG_FLAG)
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 static INLINE void
 I915_DBG(

src/gallium/drivers/i915simple/i915_debug_fp.c

@@ -28,7 +28,7 @@
 
 #include "i915_reg.h"
 #include "i915_debug.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_memory.h"
 
 

src/gallium/drivers/i915simple/i915_prim_vbuf.c

@@ -42,7 +42,7 @@
 #include "draw/draw_vbuf.h"
 #include "pipe/p_debug.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 

src/gallium/drivers/i915simple/i915_screen.c

@@ -27,7 +27,7 @@
 
 
 #include "util/u_memory.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_string.h"
 

src/gallium/drivers/i915simple/i915_state.c

@@ -30,7 +30,7 @@
 
 
 #include "draw/draw_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
@@ -536,10 +536,10 @@ static void i915_set_constant_buffer(struct pipe_context *pipe,
    if (buf) {
       void *mapped;
       if (buf->buffer && buf->buffer->size &&
-          (mapped = ws->_buffer_map(ws, buf->buffer,
+          (mapped = ws->buffer_map(ws, buf->buffer,
                                     PIPE_BUFFER_USAGE_CPU_READ))) {
          memcpy(i915->current.constants[shader], mapped, buf->buffer->size);
-         ws->_buffer_unmap(ws, buf->buffer);
+         ws->buffer_unmap(ws, buf->buffer);
          i915->current.num_user_constants[shader]
             = buf->buffer->size / (4 * sizeof(float));
       }

src/gallium/drivers/i915simple/i915_surface.c

@@ -31,7 +31,7 @@
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_tile.h"
 #include "util/u_rect.h"
 

src/gallium/drivers/i915simple/i915_texture.c

@@ -34,7 +34,7 @@
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
@@ -605,7 +605,7 @@ i915_texture_create(struct pipe_screen *screen,
 
    tex_size = tex->stride * tex->total_nblocksy;
 
-   tex->buffer = ws->_buffer_create(ws, 64,
+   tex->buffer = ws->buffer_create(ws, 64,
                                     PIPE_BUFFER_USAGE_PIXEL,
                                     tex_size);
 
@@ -613,10 +613,10 @@ i915_texture_create(struct pipe_screen *screen,
       goto fail;
 
 #if 0
-   void *ptr = ws->_buffer_map(ws, tex->buffer,
+   void *ptr = ws->buffer_map(ws, tex->buffer,
       PIPE_BUFFER_USAGE_CPU_WRITE);
    memset(ptr, 0x80, tex_size);
-   ws->_buffer_unmap(ws, tex->buffer);
+   ws->buffer_unmap(ws, tex->buffer);
 #endif
 
    return &tex->base;

src/gallium/drivers/i965simple/brw_blit.c

@@ -35,7 +35,7 @@
 #include "brw_reg.h"
 
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #define FILE_DEBUG_FLAG DEBUG_BLIT
 

src/gallium/drivers/i965simple/brw_context.c

@@ -37,7 +37,7 @@
 #include "brw_tex_layout.h"
 #include "brw_winsys.h"
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_context.h"
 #include "util/u_memory.h"
 #include "pipe/p_screen.h"

src/gallium/drivers/i965simple/brw_curbe.c

@@ -38,7 +38,7 @@
 #include "brw_util.h"
 #include "brw_wm.h"
 #include "pipe/p_state.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
@@ -256,13 +256,13 @@ static void upload_constant_buffer(struct brw_context *brw)
       /* FIXME: buffer size is num_consts + num_immediates */
       if (brw->vs.prog_data->num_consts) {
          /* map the vertex constant buffer and copy to curbe: */
-         void *data = ws->_buffer_map(ws, cbuffer->buffer, 0);
+         void *data = ws->buffer_map(ws, cbuffer->buffer, 0);
          /* FIXME: this is wrong. the cbuffer->buffer->size currently
           * represents size of consts + immediates. so if we'll
           * have both we'll copy over the end of the buffer
           * with the subsequent memcpy */
          memcpy(&buf[offset], data, cbuffer->buffer->size);
-         ws->_buffer_unmap(ws, cbuffer->buffer);
+         ws->buffer_unmap(ws, cbuffer->buffer);
          offset += cbuffer->buffer->size;
       }
       /*immediates*/

src/gallium/drivers/i965simple/brw_draw.c

@@ -34,7 +34,7 @@
 #include "brw_state.h"
 
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 static unsigned hw_prim[PIPE_PRIM_POLYGON+1] = {
    _3DPRIM_POINTLIST,

src/gallium/drivers/i965simple/brw_screen.c

@@ -27,7 +27,7 @@
 
 
 #include "util/u_memory.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_string.h"
 
 #include "brw_context.h"

src/gallium/drivers/i965simple/brw_state.c

@@ -30,7 +30,7 @@
  */
 
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_memory.h"
 #include "pipe/p_inlines.h"
 #include "pipe/p_shader_tokens.h"

src/gallium/drivers/i965simple/brw_state_pool.c

@@ -42,7 +42,7 @@
  * the pool.
  */
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include "pipe/p_inlines.h"

src/gallium/drivers/i965simple/brw_surface.c

@@ -30,7 +30,7 @@
 #include "brw_state.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_tile.h"
 #include "util/u_rect.h"
 

src/gallium/drivers/i965simple/brw_tex_layout.c

@@ -37,7 +37,7 @@
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include "brw_context.h"
@@ -295,7 +295,7 @@ brw_texture_create_screen(struct pipe_screen *screen,
       tex->base.nblocksy[0] = pf_get_nblocksy(&tex->base.block, tex->base.height[0]);
    
       if (brw_miptree_layout(tex))
-	 tex->buffer = ws->_buffer_create(ws, 64,
+	 tex->buffer = ws->buffer_create(ws, 64,
                                           PIPE_BUFFER_USAGE_PIXEL,
                                           tex->stride *
                                           tex->total_nblocksy);

src/gallium/drivers/nouveau/nouveau_winsys.h

@@ -2,7 +2,7 @@
 #define NOUVEAU_WINSYS_H
 
 #include <stdint.h>
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 
 #include "nouveau/nouveau_bo.h"

src/gallium/drivers/nv04/nv04_context.c

@@ -1,6 +1,6 @@
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv04_context.h"
 #include "nv04_screen.h"

src/gallium/drivers/nv04/nv04_miptree.c

@@ -58,7 +58,7 @@ nv04_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 
 	nv04_miptree_layout(mt);
 
-	mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+	mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
 					   mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);

src/gallium/drivers/nv04/nv04_prim_vbuf.c

@@ -1,7 +1,7 @@
 
 #include "pipe/p_debug.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_compiler.h"
 
 #include "draw/draw_vbuf.h"

src/gallium/drivers/nv04/nv04_screen.c

@@ -117,7 +117,7 @@ nv04_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
 	struct pipe_winsys *ws = screen->winsys;
 	void *map;
 
-	map = ws->_buffer_map(ws, surface->buffer, flags);
+	map = ws->buffer_map(ws, surface->buffer, flags);
 	if (!map)
 		return NULL;
 
@@ -129,7 +129,7 @@ nv04_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
 {
 	struct pipe_winsys *ws = screen->winsys;
 
-	ws->_buffer_unmap(ws, surface->buffer);
+	ws->buffer_unmap(ws, surface->buffer);
 }
 
 static void

src/gallium/drivers/nv04/nv04_surface.c

@@ -28,7 +28,7 @@
 
 #include "nv04_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_tile.h"
 

src/gallium/drivers/nv04/nv04_vbo.c

@@ -23,7 +23,7 @@ boolean nv04_draw_elements( struct pipe_context *pipe,
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv04->vertex_buffer[i].buffer) {
 			void *buf
-				= pipe->winsys->_buffer_map(pipe->winsys,
+				= pipe->winsys->buffer_map(pipe->winsys,
 						nv04->vertex_buffer[i].buffer,
 						PIPE_BUFFER_USAGE_CPU_READ);
 			draw_set_mapped_vertex_buffer(draw, i, buf);
@@ -32,7 +32,7 @@ boolean nv04_draw_elements( struct pipe_context *pipe,
 	/* Map index buffer, if present */
 	if (indexBuffer) {
 		void *mapped_indexes
-			= pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
+			= pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
 					PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
 	}
@@ -49,12 +49,12 @@ boolean nv04_draw_elements( struct pipe_context *pipe,
 	 */
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv04->vertex_buffer[i].buffer) {
-			pipe->winsys->_buffer_unmap(pipe->winsys, nv04->vertex_buffer[i].buffer);
+			pipe->winsys->buffer_unmap(pipe->winsys, nv04->vertex_buffer[i].buffer);
 			draw_set_mapped_vertex_buffer(draw, i, NULL);
 		}
 	}
 	if (indexBuffer) {
-		pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
+		pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
 		draw_set_mapped_element_buffer(draw, 0, NULL);
 	}
 

src/gallium/drivers/nv10/nv10_context.c

@@ -1,6 +1,6 @@
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv10_context.h"
 #include "nv10_screen.h"

src/gallium/drivers/nv10/nv10_miptree.c

@@ -65,7 +65,7 @@ nv10_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 
 	nv10_miptree_layout(mt);
 
-	mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+	mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
 					   mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);

src/gallium/drivers/nv10/nv10_prim_vbuf.c

@@ -40,7 +40,7 @@
 
 #include "pipe/p_debug.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv10_context.h"
 #include "nv10_state.h"
@@ -111,11 +111,11 @@ nv10_vbuf_render_allocate_vertices( struct vbuf_render *render,
 	size_t size = (size_t)vertex_size * (size_t)nr_vertices;
 
 	assert(!nv10_render->buffer);
-	nv10_render->buffer = winsys->_buffer_create(winsys, 64, PIPE_BUFFER_USAGE_VERTEX, size);
+	nv10_render->buffer = winsys->buffer_create(winsys, 64, PIPE_BUFFER_USAGE_VERTEX, size);
 
 	nv10->dirty |= NV10_NEW_VTXARRAYS;
 
-	return winsys->_buffer_map(winsys, 
+	return winsys->buffer_map(winsys, 
 			nv10_render->buffer, 
 			PIPE_BUFFER_USAGE_CPU_WRITE);
 }
@@ -187,7 +187,7 @@ nv10_vbuf_render_release_vertices( struct vbuf_render *render,
 	struct pipe_screen *pscreen = &nv10->screen->pipe;
 
 	assert(nv10_render->buffer);
-	winsys->_buffer_unmap(winsys, nv10_render->buffer);
+	winsys->buffer_unmap(winsys, nv10_render->buffer);
 	pipe_buffer_reference(pscreen, &nv10_render->buffer, NULL);
 }
 

src/gallium/drivers/nv10/nv10_screen.c

@@ -122,7 +122,7 @@ nv10_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
 	struct pipe_winsys *ws = screen->winsys;
 	void *map;
 
-	map = ws->_buffer_map(ws, surface->buffer, flags);
+	map = ws->buffer_map(ws, surface->buffer, flags);
 	if (!map)
 		return NULL;
 
@@ -134,7 +134,7 @@ nv10_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
 {
 	struct pipe_winsys *ws = screen->winsys;
 
-	ws->_buffer_unmap(ws, surface->buffer);
+	ws->buffer_unmap(ws, surface->buffer);
 }
 
 static void

src/gallium/drivers/nv10/nv10_state.c

@@ -468,12 +468,12 @@ nv10_set_constant_buffer(struct pipe_context *pipe, uint shader, uint index,
 	if (buf) {
 		void *mapped;
 		if (buf->buffer && buf->buffer->size &&
-                    (mapped = ws->_buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
+                    (mapped = ws->buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
 		{
 			memcpy(nv10->constbuf[shader], mapped, buf->buffer->size);
 			nv10->constbuf_nr[shader] =
 				buf->buffer->size / (4 * sizeof(float));
-			ws->_buffer_unmap(ws, buf->buffer);
+			ws->buffer_unmap(ws, buf->buffer);
 		}
 	}
 }

src/gallium/drivers/nv10/nv10_surface.c

@@ -28,7 +28,7 @@
 
 #include "nv10_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_tile.h"
 

src/gallium/drivers/nv10/nv10_vbo.c

@@ -25,7 +25,7 @@ boolean nv10_draw_elements( struct pipe_context *pipe,
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv10->vtxbuf[i].buffer) {
 			void *buf
-				= pipe->winsys->_buffer_map(pipe->winsys,
+				= pipe->winsys->buffer_map(pipe->winsys,
 						nv10->vtxbuf[i].buffer,
 						PIPE_BUFFER_USAGE_CPU_READ);
 			draw_set_mapped_vertex_buffer(draw, i, buf);
@@ -34,7 +34,7 @@ boolean nv10_draw_elements( struct pipe_context *pipe,
 	/* Map index buffer, if present */
 	if (indexBuffer) {
 		void *mapped_indexes
-			= pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
+			= pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
 					PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
 	}
@@ -55,12 +55,12 @@ boolean nv10_draw_elements( struct pipe_context *pipe,
 	 */
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv10->vtxbuf[i].buffer) {
-			pipe->winsys->_buffer_unmap(pipe->winsys, nv10->vtxbuf[i].buffer);
+			pipe->winsys->buffer_unmap(pipe->winsys, nv10->vtxbuf[i].buffer);
 			draw_set_mapped_vertex_buffer(draw, i, NULL);
 		}
 	}
 	if (indexBuffer) {
-		pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
+		pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
 		draw_set_mapped_element_buffer(draw, 0, NULL);
 	}
 

src/gallium/drivers/nv20/nv20_context.c

@@ -1,6 +1,6 @@
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv20_context.h"
 #include "nv20_screen.h"

src/gallium/drivers/nv20/nv20_miptree.c

@@ -65,7 +65,7 @@ nv20_miptree_create(struct pipe_screen *screen, const struct pipe_texture *pt)
 
 	nv20_miptree_layout(mt);
 
-	mt->buffer = ws->_buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
+	mt->buffer = ws->buffer_create(ws, 256, PIPE_BUFFER_USAGE_PIXEL,
 					   mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);

src/gallium/drivers/nv20/nv20_prim_vbuf.c

@@ -40,7 +40,7 @@
 
 #include "pipe/p_debug.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv20_context.h"
 #include "nv20_state.h"
@@ -113,9 +113,9 @@ static void *
 nv20__allocate_pbuffer(struct nv20_vbuf_render *nv20_render, size_t size)
 {
 	struct pipe_winsys *winsys = nv20_render->nv20->pipe.winsys;
-	nv20_render->pbuffer = winsys->_buffer_create(winsys, 64,
+	nv20_render->pbuffer = winsys->buffer_create(winsys, 64,
 					PIPE_BUFFER_USAGE_VERTEX, size);
-	return winsys->_buffer_map(winsys,
+	return winsys->buffer_map(winsys,
 			nv20_render->pbuffer,
 			PIPE_BUFFER_USAGE_CPU_WRITE);
 }
@@ -334,7 +334,7 @@ nv20_vbuf_render_release_vertices( struct vbuf_render *render,
 	struct pipe_screen *pscreen = &nv20->screen->pipe;
 
 	if (nv20_render->pbuffer) {
-		winsys->_buffer_unmap(winsys, nv20_render->pbuffer);
+		winsys->buffer_unmap(winsys, nv20_render->pbuffer);
 		pipe_buffer_reference(pscreen, &nv20_render->pbuffer, NULL);
 	} else if (nv20_render->mbuffer) {
 		FREE(nv20_render->mbuffer);

src/gallium/drivers/nv20/nv20_screen.c

@@ -122,7 +122,7 @@ nv20_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
 	struct pipe_winsys *ws = screen->winsys;
 	void *map;
 
-	map = ws->_buffer_map(ws, surface->buffer, flags);
+	map = ws->buffer_map(ws, surface->buffer, flags);
 	if (!map)
 		return NULL;
 
@@ -134,7 +134,7 @@ nv20_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
 {
 	struct pipe_winsys *ws = screen->winsys;
 
-	ws->_buffer_unmap(ws, surface->buffer);
+	ws->buffer_unmap(ws, surface->buffer);
 }
 
 static void

src/gallium/drivers/nv20/nv20_state.c

@@ -461,12 +461,12 @@ nv20_set_constant_buffer(struct pipe_context *pipe, uint shader, uint index,
 	if (buf) {
 		void *mapped;
 		if (buf->buffer && buf->buffer->size &&
-                    (mapped = ws->_buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
+                    (mapped = ws->buffer_map(ws, buf->buffer, PIPE_BUFFER_USAGE_CPU_READ)))
 		{
 			memcpy(nv20->constbuf[shader], mapped, buf->buffer->size);
 			nv20->constbuf_nr[shader] =
 				buf->buffer->size / (4 * sizeof(float));
-			ws->_buffer_unmap(ws, buf->buffer);
+			ws->buffer_unmap(ws, buf->buffer);
 		}
 	}
 }

src/gallium/drivers/nv20/nv20_surface.c

@@ -28,7 +28,7 @@
 
 #include "nv20_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 #include "util/u_tile.h"
 

src/gallium/drivers/nv20/nv20_vbo.c

@@ -25,7 +25,7 @@ boolean nv20_draw_elements( struct pipe_context *pipe,
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv20->vtxbuf[i].buffer) {
 			void *buf
-				= pipe->winsys->_buffer_map(pipe->winsys,
+				= pipe->winsys->buffer_map(pipe->winsys,
 						nv20->vtxbuf[i].buffer,
 						PIPE_BUFFER_USAGE_CPU_READ);
 			draw_set_mapped_vertex_buffer(draw, i, buf);
@@ -34,7 +34,7 @@ boolean nv20_draw_elements( struct pipe_context *pipe,
 	/* Map index buffer, if present */
 	if (indexBuffer) {
 		void *mapped_indexes
-			= pipe->winsys->_buffer_map(pipe->winsys, indexBuffer,
+			= pipe->winsys->buffer_map(pipe->winsys, indexBuffer,
 					PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
 	}
@@ -55,12 +55,12 @@ boolean nv20_draw_elements( struct pipe_context *pipe,
 	 */
 	for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 		if (nv20->vtxbuf[i].buffer) {
-			pipe->winsys->_buffer_unmap(pipe->winsys, nv20->vtxbuf[i].buffer);
+			pipe->winsys->buffer_unmap(pipe->winsys, nv20->vtxbuf[i].buffer);
 			draw_set_mapped_vertex_buffer(draw, i, NULL);
 		}
 	}
 	if (indexBuffer) {
-		pipe->winsys->_buffer_unmap(pipe->winsys, indexBuffer);
+		pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer);
 		draw_set_mapped_element_buffer(draw, 0, NULL);
 	}
 

src/gallium/drivers/nv20/nv20_vertprog.c

@@ -749,7 +749,7 @@ nv20_vertprog_validate(struct nv20_context *nv20)
 		float *map = NULL;
 
 		if (constbuf) {
-			map = ws->_buffer_map(ws, constbuf,
+			map = ws->buffer_map(ws, constbuf,
 					     PIPE_BUFFER_USAGE_CPU_READ);
 		}
 
@@ -771,7 +771,7 @@ nv20_vertprog_validate(struct nv20_context *nv20)
 		}
 
 		if (constbuf) {
-			ws->_buffer_unmap(ws, constbuf);
+			ws->buffer_unmap(ws, constbuf);
 		}
 	}
 

src/gallium/drivers/nv30/nv30_context.c

@@ -1,6 +1,6 @@
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv30_context.h"
 #include "nv30_screen.h"

src/gallium/drivers/nv30/nv30_fragprog.c

@@ -803,7 +803,7 @@ nv30_fragprog_upload(struct nv30_context *nv30,
 	uint32_t *map;
 	int i;
 
-	map = ws->_buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+	map = ws->buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
 
 #if 0
 	for (i = 0; i < fp->insn_len; i++) {
@@ -825,7 +825,7 @@ nv30_fragprog_upload(struct nv30_context *nv30,
 		}
 	}
 
-	ws->_buffer_unmap(ws, fp->buffer);
+	ws->buffer_unmap(ws, fp->buffer);
 }
 
 static boolean
@@ -849,7 +849,7 @@ nv30_fragprog_validate(struct nv30_context *nv30)
 		return FALSE;
 	}
 
-	fp->buffer = ws->_buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+	fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
 	nv30_fragprog_upload(nv30, fp);
 
 	so = so_new(8, 1);
@@ -869,7 +869,7 @@ update_constants:
 	if (fp->nr_consts) {
 		float *map;
 		
-		map = ws->_buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
+		map = ws->buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
 		for (i = 0; i < fp->nr_consts; i++) {
 			struct nv30_fragment_program_data *fpd = &fp->consts[i];
 			uint32_t *p = &fp->insn[fpd->offset];
@@ -880,7 +880,7 @@ update_constants:
 			memcpy(p, cb, 4 * sizeof(float));
 			new_consts = TRUE;
 		}
-		ws->_buffer_unmap(ws, constbuf);
+		ws->buffer_unmap(ws, constbuf);
 
 		if (new_consts)
 			nv30_fragprog_upload(nv30, fp);

src/gallium/drivers/nv30/nv30_miptree.c

@@ -93,7 +93,7 @@ nv30_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 
 	nv30_miptree_layout(mt);
 
-	mt->buffer = ws->_buffer_create(ws, 256,
+	mt->buffer = ws->buffer_create(ws, 256,
 				       PIPE_BUFFER_USAGE_PIXEL |
 				       NOUVEAU_BUFFER_USAGE_TEXTURE,
 				       mt->total_size);

src/gallium/drivers/nv30/nv30_screen.c

@@ -161,7 +161,7 @@ nv30_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
 
 	assert(surface_to_map);
 
-	map = ws->_buffer_map(ws, surface_to_map->buffer, flags);
+	map = ws->buffer_map(ws, surface_to_map->buffer, flags);
 	if (!map)
 		return NULL;
 
@@ -189,7 +189,7 @@ nv30_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
 
 	assert(surface_to_unmap);
 
-	ws->_buffer_unmap(ws, surface_to_unmap->buffer);
+	ws->buffer_unmap(ws, surface_to_unmap->buffer);
 
 	if (surface_to_unmap != surface) {
 		struct nv30_screen *nvscreen = nv30_screen(screen);

src/gallium/drivers/nv30/nv30_surface.c

@@ -28,7 +28,7 @@
 
 #include "nv30_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 
 #include "util/u_tile.h"

src/gallium/drivers/nv30/nv30_vbo.c

@@ -116,7 +116,7 @@ nv30_vbo_static_attrib(struct nv30_context *nv30, struct nouveau_stateobj *so,
 	if (nv30_vbo_format_to_hw(ve->src_format, &type, &ncomp))
 		return FALSE;
 
-	map  = ws->_buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+	map  = ws->buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
 	map += vb->buffer_offset + ve->src_offset;
 
 	switch (type) {
@@ -148,17 +148,17 @@ nv30_vbo_static_attrib(struct nv30_context *nv30, struct nouveau_stateobj *so,
 			so_data  (so, fui(v[0]));
 			break;
 		default:
-			ws->_buffer_unmap(ws, vb->buffer);
+			ws->buffer_unmap(ws, vb->buffer);
 			return FALSE;
 		}
 	}
 		break;
 	default:
-		ws->_buffer_unmap(ws, vb->buffer);
+		ws->buffer_unmap(ws, vb->buffer);
 		return FALSE;
 	}
 
-	ws->_buffer_unmap(ws, vb->buffer);
+	ws->buffer_unmap(ws, vb->buffer);
 
 	return TRUE;
 }
@@ -371,7 +371,7 @@ nv30_draw_elements_inline(struct pipe_context *pipe,
 	struct pipe_winsys *ws = pipe->winsys;
 	void *map;
 
-	map = ws->_buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
+	map = ws->buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
 	if (!ib) {
 		NOUVEAU_ERR("failed mapping ib\n");
 		return FALSE;
@@ -392,7 +392,7 @@ nv30_draw_elements_inline(struct pipe_context *pipe,
 		break;
 	}
 
-	ws->_buffer_unmap(ws, ib);
+	ws->buffer_unmap(ws, ib);
 	return TRUE;
 }
 

src/gallium/drivers/nv30/nv30_vertprog.c

@@ -749,7 +749,7 @@ nv30_vertprog_validate(struct nv30_context *nv30)
 		float *map = NULL;
 
 		if (constbuf) {
-			map = ws->_buffer_map(ws, constbuf,
+			map = ws->buffer_map(ws, constbuf,
 					     PIPE_BUFFER_USAGE_CPU_READ);
 		}
 
@@ -771,7 +771,7 @@ nv30_vertprog_validate(struct nv30_context *nv30)
 		}
 
 		if (constbuf) {
-			ws->_buffer_unmap(ws, constbuf);
+			ws->buffer_unmap(ws, constbuf);
 		}
 	}
 

src/gallium/drivers/nv40/nv40_context.c

@@ -1,6 +1,6 @@
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv40_context.h"
 #include "nv40_screen.h"

src/gallium/drivers/nv40/nv40_draw.c

@@ -241,13 +241,13 @@ nv40_draw_elements_swtnl(struct pipe_context *pipe,
 	nv40_state_emit(nv40);
 
 	for (i = 0; i < nv40->vtxbuf_nr; i++) {
-		map = ws->_buffer_map(ws, nv40->vtxbuf[i].buffer,
+		map = ws->buffer_map(ws, nv40->vtxbuf[i].buffer,
                                       PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_vertex_buffer(nv40->draw, i, map);
 	}
 
 	if (idxbuf) {
-		map = ws->_buffer_map(ws, idxbuf, PIPE_BUFFER_USAGE_CPU_READ);
+		map = ws->buffer_map(ws, idxbuf, PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_element_buffer(nv40->draw, idxbuf_size, map);
 	} else {
 		draw_set_mapped_element_buffer(nv40->draw, 0, NULL);
@@ -256,7 +256,7 @@ nv40_draw_elements_swtnl(struct pipe_context *pipe,
 	if (nv40->constbuf[PIPE_SHADER_VERTEX]) {
 		const unsigned nr = nv40->constbuf_nr[PIPE_SHADER_VERTEX];
 
-		map = ws->_buffer_map(ws, nv40->constbuf[PIPE_SHADER_VERTEX],
+		map = ws->buffer_map(ws, nv40->constbuf[PIPE_SHADER_VERTEX],
 				     PIPE_BUFFER_USAGE_CPU_READ);
 		draw_set_mapped_constant_buffer(nv40->draw, map, nr);
 	}
@@ -264,13 +264,13 @@ nv40_draw_elements_swtnl(struct pipe_context *pipe,
 	draw_arrays(nv40->draw, mode, start, count);
 
 	for (i = 0; i < nv40->vtxbuf_nr; i++)
-		ws->_buffer_unmap(ws, nv40->vtxbuf[i].buffer);
+		ws->buffer_unmap(ws, nv40->vtxbuf[i].buffer);
 
 	if (idxbuf)
-		ws->_buffer_unmap(ws, idxbuf);
+		ws->buffer_unmap(ws, idxbuf);
 
 	if (nv40->constbuf[PIPE_SHADER_VERTEX])
-		ws->_buffer_unmap(ws, nv40->constbuf[PIPE_SHADER_VERTEX]);
+		ws->buffer_unmap(ws, nv40->constbuf[PIPE_SHADER_VERTEX]);
 
 	draw_flush(nv40->draw);
 	pipe->flush(pipe, 0, NULL);

src/gallium/drivers/nv40/nv40_fragprog.c

@@ -886,7 +886,7 @@ nv40_fragprog_upload(struct nv40_context *nv40,
 	uint32_t *map;
 	int i;
 
-	map = ws->_buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+	map = ws->buffer_map(ws, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
 
 #if 0
 	for (i = 0; i < fp->insn_len; i++) {
@@ -908,7 +908,7 @@ nv40_fragprog_upload(struct nv40_context *nv40,
 		}
 	}
 
-	ws->_buffer_unmap(ws, fp->buffer);
+	ws->buffer_unmap(ws, fp->buffer);
 }
 
 static boolean
@@ -932,7 +932,7 @@ nv40_fragprog_validate(struct nv40_context *nv40)
 		return FALSE;
 	}
 
-	fp->buffer = ws->_buffer_create(ws, 0x100, 0, fp->insn_len * 4);
+	fp->buffer = ws->buffer_create(ws, 0x100, 0, fp->insn_len * 4);
 	nv40_fragprog_upload(nv40, fp);
 
 	so = so_new(4, 1);
@@ -948,7 +948,7 @@ update_constants:
 	if (fp->nr_consts) {
 		float *map;
 		
-		map = ws->_buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
+		map = ws->buffer_map(ws, constbuf, PIPE_BUFFER_USAGE_CPU_READ);
 		for (i = 0; i < fp->nr_consts; i++) {
 			struct nv40_fragment_program_data *fpd = &fp->consts[i];
 			uint32_t *p = &fp->insn[fpd->offset];
@@ -959,7 +959,7 @@ update_constants:
 			memcpy(p, cb, 4 * sizeof(float));
 			new_consts = TRUE;
 		}
-		ws->_buffer_unmap(ws, constbuf);
+		ws->buffer_unmap(ws, constbuf);
 
 		if (new_consts)
 			nv40_fragprog_upload(nv40, fp);

src/gallium/drivers/nv40/nv40_miptree.c

@@ -97,7 +97,7 @@ nv40_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 
 	nv40_miptree_layout(mt);
 
-	mt->buffer = ws->_buffer_create(ws, 256, buf_usage, mt->total_size);
+	mt->buffer = ws->buffer_create(ws, 256, buf_usage, mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
 		return NULL;

src/gallium/drivers/nv40/nv40_screen.c

@@ -170,7 +170,7 @@ nv40_surface_map(struct pipe_screen *screen, struct pipe_surface *surface,
 
 	assert(surface_to_map);
 
-	map = ws->_buffer_map(ws, surface_to_map->buffer, flags);
+	map = ws->buffer_map(ws, surface_to_map->buffer, flags);
 	if (!map)
 		return NULL;
 
@@ -198,7 +198,7 @@ nv40_surface_unmap(struct pipe_screen *screen, struct pipe_surface *surface)
 
 	assert(surface_to_unmap);
 
-	ws->_buffer_unmap(ws, surface_to_unmap->buffer);
+	ws->buffer_unmap(ws, surface_to_unmap->buffer);
 
 	if (surface_to_unmap != surface) {
 		struct nv40_screen *nvscreen = nv40_screen(screen);

src/gallium/drivers/nv40/nv40_surface.c

@@ -28,7 +28,7 @@
 
 #include "nv40_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 
 #include "util/u_tile.h"

src/gallium/drivers/nv40/nv40_vbo.c

@@ -116,7 +116,7 @@ nv40_vbo_static_attrib(struct nv40_context *nv40, struct nouveau_stateobj *so,
 	if (nv40_vbo_format_to_hw(ve->src_format, &type, &ncomp))
 		return FALSE;
 
-	map  = ws->_buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+	map  = ws->buffer_map(ws, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
 	map += vb->buffer_offset + ve->src_offset;
 
 	switch (type) {
@@ -148,17 +148,17 @@ nv40_vbo_static_attrib(struct nv40_context *nv40, struct nouveau_stateobj *so,
 			so_data  (so, fui(v[0]));
 			break;
 		default:
-			ws->_buffer_unmap(ws, vb->buffer);
+			ws->buffer_unmap(ws, vb->buffer);
 			return FALSE;
 		}
 	}
 		break;
 	default:
-		ws->_buffer_unmap(ws, vb->buffer);
+		ws->buffer_unmap(ws, vb->buffer);
 		return FALSE;
 	}
 
-	ws->_buffer_unmap(ws, vb->buffer);
+	ws->buffer_unmap(ws, vb->buffer);
 
 	return TRUE;
 }
@@ -370,7 +370,7 @@ nv40_draw_elements_inline(struct pipe_context *pipe,
 	struct pipe_winsys *ws = pipe->winsys;
 	void *map;
 
-	map = ws->_buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
+	map = ws->buffer_map(ws, ib, PIPE_BUFFER_USAGE_CPU_READ);
 	if (!ib) {
 		NOUVEAU_ERR("failed mapping ib\n");
 		return FALSE;
@@ -391,7 +391,7 @@ nv40_draw_elements_inline(struct pipe_context *pipe,
 		break;
 	}
 
-	ws->_buffer_unmap(ws, ib);
+	ws->buffer_unmap(ws, ib);
 	return TRUE;
 }
 

src/gallium/drivers/nv40/nv40_vertprog.c

@@ -980,7 +980,7 @@ check_gpu_resources:
 		float *map = NULL;
 
 		if (constbuf) {
-			map = ws->_buffer_map(ws, constbuf,
+			map = ws->buffer_map(ws, constbuf,
 					     PIPE_BUFFER_USAGE_CPU_READ);
 		}
 
@@ -1002,7 +1002,7 @@ check_gpu_resources:
 		}
 
 		if (constbuf)
-			ws->_buffer_unmap(ws, constbuf);
+			ws->buffer_unmap(ws, constbuf);
 	}
 
 	/* Upload vtxprog */

src/gallium/drivers/nv50/nv50_context.c

@@ -22,7 +22,7 @@
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 #include "nv50_context.h"
 #include "nv50_screen.h"

src/gallium/drivers/nv50/nv50_miptree.c

@@ -88,14 +88,14 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 			size  = align(size, 64);
 			size *= align(pt->height[l], 8) * pt->block.size;
 
-			lvl->image[i] = ws->_buffer_create(ws, 256, 0, size);
+			lvl->image[i] = ws->buffer_create(ws, 256, 0, size);
 			lvl->image_offset[i] = mt->total_size;
 
 			mt->total_size += size;
 		}
 	}
 
-	mt->buffer = ws->_buffer_create(ws, 256, usage, mt->total_size);
+	mt->buffer = ws->buffer_create(ws, 256, usage, mt->total_size);
 	if (!mt->buffer) {
 		FREE(mt);
 		return NULL;

src/gallium/drivers/nv50/nv50_program.c

@@ -1581,11 +1581,11 @@ nv50_program_validate_data(struct nv50_context *nv50, struct nv50_program *p)
 	}
 
 	if (p->param_nr) {
-		float *map = ws->_buffer_map(ws, nv50->constbuf[p->type],
+		float *map = ws->buffer_map(ws, nv50->constbuf[p->type],
 					    PIPE_BUFFER_USAGE_CPU_READ);
 		nv50_program_upload_data(nv50, map, p->data->start,
 					 p->param_nr);
-		ws->_buffer_unmap(ws, nv50->constbuf[p->type]);
+		ws->buffer_unmap(ws, nv50->constbuf[p->type]);
 	}
 
 	if (p->immd_nr) {
@@ -1606,7 +1606,7 @@ nv50_program_validate_code(struct nv50_context *nv50, struct nv50_program *p)
 	boolean upload = FALSE;
 
 	if (!p->buffer) {
-		p->buffer = ws->_buffer_create(ws, 0x100, 0, p->exec_size * 4);
+		p->buffer = ws->buffer_create(ws, 0x100, 0, p->exec_size * 4);
 		upload = TRUE;
 	}
 

src/gallium/drivers/nv50/nv50_query.c

@@ -47,7 +47,7 @@ nv50_query_create(struct pipe_context *pipe, unsigned type)
 	assert (q->type == PIPE_QUERY_OCCLUSION_COUNTER);
 	q->type = type;
 
-	q->buffer = ws->_buffer_create(ws, 256, 0, 16);
+	q->buffer = ws->buffer_create(ws, 256, 0, 16);
 	if (!q->buffer) {
 		FREE(q);
 		return NULL;
@@ -107,11 +107,11 @@ nv50_query_result(struct pipe_context *pipe, struct pipe_query *pq,
 	 */
 
 	if (!q->ready) {
-		uint32_t *map = ws->_buffer_map(ws, q->buffer,
+		uint32_t *map = ws->buffer_map(ws, q->buffer,
 					       PIPE_BUFFER_USAGE_CPU_READ);
 		q->result = map[1];
 		q->ready = TRUE;
-		ws->_buffer_unmap(ws, q->buffer);
+		ws->buffer_unmap(ws, q->buffer);
 	}
 
 	*result = q->result;

src/gallium/drivers/nv50/nv50_screen.c

@@ -242,7 +242,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 	so_data  (so, 8);
 
 	/* Shared constant buffer */
-	screen->constbuf = ws->_buffer_create(ws, 0, 0, 128 * 4 * 4);
+	screen->constbuf = ws->buffer_create(ws, 0, 0, 128 * 4 * 4);
 	if (nvws->res_init(&screen->vp_data_heap, 0, 128)) {
 		NOUVEAU_ERR("Error initialising constant buffer\n");
 		nv50_screen_destroy(&screen->pipe);
@@ -261,7 +261,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 	 * blocks.  At some point we *may* want to go the NVIDIA way of doing
 	 * things?
 	 */
-	screen->tic = ws->_buffer_create(ws, 0, 0, 32 * 8 * 4);
+	screen->tic = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
 	so_method(so, screen->tesla, 0x1280, 3);
 	so_reloc (so, screen->tic, 0, NOUVEAU_BO_VRAM |
 		  NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);
@@ -275,7 +275,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_winsys *nvws)
 		  NOUVEAU_BO_RD | NOUVEAU_BO_LOW, 0, 0);
 	so_data  (so, 0x00000800);
 
-	screen->tsc = ws->_buffer_create(ws, 0, 0, 32 * 8 * 4);
+	screen->tsc = ws->buffer_create(ws, 0, 0, 32 * 8 * 4);
 	so_method(so, screen->tesla, 0x1280, 3);
 	so_reloc (so, screen->tsc, 0, NOUVEAU_BO_VRAM |
 		  NOUVEAU_BO_RD | NOUVEAU_BO_HIGH, 0, 0);

src/gallium/drivers/nv50/nv50_surface.c

@@ -22,7 +22,7 @@
 
 #include "nv50_context.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 
 #include "util/u_tile.h"
@@ -65,7 +65,7 @@ nv50_surface_map(struct pipe_screen *screen, struct pipe_surface *ps,
 {
 	struct pipe_winsys *ws = screen->winsys;
 
-	return ws->_buffer_map(ws, ps->buffer, flags);
+	return ws->buffer_map(ws, ps->buffer, flags);
 }
 
 static void
@@ -73,7 +73,7 @@ nv50_surface_unmap(struct pipe_screen *pscreen, struct pipe_surface *ps)
 {
 	struct pipe_winsys *ws = pscreen->winsys;
 
-	ws->_buffer_unmap(ws, ps->buffer);
+	ws->buffer_unmap(ws, ps->buffer);
 }
 
 void

src/gallium/drivers/nv50/nv50_vbo.c

@@ -153,7 +153,7 @@ nv50_draw_elements(struct pipe_context *pipe,
 {
 	struct nv50_context *nv50 = nv50_context(pipe);
 	struct pipe_winsys *ws = pipe->winsys;
-	void *map = ws->_buffer_map(ws, indexBuffer, PIPE_BUFFER_USAGE_CPU_READ);
+	void *map = ws->buffer_map(ws, indexBuffer, PIPE_BUFFER_USAGE_CPU_READ);
 
 	nv50_state_validate(nv50);
 

src/gallium/drivers/softpipe/sp_draw_arrays.c

@@ -33,7 +33,7 @@
 
 #include "pipe/p_defines.h"
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_inlines.h"
 
 #include "sp_context.h"
@@ -50,7 +50,7 @@ softpipe_map_constant_buffers(struct softpipe_context *sp)
    uint i;
    for (i = 0; i < PIPE_SHADER_TYPES; i++) {
       if (sp->constants[i].buffer && sp->constants[i].buffer->size)
-         sp->mapped_constants[i] = ws->_buffer_map(ws, sp->constants[i].buffer,
+         sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer,
                                                   PIPE_BUFFER_USAGE_CPU_READ);
    }
 
@@ -74,7 +74,7 @@ softpipe_unmap_constant_buffers(struct softpipe_context *sp)
 
    for (i = 0; i < 2; i++) {
       if (sp->constants[i].buffer && sp->constants[i].buffer->size)
-         ws->_buffer_unmap(ws, sp->constants[i].buffer);
+         ws->buffer_unmap(ws, sp->constants[i].buffer);
       sp->mapped_constants[i] = NULL;
    }
 }

src/gallium/drivers/softpipe/sp_screen.c

@@ -27,7 +27,7 @@
 
 
 #include "util/u_memory.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_screen.h"
 

src/gallium/drivers/softpipe/sp_state_fs.c

@@ -32,7 +32,7 @@
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_shader_tokens.h"
 #include "draw/draw_context.h"
 #include "tgsi/tgsi_dump.h"

src/gallium/drivers/softpipe/sp_texture.c

@@ -33,7 +33,7 @@
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_inlines.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
@@ -87,7 +87,7 @@ softpipe_texture_layout(struct pipe_screen *screen,
       depth = minify(depth);
    }
 
-   spt->buffer = ws->_buffer_create(ws, 32,
+   spt->buffer = ws->buffer_create(ws, 32,
                                    PIPE_BUFFER_USAGE_PIXEL,
                                    buffer_size);
 
@@ -105,7 +105,7 @@ softpipe_displaytarget_layout(struct pipe_screen *screen,
    spt->base.nblocksx[0] = pf_get_nblocksx(&spt->base.block, spt->base.width[0]);  
    spt->base.nblocksy[0] = pf_get_nblocksy(&spt->base.block, spt->base.height[0]);  
 
-   spt->buffer = ws->_surface_buffer_create( ws, 
+   spt->buffer = ws->surface_buffer_create( ws, 
                                             spt->base.width[0], 
                                             spt->base.height[0],
                                             spt->base.format,

src/gallium/drivers/trace/tr_winsys.c

@@ -118,7 +118,7 @@ trace_winsys_surface_buffer_create(struct pipe_winsys *_winsys,
    trace_dump_arg(format, format);
    trace_dump_arg(uint, usage);
 
-   result = winsys->_surface_buffer_create(winsys,
+   result = winsys->surface_buffer_create(winsys,
                                           width, height,
                                           format,
                                           usage,
@@ -153,7 +153,7 @@ trace_winsys_buffer_create(struct pipe_winsys *_winsys,
    trace_dump_arg(uint, usage);
    trace_dump_arg(uint, size);
 
-   buffer = winsys->_buffer_create(winsys, alignment, usage, size);
+   buffer = winsys->buffer_create(winsys, alignment, usage, size);
    
    trace_dump_ret(ptr, buffer);
    
@@ -162,10 +162,10 @@ trace_winsys_buffer_create(struct pipe_winsys *_winsys,
    /* Zero the buffer to avoid dumping uninitialized memory */
    if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
       void *map;
-      map = winsys->_buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+      map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
       if(map) {
          memset(map, 0, buffer->size);
-         winsys->_buffer_unmap(winsys, buffer);
+         winsys->buffer_unmap(winsys, buffer);
       }
    }
    
@@ -190,7 +190,7 @@ trace_winsys_user_buffer_create(struct pipe_winsys *_winsys,
    trace_dump_arg_end();
    trace_dump_arg(uint, size);
 
-   result = winsys->_user_buffer_create(winsys, data, size);
+   result = winsys->user_buffer_create(winsys, data, size);
    
    trace_dump_ret(ptr, result);
    
@@ -216,7 +216,7 @@ trace_winsys_user_buffer_update(struct pipe_winsys *_winsys,
    const void *map;
    
    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
-      map = winsys->_buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
+      map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_READ);
       if(map) {
          trace_dump_call_begin("pipe_winsys", "buffer_write");
          
@@ -234,7 +234,7 @@ trace_winsys_user_buffer_update(struct pipe_winsys *_winsys,
       
          trace_dump_call_end();
          
-         winsys->_buffer_unmap(winsys, buffer);
+         winsys->buffer_unmap(winsys, buffer);
       }
    }
 }
@@ -249,7 +249,7 @@ trace_winsys_buffer_map(struct pipe_winsys *_winsys,
    struct pipe_winsys *winsys = tr_ws->winsys;
    void *map;
    
-   map = winsys->_buffer_map(winsys, buffer, usage);
+   map = winsys->buffer_map(winsys, buffer, usage);
    if(map) {
       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
          assert(!hash_table_get(tr_ws->buffer_maps, buffer));
@@ -290,7 +290,7 @@ trace_winsys_buffer_unmap(struct pipe_winsys *_winsys,
       hash_table_remove(tr_ws->buffer_maps, buffer);
    }
    
-   winsys->_buffer_unmap(winsys, buffer);
+   winsys->buffer_unmap(winsys, buffer);
 }
 
 
@@ -306,7 +306,7 @@ trace_winsys_buffer_destroy(struct pipe_winsys *_winsys,
    trace_dump_arg(ptr, winsys);
    trace_dump_arg(ptr, buffer);
 
-   winsys->_buffer_destroy(winsys, buffer);
+   winsys->buffer_destroy(winsys, buffer);
    
    trace_dump_call_end();
 }
@@ -420,12 +420,12 @@ trace_winsys_create(struct pipe_winsys *winsys)
    tr_ws->base.destroy = trace_winsys_destroy;
    tr_ws->base.get_name = trace_winsys_get_name;
    tr_ws->base.flush_frontbuffer = trace_winsys_flush_frontbuffer;
-   tr_ws->base._surface_buffer_create = trace_winsys_surface_buffer_create;
-   tr_ws->base._buffer_create = trace_winsys_buffer_create;
-   tr_ws->base._user_buffer_create = trace_winsys_user_buffer_create;
-   tr_ws->base._buffer_map = trace_winsys_buffer_map;
-   tr_ws->base._buffer_unmap = trace_winsys_buffer_unmap;
-   tr_ws->base._buffer_destroy = trace_winsys_buffer_destroy;
+   tr_ws->base.surface_buffer_create = trace_winsys_surface_buffer_create;
+   tr_ws->base.buffer_create = trace_winsys_buffer_create;
+   tr_ws->base.user_buffer_create = trace_winsys_user_buffer_create;
+   tr_ws->base.buffer_map = trace_winsys_buffer_map;
+   tr_ws->base.buffer_unmap = trace_winsys_buffer_unmap;
+   tr_ws->base.buffer_destroy = trace_winsys_buffer_destroy;
    tr_ws->base.fence_reference = trace_winsys_fence_reference;
    tr_ws->base.fence_signalled = trace_winsys_fence_signalled;
    tr_ws->base.fence_finish = trace_winsys_fence_finish;

src/gallium/drivers/trace/tr_winsys.h

@@ -31,7 +31,7 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_debug.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 
 /**

src/gallium/include/pipe/internal/p_winsys_screen.h

@@ -36,7 +36,7 @@
 #define P_WINSYS_H
 
 
-#include "p_format.h"
+#include "pipe/p_format.h"
 
 
 #ifdef __cplusplus
@@ -90,7 +90,7 @@ struct pipe_winsys
     * alignment indicates the client's alignment requirements, eg for
     * SSE instructions.
     */
-   struct pipe_buffer *(*_buffer_create)( struct pipe_winsys *ws, 
+   struct pipe_buffer *(*buffer_create)( struct pipe_winsys *ws, 
                                          unsigned alignment, 
                                          unsigned usage,
                                          unsigned size );
@@ -116,7 +116,7 @@ struct pipe_winsys
     * Note that ptr may be accessed at any time upto the time when the
     * buffer is destroyed, so the data must not be freed before then.
     */
-   struct pipe_buffer *(*_user_buffer_create)(struct pipe_winsys *ws, 
+   struct pipe_buffer *(*user_buffer_create)(struct pipe_winsys *ws, 
                                                     void *ptr,
                                                     unsigned bytes);
 
@@ -131,7 +131,7 @@ struct pipe_winsys
     * with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET flag  to get the underlying 
     * buffer storage.
     */
-   struct pipe_buffer *(*_surface_buffer_create)(struct pipe_winsys *ws,
+   struct pipe_buffer *(*surface_buffer_create)(struct pipe_winsys *ws,
 						unsigned width, unsigned height,
 						enum pipe_format format,
 						unsigned usage,
@@ -142,14 +142,14 @@ struct pipe_winsys
     * Map the entire data store of a buffer object into the client's address.
     * flags is bitmask of PIPE_BUFFER_USAGE_CPU_READ/WRITE flags. 
     */
-   void *(*_buffer_map)( struct pipe_winsys *ws, 
+   void *(*buffer_map)( struct pipe_winsys *ws, 
 			struct pipe_buffer *buf,
 			unsigned usage );
    
-   void (*_buffer_unmap)( struct pipe_winsys *ws, 
+   void (*buffer_unmap)( struct pipe_winsys *ws, 
 			 struct pipe_buffer *buf );
 
-   void (*_buffer_destroy)( struct pipe_winsys *ws,
+   void (*buffer_destroy)( struct pipe_winsys *ws,
 			   struct pipe_buffer *buf );
 
 
@@ -178,7 +178,6 @@ struct pipe_winsys
 
 };
 
-
 #ifdef __cplusplus
 }
 #endif

src/gallium/include/pipe/p_inlines.h

@@ -31,7 +31,6 @@
 #include "p_context.h"
 #include "p_defines.h"
 #include "p_screen.h"
-#include "p_winsys.h"
 
 
 #ifdef __cplusplus
@@ -129,26 +128,20 @@ pipe_texture_release(struct pipe_texture **ptr)
 
 
 /**
- * Convenience wrappers for winsys buffer functions.
+ * Convenience wrappers for screen buffer functions.
  */
 
 static INLINE struct pipe_buffer *
 pipe_buffer_create( struct pipe_screen *screen,
                     unsigned alignment, unsigned usage, unsigned size )
 {
-   if (screen->buffer_create)
    return screen->buffer_create(screen, alignment, usage, size);
-   else
-      return screen->winsys->_buffer_create(screen->winsys, alignment, usage, size);
 }
 
 static INLINE struct pipe_buffer *
 pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size )
 {
-   if (screen->user_buffer_create)
    return screen->user_buffer_create(screen, ptr, size);
-   else
-      return screen->winsys->_user_buffer_create(screen->winsys, ptr, size);
 }
 
 static INLINE void *
@@ -156,20 +149,14 @@ pipe_buffer_map(struct pipe_screen *screen,
                 struct pipe_buffer *buf,
                 unsigned usage)
 {
-   if (screen->buffer_map)
    return screen->buffer_map(screen, buf, usage);
-   else
-      return screen->winsys->_buffer_map(screen->winsys, buf, usage);
 }
 
 static INLINE void
 pipe_buffer_unmap(struct pipe_screen *screen,
                   struct pipe_buffer *buf)
 {
-   if (screen->buffer_unmap)
    screen->buffer_unmap(screen, buf);
-   else
-      screen->winsys->_buffer_unmap(screen->winsys, buf);
 }
 
 /* XXX: thread safety issues!
@@ -187,10 +174,7 @@ pipe_buffer_reference(struct pipe_screen *screen,
    if (*ptr) {
       assert((*ptr)->refcount);
       if(--(*ptr)->refcount == 0) {
-         if (screen->buffer_destroy)
          screen->buffer_destroy( screen, *ptr );
-         else
-            screen->winsys->_buffer_destroy( screen->winsys, *ptr );
       }
    }
 

src/gallium/include/pipe/p_screen.h

@@ -48,6 +48,8 @@ extern "C" {
 #endif
 
 
+/** Opaque type */
+struct pipe_fence_handle;
 
 /**
  * Gallium screen/adapter context.  Basically everything
@@ -196,6 +198,41 @@ struct pipe_screen {
 
    void (*buffer_destroy)( struct pipe_screen *screen,
 			   struct pipe_buffer *buf );
+
+
+   /**
+    * Do any special operations to ensure frontbuffer contents are
+    * displayed, eg copy fake frontbuffer.
+    */
+   void (*flush_frontbuffer)( struct pipe_screen *screen,
+                              struct pipe_surface *surf,
+                              void *context_private );
+
+
+
+   /** Set ptr = fence, with reference counting */
+   void (*fence_reference)( struct pipe_screen *screen,
+                            struct pipe_fence_handle **ptr,
+                            struct pipe_fence_handle *fence );
+
+   /**
+    * Checks whether the fence has been signalled.
+    * \param flags  driver-specific meaning
+    * \return zero on success.
+    */
+   int (*fence_signalled)( struct pipe_screen *screen,
+                           struct pipe_fence_handle *fence,
+                           unsigned flag );
+
+   /**
+    * Wait for the fence to finish.
+    * \param flags  driver-specific meaning
+    * \return zero on success.
+    */
+   int (*fence_finish)( struct pipe_screen *screen,
+                        struct pipe_fence_handle *fence,
+                        unsigned flag );
+
 };
 
 

src/gallium/state_trackers/egl/egl_context.c

@@ -10,7 +10,6 @@
 
 #include "pipe/p_context.h"
 #include "pipe/p_screen.h"
-#include "pipe/p_winsys.h"
 
 #include "state_tracker/st_public.h"
 #include "state_tracker/drm_api.h"

src/gallium/state_trackers/egl/egl_tracker.c

@@ -10,7 +10,7 @@
 #include "state_tracker/drm_api.h"
 
 #include "pipe/p_screen.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 
 /** HACK */
 void* driDriverAPI;

src/gallium/state_trackers/g3dvl/vl_basic_csc.c

@@ -2,7 +2,6 @@
 #include "vl_basic_csc.h"
 #include <assert.h>
 #include <pipe/p_context.h>
-#include <pipe/p_winsys.h>
 #include <pipe/p_state.h>
 #include <pipe/p_inlines.h>
 #include <tgsi/tgsi_parse.h>

src/gallium/state_trackers/g3dvl/vl_r16snorm_mc_buf.c

@@ -2,7 +2,6 @@
 #include "vl_r16snorm_mc_buf.h"
 #include <assert.h>
 #include <pipe/p_context.h>
-#include <pipe/p_winsys.h>
 #include <pipe/p_screen.h>
 #include <pipe/p_state.h>
 #include <pipe/p_inlines.h>
@@ -649,9 +648,9 @@ static int vlFlush
 
 	pipe->set_framebuffer_state(pipe, &mc->render_target);
 	pipe->set_viewport_state(pipe, &mc->viewport);
-	vs_consts = pipe->winsys->buffer_map
+	vs_consts = pipe_buffer_map
 	(
-		pipe->winsys,
+		pipe->screen,
 		mc->vs_const_buf.buffer,
 		PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
 	);

src/gallium/state_trackers/python/st_device.c

@@ -26,7 +26,7 @@
  **************************************************************************/
 
 
-#include "pipe/p_winsys.h"
+#include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "pipe/p_shader_tokens.h"
 #include "pipe/p_inlines.h"

src/gallium/state_trackers/python/st_softpipe_winsys.c

@@ -36,7 +36,7 @@
  */
 
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"/* port to just p_screen */
 #include "pipe/p_format.h"
 #include "pipe/p_context.h"
 #include "pipe/p_inlines.h"

src/gallium/winsys/drm/intel/common/intel_be_device.c

@@ -10,7 +10,7 @@
 #include "ws_dri_bufpool.h"
 #include "ws_dri_fencemgr.h"
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_state.h"
 #include "pipe/p_inlines.h"

src/gallium/winsys/drm/intel/common/intel_be_device.h

@@ -1,7 +1,7 @@
 #ifndef INTEL_DRM_DEVICE_H
 #define INTEL_DRM_DEVICE_H
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_context.h"
 
 /*

src/gallium/winsys/drm/intel/gem/intel_be_device.c

@@ -1,7 +1,7 @@
 
 #include "intel_be_device.h"
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_state.h"
 #include "pipe/p_inlines.h"

src/gallium/winsys/drm/intel/gem/intel_be_device.h

@@ -2,7 +2,7 @@
 #ifndef INTEL_DRM_DEVICE_H
 #define INTEL_DRM_DEVICE_H
 
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_context.h"
 
 #include "drm.h"

src/gallium/winsys/drm/nouveau/common/nouveau_winsys_pipe.c

@@ -1,4 +1,4 @@
-#include <pipe/p_winsys.h>
+#include "pipe/internal/p_winsys_screen.h"
 #include <pipe/p_defines.h>
 #include <pipe/p_inlines.h>
 #include <util/u_memory.h>

src/gallium/winsys/drm/nouveau/common/nouveau_winsys_pipe.h

@@ -2,7 +2,7 @@
 #define NOUVEAU_PIPE_WINSYS_H
 
 #include "pipe/p_context.h"
-#include "pipe/p_winsys.h"
+#include "pipe/internal/p_winsys_screen.h"
 #include "nouveau_context.h"
 
 struct nouveau_pipe_buffer {

src/gallium/winsys/drm/nouveau/common/nouveau_winsys_softpipe.c

@@ -29,7 +29,7 @@
  * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  */
 
-#include <pipe/p_winsys.h>
+#include "pipe/internal/p_winsys_screen.h"
 #include <pipe/p_screen.h>
 #include <pipe/p_defines.h>
 #include <pipe/p_format.h>