Merge commit 'eee/mesa-es' into android

11 files changed, 1922 insertions, 0 deletions

diff --git a/src/gallium/drivers/identity/Makefile b/src/gallium/drivers/identity/Makefile
new file mode 100644
index 0000000000..e32b9102e5
--- /dev/null
+++ b/src/gallium/drivers/identity/Makefile
@@ -0,0 +1,12 @@
+TOP = ../../../..
+include $(TOP)/configs/current
+
+LIBNAME = identity
+
+C_SOURCES = \
+	id_objects.c \
+	id_context.c \
+	id_screen.c \
+	id_drm.c
+
+include ../../Makefile.template
diff --git a/src/gallium/drivers/identity/SConscript b/src/gallium/drivers/identity/SConscript
new file mode 100644
index 0000000000..7f079dd0a8
--- /dev/null
+++ b/src/gallium/drivers/identity/SConscript
@@ -0,0 +1,13 @@
+Import('*')
+
+env = env.Clone()
+
+identity = env.ConvenienceLibrary(
+	target = 'identity',
+	source = [
+		'id_screen.c',
+		'id_context.c',
+		'id_objects.c',
+	])
+
+Export('identity')
diff --git a/src/gallium/drivers/identity/id_context.c b/src/gallium/drivers/identity/id_context.c
new file mode 100644
index 0000000000..4e700089e3
--- /dev/null
+++ b/src/gallium/drivers/identity/id_context.c
@@ -0,0 +1,719 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
+#include "pipe/p_context.h"
+#include "util/u_memory.h"
+
+#include "id_public.h"
+#include "id_context.h"
+#include "id_objects.h"
+
+
+static void
+identity_destroy(struct pipe_context *_pipe)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->destroy(pipe);
+
+   free(id_pipe);
+}
+
+static void
+identity_set_edgeflags(struct pipe_context *_pipe,
+                       const unsigned *bitfield)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_edgeflags(pipe,
+                       bitfield);
+}
+
+static boolean
+identity_draw_arrays(struct pipe_context *_pipe,
+                     unsigned prim,
+                     unsigned start,
+                     unsigned count)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->draw_arrays(pipe,
+                            prim,
+                            start,
+                            count);
+}
+
+static boolean
+identity_draw_elements(struct pipe_context *_pipe,
+                       struct pipe_buffer *_indexBuffer,
+                       unsigned indexSize,
+                       unsigned prim,
+                       unsigned start,
+                       unsigned count)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_buffer *indexBuffer = id_buffer->buffer;
+
+   return pipe->draw_elements(pipe,
+                              indexBuffer,
+                              indexSize,
+                              prim,
+                              start,
+                              count);
+}
+
+static boolean
+identity_draw_range_elements(struct pipe_context *_pipe,
+                             struct pipe_buffer *_indexBuffer,
+                             unsigned indexSize,
+                             unsigned minIndex,
+                             unsigned maxIndex,
+                             unsigned mode,
+                             unsigned start,
+                             unsigned count)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_buffer *indexBuffer = id_buffer->buffer;
+
+   return pipe->draw_range_elements(pipe,
+                                    indexBuffer,
+                                    indexSize,
+                                    minIndex,
+                                    maxIndex,
+                                    mode,
+                                    start,
+                                    count);
+}
+
+static struct pipe_query *
+identity_create_query(struct pipe_context *_pipe,
+                      unsigned query_type)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_query(pipe,
+                             query_type);
+}
+
+static void
+identity_destroy_query(struct pipe_context *_pipe,
+                       struct pipe_query *query)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->destroy_query(pipe,
+                       query);
+}
+
+static void
+identity_begin_query(struct pipe_context *_pipe,
+                     struct pipe_query *query)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->begin_query(pipe,
+                     query);
+}
+
+static void
+identity_end_query(struct pipe_context *_pipe,
+                   struct pipe_query *query)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->end_query(pipe,
+                   query);
+}
+
+static boolean
+identity_get_query_result(struct pipe_context *_pipe,
+                          struct pipe_query *query,
+                          boolean wait,
+                          uint64_t *result)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->get_query_result(pipe,
+                                 query,
+                                 wait,
+                                 result);
+}
+
+static void *
+identity_create_blend_state(struct pipe_context *_pipe,
+                            const struct pipe_blend_state *blend)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_blend_state(pipe,
+                                   blend);
+}
+
+static void
+identity_bind_blend_state(struct pipe_context *_pipe,
+                          void *blend)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_blend_state(pipe,
+                              blend);
+}
+
+static void
+identity_delete_blend_state(struct pipe_context *_pipe,
+                            void *blend)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_blend_state(pipe,
+                            blend);
+}
+
+static void *
+identity_create_sampler_state(struct pipe_context *_pipe,
+                              const struct pipe_sampler_state *sampler)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_sampler_state(pipe,
+                                     sampler);
+}
+
+static void
+identity_bind_sampler_states(struct pipe_context *_pipe,
+                             unsigned num,
+                             void **samplers)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_sampler_states(pipe,
+                             num,
+                             samplers);
+}
+
+static void
+identity_delete_sampler_state(struct pipe_context *_pipe,
+                              void *sampler)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_sampler_state(pipe,
+                              sampler);
+}
+
+static void *
+identity_create_rasterizer_state(struct pipe_context *_pipe,
+                                 const struct pipe_rasterizer_state *rasterizer)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_rasterizer_state(pipe,
+                                        rasterizer);
+}
+
+static void
+identity_bind_rasterizer_state(struct pipe_context *_pipe,
+                               void *rasterizer)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_rasterizer_state(pipe,
+                               rasterizer);
+}
+
+static void
+identity_delete_rasterizer_state(struct pipe_context *_pipe,
+                                 void *rasterizer)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_rasterizer_state(pipe,
+                                 rasterizer);
+}
+
+static void *
+identity_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
+                                          const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_depth_stencil_alpha_state(pipe,
+                                                 depth_stencil_alpha);
+}
+
+static void
+identity_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
+                                        void *depth_stencil_alpha)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_depth_stencil_alpha_state(pipe,
+                                        depth_stencil_alpha);
+}
+
+static void
+identity_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
+                                          void *depth_stencil_alpha)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_depth_stencil_alpha_state(pipe,
+                                          depth_stencil_alpha);
+}
+
+static void *
+identity_create_fs_state(struct pipe_context *_pipe,
+                         const struct pipe_shader_state *fs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_fs_state(pipe,
+                                fs);
+}
+
+static void
+identity_bind_fs_state(struct pipe_context *_pipe,
+                       void *fs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_fs_state(pipe,
+                       fs);
+}
+
+static void
+identity_delete_fs_state(struct pipe_context *_pipe,
+                         void *fs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_fs_state(pipe,
+                         fs);
+}
+
+static void *
+identity_create_vs_state(struct pipe_context *_pipe,
+                         const struct pipe_shader_state *vs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   return pipe->create_vs_state(pipe,
+                                vs);
+}
+
+static void
+identity_bind_vs_state(struct pipe_context *_pipe,
+                       void *vs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->bind_vs_state(pipe,
+                       vs);
+}
+
+static void
+identity_delete_vs_state(struct pipe_context *_pipe,
+                         void *vs)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->delete_vs_state(pipe,
+                         vs);
+}
+
+static void
+identity_set_blend_color(struct pipe_context *_pipe,
+                         const struct pipe_blend_color *blend_color)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_blend_color(pipe,
+                         blend_color);
+}
+
+static void
+identity_set_clip_state(struct pipe_context *_pipe,
+                        const struct pipe_clip_state *clip)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_clip_state(pipe,
+                        clip);
+}
+
+static void
+identity_set_constant_buffer(struct pipe_context *_pipe,
+                             uint shader,
+                             uint index,
+                             const struct pipe_constant_buffer *_buffer)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_constant_buffer unwrapped_buffer;
+   struct pipe_constant_buffer *buffer = NULL;
+
+   /* unwrap the input state */
+   if (_buffer) {
+      unwrapped_buffer.buffer = identity_buffer_unwrap(_buffer->buffer);
+      buffer = &unwrapped_buffer;
+   }
+
+   pipe->set_constant_buffer(pipe,
+                             shader,
+                             index,
+                             buffer);
+}
+
+static void
+identity_set_framebuffer_state(struct pipe_context *_pipe,
+                               const struct pipe_framebuffer_state *_state)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_framebuffer_state unwrapped_state;
+   struct pipe_framebuffer_state *state = NULL;
+   unsigned i;
+
+   /* unwrap the input state */
+   if (_state) {
+      memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
+      for(i = 0; i < _state->nr_cbufs; i++)
+         unwrapped_state.cbufs[i] = identity_surface_unwrap(_state->cbufs[i]);
+      for (; i < PIPE_MAX_COLOR_BUFS; i++)
+         unwrapped_state.cbufs[i] = NULL;
+      unwrapped_state.zsbuf = identity_surface_unwrap(_state->zsbuf);
+      state = &unwrapped_state;
+   }
+
+   pipe->set_framebuffer_state(pipe,
+                               state);
+}
+
+static void
+identity_set_polygon_stipple(struct pipe_context *_pipe,
+                             const struct pipe_poly_stipple *poly_stipple)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_polygon_stipple(pipe,
+                             poly_stipple);
+}
+
+static void
+identity_set_scissor_state(struct pipe_context *_pipe,
+                           const struct pipe_scissor_state *scissor)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_scissor_state(pipe,
+                           scissor);
+}
+
+static void
+identity_set_viewport_state(struct pipe_context *_pipe,
+                            const struct pipe_viewport_state *viewport)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_viewport_state(pipe,
+                            viewport);
+}
+
+static void
+identity_set_sampler_textures(struct pipe_context *_pipe,
+                              unsigned num_textures,
+                              struct pipe_texture **_textures)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
+   struct pipe_texture **textures = NULL;
+   unsigned i;
+
+   if (_textures) {
+      for (i = 0; i < num_textures; i++)
+         unwrapped_textures[i] = identity_texture_unwrap(_textures[i]);
+      for (; i < PIPE_MAX_SAMPLERS; i++)
+         unwrapped_textures[i] = NULL;
+
+      textures = unwrapped_textures;
+   }
+
+   pipe->set_sampler_textures(pipe,
+                              num_textures,
+                              textures);
+}
+
+static void
+identity_set_vertex_buffers(struct pipe_context *_pipe,
+                            unsigned num_buffers,
+                            const struct pipe_vertex_buffer *_buffers)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
+   struct pipe_vertex_buffer *buffers = NULL;
+   unsigned i;
+
+   if (num_buffers) {
+      memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
+      for (i = 0; i < num_buffers; i++)
+         unwrapped_buffers[i].buffer = identity_buffer_unwrap(_buffers[i].buffer);
+      buffers = unwrapped_buffers;
+   }
+
+   pipe->set_vertex_buffers(pipe,
+                            num_buffers,
+                            buffers);
+}
+
+static void
+identity_set_vertex_elements(struct pipe_context *_pipe,
+                             unsigned num_elements,
+                             const struct pipe_vertex_element *vertex_elements)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->set_vertex_elements(pipe,
+                             num_elements,
+                             vertex_elements);
+}
+
+static void
+identity_surface_copy(struct pipe_context *_pipe,
+                      struct pipe_surface *_dst,
+                      unsigned dstx,
+                      unsigned dsty,
+                      struct pipe_surface *_src,
+                      unsigned srcx,
+                      unsigned srcy,
+                      unsigned width,
+                      unsigned height)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_surface *id_surface_dst = identity_surface(_dst);
+   struct identity_surface *id_surface_src = identity_surface(_src);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_surface *dst = id_surface_dst->surface;
+   struct pipe_surface *src = id_surface_src->surface;
+
+   pipe->surface_copy(pipe,
+                      dst,
+                      dstx,
+                      dsty,
+                      src,
+                      srcx,
+                      srcy,
+                      width,
+                      height);
+}
+
+static void
+identity_surface_fill(struct pipe_context *_pipe,
+                      struct pipe_surface *_dst,
+                      unsigned dstx,
+                      unsigned dsty,
+                      unsigned width,
+                      unsigned height,
+                      unsigned value)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_surface *id_surface_dst = identity_surface(_dst);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_surface *dst = id_surface_dst->surface;
+
+   pipe->surface_fill(pipe,
+                      dst,
+                      dstx,
+                      dsty,
+                      width,
+                      height,
+                      value);
+}
+
+static void
+identity_clear(struct pipe_context *_pipe,
+               unsigned buffers,
+               const float *rgba,
+               double depth,
+               unsigned stencil)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->clear(pipe,
+               buffers,
+               rgba,
+               depth,
+               stencil);
+}
+
+static void
+identity_flush(struct pipe_context *_pipe,
+               unsigned flags,
+               struct pipe_fence_handle **fence)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct pipe_context *pipe = id_pipe->pipe;
+
+   pipe->flush(pipe,
+               flags,
+               fence);
+}
+
+static unsigned int
+identity_is_texture_referenced(struct pipe_context *_pipe,
+                               struct pipe_texture *_texture,
+                               unsigned face,
+                               unsigned level)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_texture *id_texture = identity_texture(_texture);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_texture *texture = id_texture->texture;
+
+   return pipe->is_texture_referenced(pipe,
+                                      texture,
+                                      face,
+                                      level);
+}
+
+static unsigned int
+identity_is_buffer_referenced(struct pipe_context *_pipe,
+                              struct pipe_buffer *_buffer)
+{
+   struct identity_context *id_pipe = identity_context(_pipe);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_context *pipe = id_pipe->pipe;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+
+   return pipe->is_buffer_referenced(pipe,
+                                     buffer);
+}
+
+struct pipe_context *
+identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
+{
+   struct identity_context *id_pipe;
+   (void)identity_screen(_screen);
+
+   id_pipe = CALLOC_STRUCT(identity_context);
+   if (!id_pipe) {
+      return NULL;
+   }
+
+   id_pipe->base.winsys = NULL;
+   id_pipe->base.screen = _screen;
+   id_pipe->base.priv = pipe->priv;
+   id_pipe->base.draw = NULL;
+
+   id_pipe->base.destroy = identity_destroy;
+   id_pipe->base.set_edgeflags = identity_set_edgeflags;
+   id_pipe->base.draw_arrays = identity_draw_arrays;
+   id_pipe->base.draw_elements = identity_draw_elements;
+   id_pipe->base.draw_range_elements = identity_draw_range_elements;
+   id_pipe->base.create_query = identity_create_query;
+   id_pipe->base.destroy_query = identity_destroy_query;
+   id_pipe->base.begin_query = identity_begin_query;
+   id_pipe->base.end_query = identity_end_query;
+   id_pipe->base.get_query_result = identity_get_query_result;
+   id_pipe->base.create_blend_state = identity_create_blend_state;
+   id_pipe->base.bind_blend_state = identity_bind_blend_state;
+   id_pipe->base.delete_blend_state = identity_delete_blend_state;
+   id_pipe->base.create_sampler_state = identity_create_sampler_state;
+   id_pipe->base.bind_sampler_states = identity_bind_sampler_states;
+   id_pipe->base.delete_sampler_state = identity_delete_sampler_state;
+   id_pipe->base.create_rasterizer_state = identity_create_rasterizer_state;
+   id_pipe->base.bind_rasterizer_state = identity_bind_rasterizer_state;
+   id_pipe->base.delete_rasterizer_state = identity_delete_rasterizer_state;
+   id_pipe->base.create_depth_stencil_alpha_state = identity_create_depth_stencil_alpha_state;
+   id_pipe->base.bind_depth_stencil_alpha_state = identity_bind_depth_stencil_alpha_state;
+   id_pipe->base.delete_depth_stencil_alpha_state = identity_delete_depth_stencil_alpha_state;
+   id_pipe->base.create_fs_state = identity_create_fs_state;
+   id_pipe->base.bind_fs_state = identity_bind_fs_state;
+   id_pipe->base.delete_fs_state = identity_delete_fs_state;
+   id_pipe->base.create_vs_state = identity_create_vs_state;
+   id_pipe->base.bind_vs_state = identity_bind_vs_state;
+   id_pipe->base.delete_vs_state = identity_delete_vs_state;
+   id_pipe->base.set_blend_color = identity_set_blend_color;
+   id_pipe->base.set_clip_state = identity_set_clip_state;
+   id_pipe->base.set_constant_buffer = identity_set_constant_buffer;
+   id_pipe->base.set_framebuffer_state = identity_set_framebuffer_state;
+   id_pipe->base.set_polygon_stipple = identity_set_polygon_stipple;
+   id_pipe->base.set_scissor_state = identity_set_scissor_state;
+   id_pipe->base.set_viewport_state = identity_set_viewport_state;
+   id_pipe->base.set_sampler_textures = identity_set_sampler_textures;
+   id_pipe->base.set_vertex_buffers = identity_set_vertex_buffers;
+   id_pipe->base.set_vertex_elements = identity_set_vertex_elements;
+   id_pipe->base.surface_copy = identity_surface_copy;
+   id_pipe->base.surface_fill = identity_surface_fill;
+   id_pipe->base.clear = identity_clear;
+   id_pipe->base.flush = identity_flush;
+   id_pipe->base.is_texture_referenced = identity_is_texture_referenced;
+   id_pipe->base.is_buffer_referenced = identity_is_buffer_referenced;
+
+   id_pipe->pipe = pipe;
+
+   return &id_pipe->base;
+}
diff --git a/src/gallium/drivers/identity/id_context.h b/src/gallium/drivers/identity/id_context.h
new file mode 100644
index 0000000000..75b73fc7df
--- /dev/null
+++ b/src/gallium/drivers/identity/id_context.h
@@ -0,0 +1,48 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef ID_CONTEXT_H
+#define ID_CONTEXT_H
+
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+
+
+struct identity_context {
+   struct pipe_context base;  /**< base class */
+
+   struct pipe_context *pipe;
+};
+
+
+static INLINE struct identity_context *
+identity_context(struct pipe_context *pipe)
+{
+   return (struct identity_context *)pipe;
+}
+
+#endif /* ID_CONTEXT_H */
diff --git a/src/gallium/drivers/identity/id_drm.c b/src/gallium/drivers/identity/id_drm.c
new file mode 100644
index 0000000000..14f68ac0d0
--- /dev/null
+++ b/src/gallium/drivers/identity/id_drm.c
@@ -0,0 +1,173 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "state_tracker/drm_api.h"
+
+#include "util/u_memory.h"
+#include "identity/id_drm.h"
+#include "identity/id_screen.h"
+#include "identity/id_public.h"
+#include "identity/id_screen.h"
+#include "identity/id_objects.h"
+
+struct identity_drm_api
+{
+   struct drm_api base;
+
+   struct drm_api *api;
+};
+
+static INLINE struct identity_drm_api *
+identity_drm_api(struct drm_api *_api)
+{
+   return (struct identity_drm_api *)_api;
+}
+
+static struct pipe_screen *
+identity_drm_create_screen(struct drm_api *_api, int fd,
+                           struct drm_create_screen_arg *arg)
+{
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct drm_api *api = id_api->api;
+   struct pipe_screen *screen;
+
+   if (arg && arg->mode != DRM_CREATE_NORMAL)
+      return NULL;
+
+   screen = api->create_screen(api, fd, arg);
+
+   return identity_screen_create(screen);
+}
+
+static struct pipe_context *
+identity_drm_create_context(struct drm_api *_api,
+                            struct pipe_screen *_screen)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct pipe_screen *screen = id_screen->screen;
+   struct drm_api *api = id_api->api;
+   struct pipe_context *pipe;
+
+   pipe = api->create_context(api, screen);
+
+   pipe = identity_context_create(_screen, pipe);
+
+   return pipe;
+}
+
+static struct pipe_texture *
+identity_drm_texture_from_shared_handle(struct drm_api *_api,
+                                        struct pipe_screen *_screen,
+                                        struct pipe_texture *templ,
+                                        const char *name,
+                                        unsigned stride,
+                                        unsigned handle)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct pipe_screen *screen = id_screen->screen;
+   struct drm_api *api = id_api->api;
+   struct pipe_texture *result;
+
+   result = api->texture_from_shared_handle(api, screen, templ, name, stride, handle);
+
+   result = identity_texture_create(identity_screen(_screen), result);
+
+   return result;
+}
+
+static boolean
+identity_drm_shared_handle_from_texture(struct drm_api *_api,
+                                        struct pipe_screen *_screen,
+                                        struct pipe_texture *_texture,
+                                        unsigned *stride,
+                                        unsigned *handle)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_texture *texture = id_texture->texture;
+   struct drm_api *api = id_api->api;
+
+   return api->shared_handle_from_texture(api, screen, texture, stride, handle);
+}
+
+static boolean
+identity_drm_local_handle_from_texture(struct drm_api *_api,
+                                       struct pipe_screen *_screen,
+                                       struct pipe_texture *_texture,
+                                       unsigned *stride,
+                                       unsigned *handle)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_texture *texture = id_texture->texture;
+   struct drm_api *api = id_api->api;
+
+   return api->local_handle_from_texture(api, screen, texture, stride, handle);
+}
+
+static void
+identity_drm_destroy(struct drm_api *_api)
+{
+   struct identity_drm_api *id_api = identity_drm_api(_api);
+   struct drm_api *api = id_api->api;
+   api->destroy(api);
+
+   free(id_api);
+}
+
+struct drm_api *
+identity_drm_create(struct drm_api *api)
+{
+   struct identity_drm_api *id_api;
+
+   if (!api)
+      goto error;
+
+   id_api = CALLOC_STRUCT(identity_drm_api);
+
+   if (!id_api)
+      goto error;
+
+   id_api->base.create_screen = identity_drm_create_screen;
+   id_api->base.create_context = identity_drm_create_context;
+   id_api->base.texture_from_shared_handle = identity_drm_texture_from_shared_handle;
+   id_api->base.shared_handle_from_texture = identity_drm_shared_handle_from_texture;
+   id_api->base.local_handle_from_texture = identity_drm_local_handle_from_texture;
+   id_api->base.destroy = identity_drm_destroy;
+   id_api->api = api;
+
+   return &id_api->base;
+
+error:
+   return api;
+}
diff --git a/src/gallium/drivers/identity/id_drm.h b/src/gallium/drivers/identity/id_drm.h
new file mode 100644
index 0000000000..cf2ad2ce07
--- /dev/null
+++ b/src/gallium/drivers/identity/id_drm.h
@@ -0,0 +1,35 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef ID_DRM_H
+#define ID_DRM_H
+
+struct drm_api;
+
+struct drm_api* identity_drm_create(struct drm_api *api);
+
+#endif /* ID_DRM_H */
diff --git a/src/gallium/drivers/identity/id_objects.c b/src/gallium/drivers/identity/id_objects.c
new file mode 100644
index 0000000000..e893e59940
--- /dev/null
+++ b/src/gallium/drivers/identity/id_objects.c
@@ -0,0 +1,182 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "util/u_memory.h"
+
+#include "id_public.h"
+#include "id_screen.h"
+#include "id_objects.h"
+
+struct pipe_buffer *
+identity_buffer_create(struct identity_screen *id_screen,
+                       struct pipe_buffer *buffer)
+{
+   struct identity_buffer *id_buffer;
+
+   if(!buffer)
+      goto error;
+
+   assert(buffer->screen == id_screen->screen);
+
+   id_buffer = CALLOC_STRUCT(identity_buffer);
+   if(!id_buffer)
+      goto error;
+
+   memcpy(&id_buffer->base, buffer, sizeof(struct pipe_buffer));
+
+   pipe_reference_init(&id_buffer->base.reference, 1);
+   id_buffer->base.screen = &id_screen->base;
+   id_buffer->buffer = buffer;
+
+   return &id_buffer->base;
+
+error:
+   pipe_buffer_reference(&buffer, NULL);
+   return NULL;
+}
+
+void
+identity_buffer_destroy(struct identity_buffer *id_buffer)
+{
+   pipe_buffer_reference(&id_buffer->buffer, NULL);
+   FREE(id_buffer);
+}
+
+
+struct pipe_texture *
+identity_texture_create(struct identity_screen *id_screen,
+                        struct pipe_texture *texture)
+{
+   struct identity_texture *id_texture;
+
+   if(!texture)
+      goto error;
+
+   assert(texture->screen == id_screen->screen);
+
+   id_texture = CALLOC_STRUCT(identity_texture);
+   if(!id_texture)
+      goto error;
+
+   memcpy(&id_texture->base, texture, sizeof(struct pipe_texture));
+
+   pipe_reference_init(&id_texture->base.reference, 1);
+   id_texture->base.screen = &id_screen->base;
+   id_texture->texture = texture;
+
+   return &id_texture->base;
+
+error:
+   pipe_texture_reference(&texture, NULL);
+   return NULL;
+}
+
+void
+identity_texture_destroy(struct identity_texture *id_texture)
+{
+   pipe_texture_reference(&id_texture->texture, NULL);
+   FREE(id_texture);
+}
+
+
+struct pipe_surface *
+identity_surface_create(struct identity_texture *id_texture,
+                        struct pipe_surface *surface)
+{
+   struct identity_surface *id_surface;
+
+   if(!surface)
+      goto error;
+
+   assert(surface->texture == id_texture->texture);
+
+   id_surface = CALLOC_STRUCT(identity_surface);
+   if(!id_surface)
+      goto error;
+
+   memcpy(&id_surface->base, surface, sizeof(struct pipe_surface));
+
+   pipe_reference_init(&id_surface->base.reference, 1);
+   id_surface->base.texture = NULL;
+   pipe_texture_reference(&id_surface->base.texture, &id_texture->base);
+   id_surface->surface = surface;
+
+   return &id_surface->base;
+
+error:
+   pipe_surface_reference(&surface, NULL);
+   return NULL;
+}
+
+void
+identity_surface_destroy(struct identity_surface *id_surface)
+{
+   pipe_texture_reference(&id_surface->base.texture, NULL);
+   pipe_surface_reference(&id_surface->surface, NULL);
+   FREE(id_surface);
+}
+
+
+struct pipe_transfer *
+identity_transfer_create(struct identity_texture *id_texture,
+                         struct pipe_transfer *transfer)
+{
+   struct identity_transfer *id_transfer;
+
+   if(!transfer)
+      goto error;
+
+   assert(transfer->texture == id_texture->texture);
+
+   id_transfer = CALLOC_STRUCT(identity_transfer);
+   if(!id_transfer)
+      goto error;
+
+   memcpy(&id_transfer->base, transfer, sizeof(struct pipe_transfer));
+
+   id_transfer->base.texture = NULL;
+   pipe_texture_reference(&id_transfer->base.texture, &id_texture->base);
+   id_transfer->transfer = transfer;
+   assert(id_transfer->base.texture == &id_texture->base);
+
+   return &id_transfer->base;
+
+error:
+   transfer->texture->screen->tex_transfer_destroy(transfer);
+   return NULL;
+}
+
+void
+identity_transfer_destroy(struct identity_transfer *id_transfer)
+{
+   struct identity_screen *id_screen = identity_screen(id_transfer->base.texture->screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   pipe_texture_reference(&id_transfer->base.texture, NULL);
+   screen->tex_transfer_destroy(id_transfer->transfer);
+   FREE(id_transfer);
+}
diff --git a/src/gallium/drivers/identity/id_objects.h b/src/gallium/drivers/identity/id_objects.h
new file mode 100644
index 0000000000..ce58faa3c7
--- /dev/null
+++ b/src/gallium/drivers/identity/id_objects.h
@@ -0,0 +1,169 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef ID_OBJECTS_H
+#define ID_OBJECTS_H
+
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_state.h"
+
+#include "id_screen.h"
+
+
+struct identity_buffer
+{
+   struct pipe_buffer base;
+
+   struct pipe_buffer *buffer;
+};
+
+
+struct identity_texture
+{
+   struct pipe_texture base;
+
+   struct pipe_texture *texture;
+};
+
+
+struct identity_surface
+{
+   struct pipe_surface base;
+
+   struct pipe_surface *surface;
+};
+
+
+struct identity_transfer
+{
+   struct pipe_transfer base;
+
+   struct pipe_transfer *transfer;
+};
+
+
+static INLINE struct identity_buffer *
+identity_buffer(struct pipe_buffer *_buffer)
+{
+   if(!_buffer)
+      return NULL;
+   (void)identity_screen(_buffer->screen);
+   return (struct identity_buffer *)_buffer;
+}
+
+static INLINE struct identity_texture *
+identity_texture(struct pipe_texture *_texture)
+{
+   if(!_texture)
+      return NULL;
+   (void)identity_screen(_texture->screen);
+   return (struct identity_texture *)_texture;
+}
+
+static INLINE struct identity_surface *
+identity_surface(struct pipe_surface *_surface)
+{
+   if(!_surface)
+      return NULL;
+   (void)identity_texture(_surface->texture);
+   return (struct identity_surface *)_surface;
+}
+
+static INLINE struct identity_transfer *
+identity_transfer(struct pipe_transfer *_transfer)
+{
+   if(!_transfer)
+      return NULL;
+   (void)identity_texture(_transfer->texture);
+   return (struct identity_transfer *)_transfer;
+}
+
+
+static INLINE struct pipe_buffer *
+identity_buffer_unwrap(struct pipe_buffer *_buffer)
+{
+   if(!_buffer)
+      return NULL;
+   return identity_buffer(_buffer)->buffer;
+}
+
+static INLINE struct pipe_texture *
+identity_texture_unwrap(struct pipe_texture *_texture)
+{
+   if(!_texture)
+      return NULL;
+   return identity_texture(_texture)->texture;
+}
+
+static INLINE struct pipe_surface *
+identity_surface_unwrap(struct pipe_surface *_surface)
+{
+   if(!_surface)
+      return NULL;
+   return identity_surface(_surface)->surface;
+}
+
+static INLINE struct pipe_transfer *
+identity_transfer_unwrap(struct pipe_transfer *_transfer)
+{
+   if(!_transfer)
+      return NULL;
+   return identity_transfer(_transfer)->transfer;
+}
+
+
+struct pipe_buffer *
+identity_buffer_create(struct identity_screen *id_screen,
+                       struct pipe_buffer *buffer);
+
+void
+identity_buffer_destroy(struct identity_buffer *id_buffer);
+
+struct pipe_texture *
+identity_texture_create(struct identity_screen *id_screen,
+                        struct pipe_texture *texture);
+
+void
+identity_texture_destroy(struct identity_texture *id_texture);
+
+struct pipe_surface *
+identity_surface_create(struct identity_texture *id_texture,
+                        struct pipe_surface *surface);
+
+void
+identity_surface_destroy(struct identity_surface *id_surface);
+
+struct pipe_transfer *
+identity_transfer_create(struct identity_texture *id_texture,
+                         struct pipe_transfer *transfer);
+
+void
+identity_transfer_destroy(struct identity_transfer *id_transfer);
+
+
+#endif /* ID_OBJECTS_H */
diff --git a/src/gallium/drivers/identity/id_public.h b/src/gallium/drivers/identity/id_public.h
new file mode 100644
index 0000000000..cac14cfd60
--- /dev/null
+++ b/src/gallium/drivers/identity/id_public.h
@@ -0,0 +1,40 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef ID_PUBLIC_H
+#define ID_PUBLIC_H
+
+struct pipe_screen;
+struct pipe_context;
+
+struct pipe_screen *
+identity_screen_create(struct pipe_screen *screen);
+
+struct pipe_context *
+identity_context_create(struct pipe_screen *screen, struct pipe_context *pipe);
+
+#endif /* PT_PUBLIC_H */
diff --git a/src/gallium/drivers/identity/id_screen.c b/src/gallium/drivers/identity/id_screen.c
new file mode 100644
index 0000000000..26439637d0
--- /dev/null
+++ b/src/gallium/drivers/identity/id_screen.c
@@ -0,0 +1,483 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+
+#include "pipe/p_screen.h"
+#include "pipe/p_state.h"
+#include "util/u_memory.h"
+
+#include "id_public.h"
+#include "id_screen.h"
+#include "id_objects.h"
+
+
+static void
+identity_screen_destroy(struct pipe_screen *_screen)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   screen->destroy(screen);
+
+   FREE(id_screen);
+}
+
+static const char *
+identity_screen_get_name(struct pipe_screen *_screen)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->get_name(screen);
+}
+
+static const char *
+identity_screen_get_vendor(struct pipe_screen *_screen)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->get_vendor(screen);
+}
+
+static int
+identity_screen_get_param(struct pipe_screen *_screen,
+                          int param)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->get_param(screen,
+                            param);
+}
+
+static float
+identity_screen_get_paramf(struct pipe_screen *_screen,
+                           int param)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->get_paramf(screen,
+                             param);
+}
+
+static boolean
+identity_screen_is_format_supported(struct pipe_screen *_screen,
+                                    enum pipe_format format,
+                                    enum pipe_texture_target target,
+                                    unsigned tex_usage,
+                                    unsigned geom_flags)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->is_format_supported(screen,
+                                      format,
+                                      target,
+                                      tex_usage,
+                                      geom_flags);
+}
+
+static struct pipe_texture *
+identity_screen_texture_create(struct pipe_screen *_screen,
+                               const struct pipe_texture *templat)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_texture *result;
+
+   result = screen->texture_create(screen,
+                                   templat);
+
+   if (result)
+      return identity_texture_create(id_screen, result);
+   return NULL;
+}
+
+static struct pipe_texture *
+identity_screen_texture_blanket(struct pipe_screen *_screen,
+                                const struct pipe_texture *templat,
+                                const unsigned *stride,
+                                struct pipe_buffer *_buffer)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+   struct pipe_texture *result;
+
+   result = screen->texture_blanket(screen,
+                                    templat,
+                                    stride,
+                                    buffer);
+
+   if (result)
+      return identity_texture_create(id_screen, result);
+   return NULL;
+}
+
+static void
+identity_screen_texture_destroy(struct pipe_texture *_texture)
+{
+   identity_texture_destroy(identity_texture(_texture));
+}
+
+static struct pipe_surface *
+identity_screen_get_tex_surface(struct pipe_screen *_screen,
+                                struct pipe_texture *_texture,
+                                unsigned face,
+                                unsigned level,
+                                unsigned zslice,
+                                unsigned usage)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_texture *id_texture = identity_texture(_texture);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_surface *result;
+
+   result = screen->get_tex_surface(screen,
+                                    texture,
+                                    face,
+                                    level,
+                                    zslice,
+                                    usage);
+
+   if (result)
+      return identity_surface_create(id_texture, result);
+   return NULL;
+}
+
+static void
+identity_screen_tex_surface_destroy(struct pipe_surface *_surface)
+{
+   identity_surface_destroy(identity_surface(_surface));
+}
+
+static struct pipe_transfer *
+identity_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 identity_screen *id_screen = identity_screen(_screen);
+   struct identity_texture *id_texture = identity_texture(_texture);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_transfer *result;
+
+   result = screen->get_tex_transfer(screen,
+                                     texture,
+                                     face,
+                                     level,
+                                     zslice,
+                                     usage,
+                                     x,
+                                     y,
+                                     w,
+                                     h);
+
+   if (result)
+      return identity_transfer_create(id_texture, result);
+   return NULL;
+}
+
+static void
+identity_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
+{
+   identity_transfer_destroy(identity_transfer(_transfer));
+}
+
+static void *
+identity_screen_transfer_map(struct pipe_screen *_screen,
+                             struct pipe_transfer *_transfer)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_transfer *id_transfer = identity_transfer(_transfer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_transfer *transfer = id_transfer->transfer;
+
+   return screen->transfer_map(screen,
+                               transfer);
+}
+
+static void
+identity_screen_transfer_unmap(struct pipe_screen *_screen,
+                               struct pipe_transfer *_transfer)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_transfer *id_transfer = identity_transfer(_transfer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_transfer *transfer = id_transfer->transfer;
+
+   screen->transfer_unmap(screen,
+                          transfer);
+}
+
+static struct pipe_buffer *
+identity_screen_buffer_create(struct pipe_screen *_screen,
+                              unsigned alignment,
+                              unsigned usage,
+                              unsigned size)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *result;
+
+   result = screen->buffer_create(screen,
+                                  alignment,
+                                  usage,
+                                  size);
+
+   if (result)
+      return identity_buffer_create(id_screen, result);
+   return NULL;
+}
+
+static struct pipe_buffer *
+identity_screen_user_buffer_create(struct pipe_screen *_screen,
+                                   void *ptr,
+                                   unsigned bytes)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *result;
+
+   result = screen->user_buffer_create(screen,
+                                       ptr,
+                                       bytes);
+
+   if (result)
+      return identity_buffer_create(id_screen, result);
+   return NULL;
+}
+
+static struct pipe_buffer *
+identity_screen_surface_buffer_create(struct pipe_screen *_screen,
+                                      unsigned width,
+                                      unsigned height,
+                                      enum pipe_format format,
+                                      unsigned usage,
+                                      unsigned tex_usage,
+                                      unsigned *stride)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *result;
+
+   result = screen->surface_buffer_create(screen,
+                                          width,
+                                          height,
+                                          format,
+                                          usage,
+                                          tex_usage,
+                                          stride);
+
+   if (result)
+      return identity_buffer_create(id_screen, result);
+   return NULL;
+}
+
+static void *
+identity_screen_buffer_map(struct pipe_screen *_screen,
+                           struct pipe_buffer *_buffer,
+                           unsigned usage)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+
+   return screen->buffer_map(screen,
+                             buffer,
+                             usage);
+}
+
+static void *
+identity_screen_buffer_map_range(struct pipe_screen *_screen,
+                                 struct pipe_buffer *_buffer,
+                                 unsigned offset,
+                                 unsigned length,
+                                 unsigned usage)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+
+   return screen->buffer_map_range(screen,
+                                   buffer,
+                                   offset,
+                                   length,
+                                   usage);
+}
+
+static void
+identity_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
+                                          struct pipe_buffer *_buffer,
+                                          unsigned offset,
+                                          unsigned length)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+
+   screen->buffer_flush_mapped_range(screen,
+                                     buffer,
+                                     offset,
+                                     length);
+}
+
+static void
+identity_screen_buffer_unmap(struct pipe_screen *_screen,
+                             struct pipe_buffer *_buffer)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_buffer *id_buffer = identity_buffer(_buffer);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_buffer *buffer = id_buffer->buffer;
+
+   screen->buffer_unmap(screen,
+                        buffer);
+}
+
+static void
+identity_screen_buffer_destroy(struct pipe_buffer *_buffer)
+{
+   identity_buffer_destroy(identity_buffer(_buffer));
+}
+
+static void
+identity_screen_flush_frontbuffer(struct pipe_screen *_screen,
+                                  struct pipe_surface *_surface,
+                                  void *context_private)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct identity_surface *id_surface = identity_surface(_surface);
+   struct pipe_screen *screen = id_screen->screen;
+   struct pipe_surface *surface = id_surface->surface;
+
+   screen->flush_frontbuffer(screen,
+                             surface,
+                             context_private);
+}
+
+static void
+identity_screen_fence_reference(struct pipe_screen *_screen,
+                                struct pipe_fence_handle **ptr,
+                                struct pipe_fence_handle *fence)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   screen->fence_reference(screen,
+                           ptr,
+                           fence);
+}
+
+static int
+identity_screen_fence_signalled(struct pipe_screen *_screen,
+                                struct pipe_fence_handle *fence,
+                                unsigned flags)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->fence_signalled(screen,
+                                  fence,
+                                  flags);
+}
+
+static int
+identity_screen_fence_finish(struct pipe_screen *_screen,
+                             struct pipe_fence_handle *fence,
+                             unsigned flags)
+{
+   struct identity_screen *id_screen = identity_screen(_screen);
+   struct pipe_screen *screen = id_screen->screen;
+
+   return screen->fence_finish(screen,
+                               fence,
+                               flags);
+}
+
+struct pipe_screen *
+identity_screen_create(struct pipe_screen *screen)
+{
+   struct identity_screen *id_screen;
+
+   id_screen = CALLOC_STRUCT(identity_screen);
+   if (!id_screen) {
+      return NULL;
+   }
+
+   id_screen->base.winsys = NULL;
+
+   id_screen->base.destroy = identity_screen_destroy;
+   id_screen->base.get_name = identity_screen_get_name;
+   id_screen->base.get_vendor = identity_screen_get_vendor;
+   id_screen->base.get_param = identity_screen_get_param;
+   id_screen->base.get_paramf = identity_screen_get_paramf;
+   id_screen->base.is_format_supported = identity_screen_is_format_supported;
+   id_screen->base.texture_create = identity_screen_texture_create;
+   id_screen->base.texture_blanket = identity_screen_texture_blanket;
+   id_screen->base.texture_destroy = identity_screen_texture_destroy;
+   id_screen->base.get_tex_surface = identity_screen_get_tex_surface;
+   id_screen->base.tex_surface_destroy = identity_screen_tex_surface_destroy;
+   id_screen->base.get_tex_transfer = identity_screen_get_tex_transfer;
+   id_screen->base.tex_transfer_destroy = identity_screen_tex_transfer_destroy;
+   id_screen->base.transfer_map = identity_screen_transfer_map;
+   id_screen->base.transfer_unmap = identity_screen_transfer_unmap;
+   id_screen->base.buffer_create = identity_screen_buffer_create;
+   id_screen->base.user_buffer_create = identity_screen_user_buffer_create;
+   id_screen->base.surface_buffer_create = identity_screen_surface_buffer_create;
+   if (screen->buffer_map)
+      id_screen->base.buffer_map = identity_screen_buffer_map;
+   if (screen->buffer_map_range)
+      id_screen->base.buffer_map_range = identity_screen_buffer_map_range;
+   if (screen->buffer_flush_mapped_range)
+      id_screen->base.buffer_flush_mapped_range = identity_screen_buffer_flush_mapped_range;
+   if (screen->buffer_unmap)
+      id_screen->base.buffer_unmap = identity_screen_buffer_unmap;
+   id_screen->base.buffer_destroy = identity_screen_buffer_destroy;
+   id_screen->base.flush_frontbuffer = identity_screen_flush_frontbuffer;
+   id_screen->base.fence_reference = identity_screen_fence_reference;
+   id_screen->base.fence_signalled = identity_screen_fence_signalled;
+   id_screen->base.fence_finish = identity_screen_fence_finish;
+
+   id_screen->screen = screen;
+
+   return &id_screen->base;
+}
diff --git a/src/gallium/drivers/identity/id_screen.h b/src/gallium/drivers/identity/id_screen.h
new file mode 100644
index 0000000000..2c4f129089
--- /dev/null
+++ b/src/gallium/drivers/identity/id_screen.h
@@ -0,0 +1,48 @@
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef ID_SCREEN_H
+#define ID_SCREEN_H
+
+#include "pipe/p_screen.h"
+#include "pipe/p_defines.h"
+
+
+struct identity_screen {
+   struct pipe_screen base;
+
+   struct pipe_screen *screen;
+};
+
+
+static INLINE struct identity_screen *
+identity_screen(struct pipe_screen *screen)
+{
+   return (struct identity_screen *)screen;
+}
+
+#endif /* ID_SCREEN_H */