Import Mesa 7.10.3

13 files changed, 2257 insertions, 0 deletions

diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.c b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.c
new file mode 100644
index 000000000..fc68ee13e
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.c
@@ -0,0 +1,211 @@
+/**************************************************************************
+ *
+ * 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.
+ *
+ **************************************************************************/
+/*
+ * Author: Keith Whitwell <keithw@vmware.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ */
+
+#include "utils.h"
+
+#include "dri_screen.h"
+#include "dri_drawable.h"
+#include "dri_context.h"
+
+#include "pipe/p_context.h"
+#include "state_tracker/st_context.h"
+
+static void
+dri_init_extensions(struct dri_context *ctx)
+{
+   struct st_context *st = (struct st_context *) ctx->st;
+
+   /* New extensions should be added in mesa/state_tracker/st_extensions.c
+    * and not in this file. */
+   driInitExtensions(st->ctx, NULL, GL_FALSE);
+}
+
+GLboolean
+dri_create_context(gl_api api, const struct gl_config * visual,
+		   __DRIcontext * cPriv, void *sharedContextPrivate)
+{
+   __DRIscreen *sPriv = cPriv->driScreenPriv;
+   struct dri_screen *screen = dri_screen(sPriv);
+   struct st_api *stapi = screen->st_api;
+   struct dri_context *ctx = NULL;
+   struct st_context_iface *st_share = NULL;
+   struct st_context_attribs attribs;
+
+   memset(&attribs, 0, sizeof(attribs));
+   switch (api) {
+   case API_OPENGLES:
+      attribs.profile = ST_PROFILE_OPENGL_ES1;
+      break;
+   case API_OPENGLES2:
+      attribs.profile = ST_PROFILE_OPENGL_ES2;
+      break;
+   default:
+      attribs.profile = ST_PROFILE_DEFAULT;
+      break;
+   }
+
+   if (sharedContextPrivate) {
+      st_share = ((struct dri_context *)sharedContextPrivate)->st;
+   }
+
+   ctx = CALLOC_STRUCT(dri_context);
+   if (ctx == NULL)
+      goto fail;
+
+   cPriv->driverPrivate = ctx;
+   ctx->cPriv = cPriv;
+   ctx->sPriv = sPriv;
+   ctx->lock = screen->drmLock;
+
+   driParseConfigFiles(&ctx->optionCache,
+		       &screen->optionCache, sPriv->myNum, "dri");
+
+   dri_fill_st_visual(&attribs.visual, screen, visual);
+   ctx->st = stapi->create_context(stapi, &screen->base, &attribs, st_share);
+   if (ctx->st == NULL)
+      goto fail;
+   ctx->st->st_manager_private = (void *) ctx;
+   ctx->stapi = stapi;
+
+   /*
+    * libmesagallium.a that this state tracker will be linked to expects
+    * OpenGL's _glapi_table.  That is, it expects libGL.so instead of
+    * libGLESv1_CM.so or libGLESv2.so.  As there is no clean way to know the
+    * shared library the app links to, use the api as a simple check.
+    * It might be as well to simply remove this function call though.
+    */
+   if (api == API_OPENGL)
+      dri_init_extensions(ctx);
+
+   return GL_TRUE;
+
+ fail:
+   if (ctx && ctx->st)
+      ctx->st->destroy(ctx->st);
+
+   FREE(ctx);
+   return GL_FALSE;
+}
+
+void
+dri_destroy_context(__DRIcontext * cPriv)
+{
+   struct dri_context *ctx = dri_context(cPriv);
+
+   /* note: we are freeing values and nothing more because
+    * driParseConfigFiles allocated values only - the rest
+    * is owned by screen optionCache.
+    */
+   FREE(ctx->optionCache.values);
+
+   /* No particular reason to wait for command completion before
+    * destroying a context, but it is probably worthwhile flushing it
+    * to avoid having to add code elsewhere to cope with flushing a
+    * partially destroyed context.
+    */
+   ctx->st->flush(ctx->st, 0, NULL);
+   ctx->st->destroy(ctx->st);
+
+   FREE(ctx);
+}
+
+GLboolean
+dri_unbind_context(__DRIcontext * cPriv)
+{
+   /* dri_util.c ensures cPriv is not null */
+   struct dri_screen *screen = dri_screen(cPriv->driScreenPriv);
+   struct dri_context *ctx = dri_context(cPriv);
+   struct dri_drawable *draw = dri_drawable(ctx->dPriv);
+   struct dri_drawable *read = dri_drawable(ctx->rPriv);
+   struct st_api *stapi = screen->st_api;
+
+   if (--ctx->bind_count == 0) {
+      if (ctx->st == ctx->stapi->get_current(ctx->stapi)) {
+         ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
+         stapi->make_current(stapi, NULL, NULL, NULL);
+         draw->context = NULL;
+         read->context = NULL;
+      }
+   }
+
+   return GL_TRUE;
+}
+
+GLboolean
+dri_make_current(__DRIcontext * cPriv,
+		 __DRIdrawable * driDrawPriv,
+		 __DRIdrawable * driReadPriv)
+{
+   /* dri_util.c ensures cPriv is not null */
+   struct dri_context *ctx = dri_context(cPriv);
+   struct dri_drawable *draw = dri_drawable(driDrawPriv);
+   struct dri_drawable *read = dri_drawable(driReadPriv);
+   struct st_context_iface *old_st = ctx->stapi->get_current(ctx->stapi);
+
+   if (old_st && old_st != ctx->st)
+      old_st->flush(old_st, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+   ++ctx->bind_count;
+
+   if (!driDrawPriv && !driReadPriv)
+      return ctx->stapi->make_current(ctx->stapi, ctx->st, NULL, NULL);
+   else if (!driDrawPriv || !driReadPriv)
+      return GL_FALSE;
+
+   draw->context = ctx;
+   if (ctx->dPriv != driDrawPriv) {
+      ctx->dPriv = driDrawPriv;
+      draw->texture_stamp = driDrawPriv->lastStamp - 1;
+   }
+   read->context = ctx;
+   if (ctx->rPriv != driReadPriv) {
+      ctx->rPriv = driReadPriv;
+      read->texture_stamp = driReadPriv->lastStamp - 1;
+   }
+
+   ctx->stapi->make_current(ctx->stapi, ctx->st, &draw->base, &read->base);
+
+   return GL_TRUE;
+}
+
+struct dri_context *
+dri_get_current(__DRIscreen *sPriv)
+{
+   struct dri_screen *screen = dri_screen(sPriv);
+   struct st_api *stapi = screen->st_api;
+   struct st_context_iface *st;
+
+   st = stapi->get_current(stapi);
+
+   return (struct dri_context *) (st) ? st->st_manager_private : NULL;
+}
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.h b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.h
new file mode 100644
index 000000000..35105e861
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_context.h
@@ -0,0 +1,97 @@
+/**************************************************************************
+ *
+ * Copyright (C) 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.
+ *
+ **************************************************************************/
+/*
+ * Author: Keith Whitwell <keithw@vmware.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ */
+
+#ifndef DRI_CONTEXT_H
+#define DRI_CONTEXT_H
+
+#include "pipe/p_compiler.h"
+#include "dri_wrapper.h"
+
+struct pipe_context;
+struct pipe_fence;
+struct st_api;
+struct st_context_iface;
+struct dri_drawable;
+
+struct dri_context
+{
+   /* dri */
+   __DRIscreen *sPriv;
+   __DRIcontext *cPriv;
+   __DRIdrawable *dPriv;
+   __DRIdrawable *rPriv;
+
+   driOptionCache optionCache;
+
+   drmLock *lock;
+   boolean isLocked;
+   boolean stLostLock;
+   boolean wsLostLock;
+
+   unsigned int bind_count;
+
+   /* gallium */
+   struct st_api *stapi;
+   struct st_context_iface *st;
+};
+
+static INLINE struct dri_context *
+dri_context(__DRIcontext * driContextPriv)
+{
+   if (!driContextPriv)
+     return NULL;
+   return (struct dri_context *)driContextPriv->driverPrivate;
+}
+
+/***********************************************************************
+ * dri_context.c
+ */
+void dri_destroy_context(__DRIcontext * driContextPriv);
+
+boolean dri_unbind_context(__DRIcontext * driContextPriv);
+
+boolean
+dri_make_current(__DRIcontext * driContextPriv,
+		 __DRIdrawable * driDrawPriv,
+		 __DRIdrawable * driReadPriv);
+
+struct dri_context *
+dri_get_current(__DRIscreen * driScreenPriv);
+
+boolean
+dri_create_context(gl_api api,
+		   const struct gl_config * visual,
+		   __DRIcontext * driContextPriv,
+		   void *sharedContextPrivate);
+
+#endif
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.c b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.c
new file mode 100644
index 000000000..61936706a
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.c
@@ -0,0 +1,267 @@
+/**************************************************************************
+ *
+ * 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.
+ *
+ **************************************************************************/
+/*
+ * Author: Keith Whitwell <keithw@vmware.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ */
+
+#include "dri_screen.h"
+#include "dri_context.h"
+#include "dri_drawable.h"
+
+#include "pipe/p_screen.h"
+#include "util/u_format.h"
+#include "util/u_memory.h"
+#include "util/u_inlines.h"
+ 
+
+static boolean
+dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
+                            const enum st_attachment_type *statts,
+                            unsigned count,
+                            struct pipe_resource **out)
+{
+   struct dri_drawable *drawable =
+      (struct dri_drawable *) stfbi->st_manager_private;
+   struct dri_screen *screen = dri_screen(drawable->sPriv);
+   unsigned statt_mask, new_mask;
+   boolean new_stamp;
+   int i;
+
+   statt_mask = 0x0;
+   for (i = 0; i < count; i++)
+      statt_mask |= (1 << statts[i]);
+
+   /* record newly allocated textures */
+   new_mask = (statt_mask & ~drawable->texture_mask);
+
+   /*
+    * dPriv->pStamp is the server stamp.  It should be accessed with a lock, at
+    * least for DRI1.  dPriv->lastStamp is the client stamp.  It has the value
+    * of the server stamp when last checked.
+    */
+   new_stamp = (drawable->texture_stamp != drawable->dPriv->lastStamp);
+
+   if (new_stamp || new_mask || screen->broken_invalidate) {
+      if (new_stamp && drawable->update_drawable_info)
+         drawable->update_drawable_info(drawable);
+
+      drawable->allocate_textures(drawable, statts, count);
+
+      /* add existing textures */
+      for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
+         if (drawable->textures[i])
+            statt_mask |= (1 << i);
+      }
+
+      drawable->texture_stamp = drawable->dPriv->lastStamp;
+      drawable->texture_mask = statt_mask;
+   }
+
+   if (!out)
+      return TRUE;
+
+   for (i = 0; i < count; i++) {
+      out[i] = NULL;
+      pipe_resource_reference(&out[i], drawable->textures[statts[i]]);
+   }
+
+   return TRUE;
+}
+
+static boolean
+dri_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi,
+                               enum st_attachment_type statt)
+{
+   struct dri_drawable *drawable =
+      (struct dri_drawable *) stfbi->st_manager_private;
+
+   /* XXX remove this and just set the correct one on the framebuffer */
+   drawable->flush_frontbuffer(drawable, statt);
+
+   return TRUE;
+}
+
+/**
+ * This is called when we need to set up GL rendering to a new X window.
+ */
+boolean
+dri_create_buffer(__DRIscreen * sPriv,
+		  __DRIdrawable * dPriv,
+		  const struct gl_config * visual, boolean isPixmap)
+{
+   struct dri_screen *screen = sPriv->private;
+   struct dri_drawable *drawable = NULL;
+
+   if (isPixmap)
+      goto fail;		       /* not implemented */
+
+   drawable = CALLOC_STRUCT(dri_drawable);
+   if (drawable == NULL)
+      goto fail;
+
+   dri_fill_st_visual(&drawable->stvis, screen, visual);
+
+   /* setup the st_framebuffer_iface */
+   drawable->base.visual = &drawable->stvis;
+   drawable->base.flush_front = dri_st_framebuffer_flush_front;
+   drawable->base.validate = dri_st_framebuffer_validate;
+   drawable->base.st_manager_private = (void *) drawable;
+
+   drawable->screen = screen;
+   drawable->sPriv = sPriv;
+   drawable->dPriv = dPriv;
+   dPriv->driverPrivate = (void *)drawable;
+
+   return GL_TRUE;
+fail:
+   FREE(drawable);
+   return GL_FALSE;
+}
+
+void
+dri_destroy_buffer(__DRIdrawable * dPriv)
+{
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+   int i;
+
+   pipe_surface_reference(&drawable->drisw_surface, NULL);
+
+   for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+      pipe_resource_reference(&drawable->textures[i], NULL);
+
+   FREE(drawable);
+}
+
+/**
+ * Validate the texture at an attachment.  Allocate the texture if it does not
+ * exist.  Used by the TFP extension.
+ */
+static void
+dri_drawable_validate_att(struct dri_drawable *drawable,
+                          enum st_attachment_type statt)
+{
+   enum st_attachment_type statts[ST_ATTACHMENT_COUNT];
+   unsigned i, count = 0;
+
+   /* check if buffer already exists */
+   if (drawable->texture_mask & (1 << statt))
+      return;
+
+   /* make sure DRI2 does not destroy existing buffers */
+   for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
+      if (drawable->texture_mask & (1 << i)) {
+         statts[count++] = i;
+      }
+   }
+   statts[count++] = statt;
+
+   drawable->texture_stamp = drawable->dPriv->lastStamp - 1;
+
+   drawable->base.validate(&drawable->base, statts, count, NULL);
+}
+
+/**
+ * These are used for GLX_EXT_texture_from_pixmap
+ */
+static void
+dri_set_tex_buffer2(__DRIcontext *pDRICtx, GLint target,
+                    GLint format, __DRIdrawable *dPriv)
+{
+   struct dri_context *ctx = dri_context(pDRICtx);
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+   struct pipe_resource *pt;
+
+   dri_drawable_validate_att(drawable, ST_ATTACHMENT_FRONT_LEFT);
+
+   pt = drawable->textures[ST_ATTACHMENT_FRONT_LEFT];
+
+   if (pt) {
+      enum pipe_format internal_format = pt->format;
+
+      if (format == __DRI_TEXTURE_FORMAT_RGB)  {
+         /* only need to cover the formats recognized by dri_fill_st_visual */
+         switch (internal_format) {
+         case PIPE_FORMAT_B8G8R8A8_UNORM:
+            internal_format = PIPE_FORMAT_B8G8R8X8_UNORM;
+            break;
+         case PIPE_FORMAT_A8R8G8B8_UNORM:
+            internal_format = PIPE_FORMAT_X8R8G8B8_UNORM;
+            break;
+         default:
+            break;
+         }
+      }
+
+      ctx->st->teximage(ctx->st,
+            (target == GL_TEXTURE_2D) ? ST_TEXTURE_2D : ST_TEXTURE_RECT,
+            0, internal_format, pt, FALSE);
+   }
+}
+
+static void
+dri_set_tex_buffer(__DRIcontext *pDRICtx, GLint target,
+                   __DRIdrawable *dPriv)
+{
+   dri_set_tex_buffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);
+}
+
+const __DRItexBufferExtension driTexBufferExtension = {
+    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
+   dri_set_tex_buffer,
+   dri_set_tex_buffer2,
+};
+
+/**
+ * Get the format and binding of an attachment.
+ */
+void
+dri_drawable_get_format(struct dri_drawable *drawable,
+                        enum st_attachment_type statt,
+                        enum pipe_format *format,
+                        unsigned *bind)
+{
+   switch (statt) {
+   case ST_ATTACHMENT_FRONT_LEFT:
+   case ST_ATTACHMENT_BACK_LEFT:
+   case ST_ATTACHMENT_FRONT_RIGHT:
+   case ST_ATTACHMENT_BACK_RIGHT:
+      *format = drawable->stvis.color_format;
+      *bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
+      break;
+   case ST_ATTACHMENT_DEPTH_STENCIL:
+      *format = drawable->stvis.depth_stencil_format;
+      *bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */
+      break;
+   default:
+      *format = PIPE_FORMAT_NONE;
+      *bind = 0;
+      break;
+   }
+}
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.h b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.h
new file mode 100644
index 000000000..7f1aa512c
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_drawable.h
@@ -0,0 +1,100 @@
+/**************************************************************************
+ *
+ * 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 DRI_DRAWABLE_H
+#define DRI_DRAWABLE_H
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_format.h"
+#include "state_tracker/st_api.h"
+
+struct pipe_surface;
+struct st_framebuffer;
+struct dri_context;
+
+struct dri_drawable
+{
+   struct st_framebuffer_iface base;
+   struct st_visual stvis;
+
+   struct dri_screen *screen;
+   struct dri_context *context;
+
+   /* dri */
+   __DRIdrawable *dPriv;
+   __DRIscreen *sPriv;
+
+   __DRIbuffer old[8];
+   unsigned old_num;
+   unsigned old_w;
+   unsigned old_h;
+
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
+   unsigned int texture_mask, texture_stamp;
+
+   /* used only by DRISW */
+   struct pipe_surface *drisw_surface;
+
+   /* hooks filled in by dri2 & drisw */
+   void (*allocate_textures)(struct dri_drawable *drawable,
+                             const enum st_attachment_type *statts,
+                             unsigned count);
+
+   void (*update_drawable_info)(struct dri_drawable *drawable);
+
+   void (*flush_frontbuffer)(struct dri_drawable *drawable,
+                             enum st_attachment_type statt);
+};
+
+static INLINE struct dri_drawable *
+dri_drawable(__DRIdrawable * driDrawPriv)
+{
+   return (struct dri_drawable *) (driDrawPriv)
+      ? driDrawPriv->driverPrivate : NULL;
+}
+
+/***********************************************************************
+ * dri_drawable.c
+ */
+boolean
+dri_create_buffer(__DRIscreen * sPriv,
+		  __DRIdrawable * dPriv,
+		  const struct gl_config * visual, boolean isPixmap);
+
+void dri_destroy_buffer(__DRIdrawable * dPriv);
+
+void
+dri_drawable_get_format(struct dri_drawable *drawable,
+                        enum st_attachment_type statt,
+                        enum pipe_format *format,
+                        unsigned *bind);
+
+extern const __DRItexBufferExtension driTexBufferExtension;
+
+#endif
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.c b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.c
new file mode 100644
index 000000000..f6e22c74b
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.c
@@ -0,0 +1,396 @@
+/**************************************************************************
+ *
+ * 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.
+ *
+ **************************************************************************/
+/*
+ * Author: Keith Whitwell <keithw@vmware.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ */
+
+#include "utils.h"
+#include "xmlpool.h"
+
+#include "dri_screen.h"
+
+#include "util/u_inlines.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_format.h"
+#include "state_tracker/st_gl_api.h" /* for st_gl_api_create */
+
+#include "util/u_debug.h"
+
+PUBLIC const char __driConfigOptions[] =
+   DRI_CONF_BEGIN DRI_CONF_SECTION_PERFORMANCE
+   DRI_CONF_FTHROTTLE_MODE(DRI_CONF_FTHROTTLE_IRQS)
+   DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
+   DRI_CONF_SECTION_END DRI_CONF_SECTION_QUALITY
+/* DRI_CONF_FORCE_S3TC_ENABLE(false) */
+   DRI_CONF_ALLOW_LARGE_TEXTURES(1)
+   DRI_CONF_SECTION_END DRI_CONF_END;
+
+static const uint __driNConfigOptions = 3;
+
+static const __DRIconfig **
+dri_fill_in_modes(struct dri_screen *screen,
+		  unsigned pixel_bits)
+{
+   __DRIconfig **configs = NULL;
+   __DRIconfig **configs_r5g6b5 = NULL;
+   __DRIconfig **configs_a8r8g8b8 = NULL;
+   __DRIconfig **configs_x8r8g8b8 = NULL;
+   uint8_t depth_bits_array[5];
+   uint8_t stencil_bits_array[5];
+   uint8_t msaa_samples_array[5];
+   unsigned depth_buffer_factor;
+   unsigned back_buffer_factor;
+   unsigned msaa_samples_factor;
+   unsigned i;
+   struct pipe_screen *p_screen = screen->base.screen;
+   boolean pf_r5g6b5, pf_a8r8g8b8, pf_x8r8g8b8;
+   boolean pf_z16, pf_x8z24, pf_z24x8, pf_s8z24, pf_z24s8, pf_z32;
+
+   static const GLenum back_buffer_modes[] = {
+      GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
+   };
+
+   depth_bits_array[0] = 0;
+   stencil_bits_array[0] = 0;
+   depth_buffer_factor = 1;
+
+   pf_x8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24X8_UNORM,
+					    PIPE_TEXTURE_2D, 0,
+					    PIPE_BIND_DEPTH_STENCIL, 0);
+   pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM,
+					    PIPE_TEXTURE_2D, 0,
+					    PIPE_BIND_DEPTH_STENCIL, 0);
+   pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
+					    PIPE_TEXTURE_2D, 0,
+					    PIPE_BIND_DEPTH_STENCIL, 0);
+   pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
+					    PIPE_TEXTURE_2D, 0,
+					    PIPE_BIND_DEPTH_STENCIL, 0);
+   pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
+					       PIPE_TEXTURE_2D, 0,
+					       PIPE_BIND_RENDER_TARGET, 0);
+   pf_x8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM,
+					       PIPE_TEXTURE_2D, 0,
+					       PIPE_BIND_RENDER_TARGET, 0);
+   pf_r5g6b5 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM,
+					     PIPE_TEXTURE_2D, 0,
+					     PIPE_BIND_RENDER_TARGET, 0);
+
+   /* We can only get a 16 or 32 bit depth buffer with getBuffersWithFormat */
+   if (dri_with_format(screen->sPriv)) {
+      pf_z16 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z16_UNORM,
+                                             PIPE_TEXTURE_2D, 0,
+                                             PIPE_BIND_DEPTH_STENCIL, 0);
+      pf_z32 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z32_UNORM,
+                                             PIPE_TEXTURE_2D, 0,
+                                             PIPE_BIND_DEPTH_STENCIL, 0);
+   } else {
+      pf_z16 = FALSE;
+      pf_z32 = FALSE;
+   }
+
+   if (pf_z16) {
+      depth_bits_array[depth_buffer_factor] = 16;
+      stencil_bits_array[depth_buffer_factor++] = 0;
+   }
+   if (pf_x8z24 || pf_z24x8) {
+      depth_bits_array[depth_buffer_factor] = 24;
+      stencil_bits_array[depth_buffer_factor++] = 0;
+      screen->d_depth_bits_last = pf_x8z24;
+   }
+   if (pf_s8z24 || pf_z24s8) {
+      depth_bits_array[depth_buffer_factor] = 24;
+      stencil_bits_array[depth_buffer_factor++] = 8;
+      screen->sd_depth_bits_last = pf_s8z24;
+   }
+   if (pf_z32) {
+      depth_bits_array[depth_buffer_factor] = 32;
+      stencil_bits_array[depth_buffer_factor++] = 0;
+   }
+
+   msaa_samples_array[0] = 0;
+   back_buffer_factor = 3;
+
+   /* also test color for msaa 2/4/6/8 - just assume it'll work for all depth buffers */
+   if (pf_r5g6b5) {
+      msaa_samples_factor = 1;
+      for (i = 1; i < 5; i++) {
+         if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM,
+						   PIPE_TEXTURE_2D, i*2,
+						   PIPE_BIND_RENDER_TARGET, 0)) {
+            msaa_samples_array[msaa_samples_factor] = i * 2;
+            msaa_samples_factor++;
+         }
+      }
+
+      configs_r5g6b5 = driCreateConfigs(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
+                                        depth_bits_array, stencil_bits_array,
+                                        depth_buffer_factor, back_buffer_modes,
+                                        back_buffer_factor,
+                                        msaa_samples_array, msaa_samples_factor,
+                                        GL_TRUE);
+   }
+
+   if (pf_a8r8g8b8) {
+      msaa_samples_factor = 1;
+      for (i = 1; i < 5; i++) {
+         if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
+						   PIPE_TEXTURE_2D, i*2,
+						   PIPE_BIND_RENDER_TARGET, 0)) {
+            msaa_samples_array[msaa_samples_factor] = i * 2;
+            msaa_samples_factor++;
+         }
+      }
+
+      configs_a8r8g8b8 = driCreateConfigs(GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
+                                          depth_bits_array,
+                                          stencil_bits_array,
+                                          depth_buffer_factor,
+                                          back_buffer_modes,
+                                          back_buffer_factor,
+                                          msaa_samples_array,
+                                          msaa_samples_factor,
+                                          GL_TRUE);
+   }
+
+   if (pf_x8r8g8b8) {
+      msaa_samples_factor = 1;
+      for (i = 1; i < 5; i++) {
+         if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM,
+						   PIPE_TEXTURE_2D, i*2,
+						   PIPE_BIND_RENDER_TARGET, 0)) {
+            msaa_samples_array[msaa_samples_factor] = i * 2;
+            msaa_samples_factor++;
+         }
+      }
+
+      configs_x8r8g8b8 = driCreateConfigs(GL_BGR, GL_UNSIGNED_INT_8_8_8_8_REV,
+                                          depth_bits_array,
+                                          stencil_bits_array,
+                                          depth_buffer_factor,
+                                          back_buffer_modes,
+                                          back_buffer_factor,
+                                          msaa_samples_array,
+                                          msaa_samples_factor,
+                                          GL_TRUE);
+   }
+
+   if (pixel_bits == 16) {
+      configs = configs_r5g6b5;
+      if (configs_a8r8g8b8)
+         configs = configs ? driConcatConfigs(configs, configs_a8r8g8b8) : configs_a8r8g8b8;
+      if (configs_x8r8g8b8)
+	 configs = configs ? driConcatConfigs(configs, configs_x8r8g8b8) : configs_x8r8g8b8;
+   } else {
+      configs = configs_a8r8g8b8;
+      if (configs_x8r8g8b8)
+	 configs = configs ? driConcatConfigs(configs, configs_x8r8g8b8) : configs_x8r8g8b8;
+      if (configs_r5g6b5)
+         configs = configs ? driConcatConfigs(configs, configs_r5g6b5) : configs_r5g6b5;
+   }
+
+   if (configs == NULL) {
+      debug_printf("%s: driCreateConfigs failed\n", __FUNCTION__);
+      return NULL;
+   }
+
+   return (const __DRIconfig **)configs;
+}
+
+/**
+ * Roughly the converse of dri_fill_in_modes.
+ */
+void
+dri_fill_st_visual(struct st_visual *stvis, struct dri_screen *screen,
+                   const struct gl_config *mode)
+{
+   memset(stvis, 0, sizeof(*stvis));
+
+   if (!mode)
+      return;
+
+   stvis->samples = mode->samples;
+   stvis->render_buffer = ST_ATTACHMENT_INVALID;
+
+   if (mode->redBits == 8) {
+      if (mode->alphaBits == 8)
+         stvis->color_format = PIPE_FORMAT_B8G8R8A8_UNORM;
+      else
+         stvis->color_format = PIPE_FORMAT_B8G8R8X8_UNORM;
+   } else {
+      stvis->color_format = PIPE_FORMAT_B5G6R5_UNORM;
+   }
+
+   switch (mode->depthBits) {
+   default:
+   case 0:
+      stvis->depth_stencil_format = PIPE_FORMAT_NONE;
+      break;
+   case 16:
+      stvis->depth_stencil_format = PIPE_FORMAT_Z16_UNORM;
+      break;
+   case 24:
+      if (mode->stencilBits == 0) {
+	 stvis->depth_stencil_format = (screen->d_depth_bits_last) ?
+                                          PIPE_FORMAT_Z24X8_UNORM:
+                                          PIPE_FORMAT_X8Z24_UNORM;
+      } else {
+	 stvis->depth_stencil_format = (screen->sd_depth_bits_last) ?
+                                          PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+                                          PIPE_FORMAT_S8_USCALED_Z24_UNORM;
+      }
+      break;
+   case 32:
+      stvis->depth_stencil_format = PIPE_FORMAT_Z32_UNORM;
+      break;
+   }
+
+   stvis->accum_format = (mode->haveAccumBuffer) ?
+      PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
+
+   stvis->buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
+   if (mode->doubleBufferMode)
+      stvis->buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
+   if (mode->stereoMode) {
+      stvis->buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
+      if (mode->doubleBufferMode)
+         stvis->buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
+   }
+
+   if (mode->haveDepthBuffer || mode->haveStencilBuffer)
+      stvis->buffer_mask |= ST_ATTACHMENT_DEPTH_STENCIL_MASK;
+   /* let the state tracker allocate the accum buffer */
+}
+
+static boolean
+dri_get_egl_image(struct st_manager *smapi,
+                  void *egl_image,
+                  struct st_egl_image *stimg)
+{
+   struct dri_screen *screen = (struct dri_screen *)smapi;
+   __DRIimage *img = NULL;
+
+   if (screen->lookup_egl_image) {
+      img = screen->lookup_egl_image(screen, egl_image);
+   }
+
+   if (!img)
+      return FALSE;
+
+   stimg->texture = NULL;
+   pipe_resource_reference(&stimg->texture, img->texture);
+   stimg->level = img->level;
+   stimg->layer = img->layer;
+
+   return TRUE;
+}
+
+static int
+dri_get_param(struct st_manager *smapi,
+              enum st_manager_param param)
+{
+   struct dri_screen *screen = (struct dri_screen *)smapi;
+
+   switch(param) {
+   case ST_MANAGER_BROKEN_INVALIDATE:
+      return screen->broken_invalidate;
+   default:
+      return 0;
+   }
+}
+
+static void
+dri_destroy_option_cache(struct dri_screen * screen)
+{
+   int i;
+
+   if (screen->optionCache.info) {
+      for (i = 0; i < (1 << screen->optionCache.tableSize); ++i) {
+         FREE(screen->optionCache.info[i].name);
+         FREE(screen->optionCache.info[i].ranges);
+      }
+      FREE(screen->optionCache.info);
+   }
+
+   FREE(screen->optionCache.values);
+}
+
+void
+dri_destroy_screen_helper(struct dri_screen * screen)
+{
+   if (screen->st_api && screen->st_api->destroy)
+      screen->st_api->destroy(screen->st_api);
+
+   if (screen->base.screen)
+      screen->base.screen->destroy(screen->base.screen);
+
+   dri_destroy_option_cache(screen);
+}
+
+void
+dri_destroy_screen(__DRIscreen * sPriv)
+{
+   struct dri_screen *screen = dri_screen(sPriv);
+
+   dri_destroy_screen_helper(screen);
+
+   FREE(screen);
+   sPriv->private = NULL;
+   sPriv->extensions = NULL;
+}
+
+const __DRIconfig **
+dri_init_screen_helper(struct dri_screen *screen,
+                       struct pipe_screen *pscreen,
+                       unsigned pixel_bits)
+{
+   screen->base.screen = pscreen;
+   if (!screen->base.screen) {
+      debug_printf("%s: failed to create pipe_screen\n", __FUNCTION__);
+      return NULL;
+   }
+
+   screen->base.get_egl_image = dri_get_egl_image;
+   screen->base.get_param = dri_get_param;
+
+   screen->st_api = st_gl_api_create();
+   if (!screen->st_api)
+      return NULL;
+
+   if(pscreen->get_param(pscreen, PIPE_CAP_NPOT_TEXTURES))
+      screen->target = PIPE_TEXTURE_2D;
+   else
+      screen->target = PIPE_TEXTURE_RECT;
+
+   driParseOptionInfo(&screen->optionCache,
+                      __driConfigOptions, __driNConfigOptions);
+
+   return dri_fill_in_modes(screen, pixel_bits);
+}
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.h b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.h
new file mode 100644
index 000000000..8cb0a102c
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_screen.h
@@ -0,0 +1,131 @@
+/**************************************************************************
+ *
+ * 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.
+ *
+ **************************************************************************/
+/*
+ * Author: Keith Whitwell <keithw@vmware.com>
+ * Author: Jakob Bornecrantz <wallbraker@gmail.com>
+ */
+
+#ifndef DRI_SCREEN_H
+#define DRI_SCREEN_H
+
+#include "dri_wrapper.h"
+#include "xmlconfig.h"
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_context.h"
+#include "pipe/p_state.h"
+#include "state_tracker/st_api.h"
+
+struct dri_context;
+struct dri_drawable;
+
+struct dri_screen
+{
+   /* st_api */
+   struct st_manager base;
+   struct st_api *st_api;
+
+   /* on old libGL's invalidate doesn't get called as it should */
+   boolean broken_invalidate;
+
+   /* dri */
+   __DRIscreen *sPriv;
+
+   /**
+    * Configuration cache with default values for all contexts
+    */
+   driOptionCache optionCache;
+
+   /* drm */
+   int fd;
+   drmLock *drmLock;
+
+   /* gallium */
+   boolean d_depth_bits_last;
+   boolean sd_depth_bits_last;
+   boolean auto_fake_front;
+   enum pipe_texture_target target;
+
+   /* hooks filled in by dri2 & drisw */
+   __DRIimage * (*lookup_egl_image)(struct dri_screen *ctx, void *handle);
+};
+
+/** cast wrapper */
+static INLINE struct dri_screen *
+dri_screen(__DRIscreen * sPriv)
+{
+   return (struct dri_screen *)sPriv->private;
+}
+
+struct __DRIimageRec {
+   struct pipe_resource *texture;
+   unsigned level;
+   unsigned layer;
+
+   void *loader_private;
+};
+
+#ifndef __NOT_HAVE_DRM_H
+
+static INLINE boolean
+dri_with_format(__DRIscreen * sPriv)
+{
+   const __DRIdri2LoaderExtension *loader = sPriv->dri2.loader;
+
+   return loader
+       && (loader->base.version >= 3)
+       && (loader->getBuffersWithFormat != NULL);
+}
+
+#else
+
+static INLINE boolean
+dri_with_format(__DRIscreen * sPriv)
+{
+   return TRUE;
+}
+
+#endif
+
+void
+dri_fill_st_visual(struct st_visual *stvis, struct dri_screen *screen,
+                   const struct gl_config *mode);
+
+const __DRIconfig **
+dri_init_screen_helper(struct dri_screen *screen,
+                       struct pipe_screen *pscreen,
+                       unsigned pixel_bits);
+
+void
+dri_destroy_screen_helper(struct dri_screen * screen);
+
+void
+dri_destroy_screen(__DRIscreen * sPriv);
+
+#endif
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/common/dri_wrapper.h b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_wrapper.h
new file mode 100644
index 000000000..141ba0270
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/common/dri_wrapper.h
@@ -0,0 +1,10 @@
+#ifndef DRI_WRAPPER_H
+#define DRI_WRAPPER_H
+
+#ifndef __NOT_HAVE_DRM_H
+#include "dri_util.h"
+#else
+#include "drisw_util.h"
+#endif
+
+#endif
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/drm/Makefile b/dist/Mesa/src/gallium/state_trackers/dri/drm/Makefile
new file mode 100644
index 000000000..c717b2bde
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/drm/Makefile
@@ -0,0 +1,30 @@
+TOP = ../../../../..
+include $(TOP)/configs/current
+
+LIBNAME = dridrm
+
+LIBRARY_INCLUDES = \
+	-I$(TOP)/include \
+	-I$(TOP)/src/mapi \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/src/gallium/state_trackers/dri/common \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+	-I$(TOP)/src/mesa/main \
+         $(shell pkg-config --cflags-only-I libdrm)
+
+
+C_SOURCES = \
+	dri_context.c \
+	dri_screen.c \
+	dri_drawable.c \
+	dri2.c
+
+#	$(TOP)/src/mesa/drivers/dri/common/utils.c \
+	$(TOP)/src/mesa/drivers/dri/common/vblank.c \
+	$(TOP)/src/mesa/drivers/dri/common/dri_util.c \
+	$(TOP)/src/mesa/drivers/dri/common/xmlconfig.c \
+	$(TOP)/src/mesa/drivers/common/driverfuncs.c \
+	$(TOP)/src/mesa/drivers/dri/common/texmem.c \
+	$(TOP)/src/mesa/drivers/dri/common/drirenderbuffer.c
+
+include ../../../Makefile.template
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/drm/SConscript b/dist/Mesa/src/gallium/state_trackers/dri/drm/SConscript
new file mode 100644
index 000000000..b188f76f9
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/drm/SConscript
@@ -0,0 +1,28 @@
+#######################################################################
+# SConscript for dri state_tracker
+
+Import('*')
+
+env = env.Clone()
+
+env.ParseConfig('pkg-config --cflags --libs libdrm')
+
+env.Append(CPPPATH = [
+    '#/src/mapi',
+    '#/src/mesa',
+    '#/src/gallium/state_trackers/dri/common',
+    '#/src/mesa/drivers/dri/common',
+])
+
+sources = [
+    'dri_context.c',
+    'dri_drawable.c',
+    'dri_screen.c',
+    'dri2.c',
+]
+
+st_dri = env.ConvenienceLibrary(
+    target = 'st_dri',
+    source = sources,
+)
+Export('st_dri')
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/drm/dri2.c b/dist/Mesa/src/gallium/state_trackers/dri/drm/dri2.c
new file mode 100644
index 000000000..997a17b1f
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/drm/dri2.c
@@ -0,0 +1,614 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright 2009, VMware, Inc.
+ * All Rights Reserved.
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@vmware.com>
+ *    Jakob Bornecrantz <wallbraker@gmail.com>
+ *    Chia-I Wu <olv@lunarg.com>
+ */
+
+#include "util/u_memory.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_debug.h"
+#include "state_tracker/drm_driver.h"
+
+#include "dri_screen.h"
+#include "dri_context.h"
+#include "dri_drawable.h"
+
+/**
+ * DRI2 flush extension.
+ */
+static void
+dri2_flush_drawable(__DRIdrawable *draw)
+{
+}
+
+static void
+dri2_invalidate_drawable(__DRIdrawable *dPriv)
+{
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+   struct dri_context *ctx = drawable->context;
+
+   dri2InvalidateDrawable(dPriv);
+   drawable->dPriv->lastStamp = *drawable->dPriv->pStamp;
+
+   if (ctx)
+      ctx->st->notify_invalid_framebuffer(ctx->st, &drawable->base);
+}
+
+static const __DRI2flushExtension dri2FlushExtension = {
+    { __DRI2_FLUSH, __DRI2_FLUSH_VERSION },
+    dri2_flush_drawable,
+    dri2_invalidate_drawable,
+};
+
+/**
+ * Retrieve __DRIbuffer from the DRI loader.
+ */
+static __DRIbuffer *
+dri2_drawable_get_buffers(struct dri_drawable *drawable,
+                          const enum st_attachment_type *statts,
+                          unsigned *count)
+{
+   __DRIdrawable *dri_drawable = drawable->dPriv;
+   struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
+   boolean with_format;
+   __DRIbuffer *buffers;
+   int num_buffers;
+   unsigned attachments[10];
+   unsigned num_attachments, i;
+
+   assert(loader);
+   with_format = dri_with_format(drawable->sPriv);
+
+   num_attachments = 0;
+
+   /* for Xserver 1.6.0 (DRI2 version 1) we always need to ask for the front */
+   if (!with_format)
+      attachments[num_attachments++] = __DRI_BUFFER_FRONT_LEFT;
+
+   for (i = 0; i < *count; i++) {
+      enum pipe_format format;
+      unsigned bind;
+      int att, bpp;
+
+      dri_drawable_get_format(drawable, statts[i], &format, &bind);
+      if (format == PIPE_FORMAT_NONE)
+         continue;
+
+      switch (statts[i]) {
+      case ST_ATTACHMENT_FRONT_LEFT:
+         /* already added */
+         if (!with_format)
+            continue;
+         att = __DRI_BUFFER_FRONT_LEFT;
+         break;
+      case ST_ATTACHMENT_BACK_LEFT:
+         att = __DRI_BUFFER_BACK_LEFT;
+         break;
+      case ST_ATTACHMENT_FRONT_RIGHT:
+         att = __DRI_BUFFER_FRONT_RIGHT;
+         break;
+      case ST_ATTACHMENT_BACK_RIGHT:
+         att = __DRI_BUFFER_BACK_RIGHT;
+         break;
+      case ST_ATTACHMENT_DEPTH_STENCIL:
+         att = __DRI_BUFFER_DEPTH_STENCIL;
+         break;
+      default:
+         att = -1;
+         break;
+      }
+
+      bpp = util_format_get_blocksizebits(format);
+
+      if (att >= 0) {
+         attachments[num_attachments++] = att;
+         if (with_format) {
+            attachments[num_attachments++] = bpp;
+         }
+      }
+   }
+
+   if (with_format) {
+      num_attachments /= 2;
+      buffers = loader->getBuffersWithFormat(dri_drawable,
+            &dri_drawable->w, &dri_drawable->h,
+            attachments, num_attachments,
+            &num_buffers, dri_drawable->loaderPrivate);
+   }
+   else {
+      buffers = loader->getBuffers(dri_drawable,
+            &dri_drawable->w, &dri_drawable->h,
+            attachments, num_attachments,
+            &num_buffers, dri_drawable->loaderPrivate);
+   }
+
+   if (buffers) {
+      /* set one cliprect to cover the whole dri_drawable */
+      dri_drawable->x = 0;
+      dri_drawable->y = 0;
+      dri_drawable->backX = 0;
+      dri_drawable->backY = 0;
+      dri_drawable->numClipRects = 1;
+      dri_drawable->pClipRects[0].x1 = 0;
+      dri_drawable->pClipRects[0].y1 = 0;
+      dri_drawable->pClipRects[0].x2 = dri_drawable->w;
+      dri_drawable->pClipRects[0].y2 = dri_drawable->h;
+      dri_drawable->numBackClipRects = 1;
+      dri_drawable->pBackClipRects[0].x1 = 0;
+      dri_drawable->pBackClipRects[0].y1 = 0;
+      dri_drawable->pBackClipRects[0].x2 = dri_drawable->w;
+      dri_drawable->pBackClipRects[0].y2 = dri_drawable->h;
+
+      *count = num_buffers;
+   }
+
+   return buffers;
+}
+
+/**
+ * Process __DRIbuffer and convert them into pipe_resources.
+ */
+static void
+dri2_drawable_process_buffers(struct dri_drawable *drawable,
+                              __DRIbuffer *buffers, unsigned count)
+{
+   struct dri_screen *screen = dri_screen(drawable->sPriv);
+   __DRIdrawable *dri_drawable = drawable->dPriv;
+   struct pipe_resource templ;
+   struct winsys_handle whandle;
+   boolean have_depth = FALSE;
+   unsigned i, bind;
+
+   if (drawable->old_num == count &&
+       drawable->old_w == dri_drawable->w &&
+       drawable->old_h == dri_drawable->h &&
+       memcmp(drawable->old, buffers, sizeof(__DRIbuffer) * count) == 0)
+      return;
+
+   for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+      pipe_resource_reference(&drawable->textures[i], NULL);
+
+   memset(&templ, 0, sizeof(templ));
+   templ.target = screen->target;
+   templ.last_level = 0;
+   templ.width0 = dri_drawable->w;
+   templ.height0 = dri_drawable->h;
+   templ.depth0 = 1;
+   templ.array_size = 1;
+
+   memset(&whandle, 0, sizeof(whandle));
+
+   for (i = 0; i < count; i++) {
+      __DRIbuffer *buf = &buffers[i];
+      enum st_attachment_type statt;
+      enum pipe_format format;
+
+      switch (buf->attachment) {
+      case __DRI_BUFFER_FRONT_LEFT:
+         if (!screen->auto_fake_front) {
+            statt = ST_ATTACHMENT_INVALID;
+            break;
+         }
+         /* fallthrough */
+      case __DRI_BUFFER_FAKE_FRONT_LEFT:
+         statt = ST_ATTACHMENT_FRONT_LEFT;
+         break;
+      case __DRI_BUFFER_BACK_LEFT:
+         statt = ST_ATTACHMENT_BACK_LEFT;
+         break;
+      case __DRI_BUFFER_DEPTH:
+      case __DRI_BUFFER_DEPTH_STENCIL:
+      case __DRI_BUFFER_STENCIL:
+         /* use only the first depth/stencil buffer */
+         if (!have_depth) {
+            have_depth = TRUE;
+            statt = ST_ATTACHMENT_DEPTH_STENCIL;
+         }
+         else {
+            statt = ST_ATTACHMENT_INVALID;
+         }
+         break;
+      default:
+         statt = ST_ATTACHMENT_INVALID;
+         break;
+      }
+
+      dri_drawable_get_format(drawable, statt, &format, &bind);
+      if (statt == ST_ATTACHMENT_INVALID || format == PIPE_FORMAT_NONE)
+         continue;
+
+      templ.format = format;
+      templ.bind = bind;
+      whandle.handle = buf->name;
+      whandle.stride = buf->pitch;
+
+      drawable->textures[statt] =
+         screen->base.screen->resource_from_handle(screen->base.screen,
+               &templ, &whandle);
+   }
+
+   drawable->old_num = count;
+   drawable->old_w = dri_drawable->w;
+   drawable->old_h = dri_drawable->h;
+   memcpy(drawable->old, buffers, sizeof(__DRIbuffer) * count);
+}
+
+/*
+ * Backend functions for st_framebuffer interface.
+ */
+
+static void
+dri2_allocate_textures(struct dri_drawable *drawable,
+                       const enum st_attachment_type *statts,
+                       unsigned count)
+{
+   __DRIbuffer *buffers;
+   unsigned num_buffers = count;
+
+   buffers = dri2_drawable_get_buffers(drawable, statts, &num_buffers);
+   if (buffers)
+      dri2_drawable_process_buffers(drawable, buffers, num_buffers);
+}
+
+static void
+dri2_flush_frontbuffer(struct dri_drawable *drawable,
+                       enum st_attachment_type statt)
+{
+   __DRIdrawable *dri_drawable = drawable->dPriv;
+   struct __DRIdri2LoaderExtensionRec *loader = drawable->sPriv->dri2.loader;
+
+   if (loader->flushFrontBuffer == NULL)
+      return;
+
+   if (statt == ST_ATTACHMENT_FRONT_LEFT) {
+      loader->flushFrontBuffer(dri_drawable, dri_drawable->loaderPrivate);
+   }
+}
+
+static __DRIimage *
+dri2_lookup_egl_image(struct dri_screen *screen, void *handle)
+{
+   __DRIimageLookupExtension *loader = screen->sPriv->dri2.image;
+   __DRIimage *img;
+
+   if (!loader->lookupEGLImage)
+      return NULL;
+
+   img = loader->lookupEGLImage(screen->sPriv,
+				handle, screen->sPriv->loaderPrivate);
+
+   return img;
+}
+
+static __DRIimage *
+dri2_create_image_from_name(__DRIscreen *_screen,
+                            int width, int height, int format,
+                            int name, int pitch, void *loaderPrivate)
+{
+   struct dri_screen *screen = dri_screen(_screen);
+   __DRIimage *img;
+   struct pipe_resource templ;
+   struct winsys_handle whandle;
+   unsigned tex_usage;
+   enum pipe_format pf;
+
+   tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
+
+   switch (format) {
+   case __DRI_IMAGE_FORMAT_RGB565:
+      pf = PIPE_FORMAT_B5G6R5_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_XRGB8888:
+      pf = PIPE_FORMAT_B8G8R8X8_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_ARGB8888:
+      pf = PIPE_FORMAT_B8G8R8A8_UNORM;
+      break;
+   default:
+      pf = PIPE_FORMAT_NONE;
+      break;
+   }
+   if (pf == PIPE_FORMAT_NONE)
+      return NULL;
+
+   img = CALLOC_STRUCT(__DRIimageRec);
+   if (!img)
+      return NULL;
+
+   memset(&templ, 0, sizeof(templ));
+   templ.bind = tex_usage;
+   templ.format = pf;
+   templ.target = screen->target;
+   templ.last_level = 0;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+   templ.array_size = 1;
+
+   memset(&whandle, 0, sizeof(whandle));
+   whandle.handle = name;
+   whandle.stride = pitch * util_format_get_blocksize(pf);
+
+   img->texture = screen->base.screen->resource_from_handle(screen->base.screen,
+         &templ, &whandle);
+   if (!img->texture) {
+      FREE(img);
+      return NULL;
+   }
+
+   img->level = 0;
+   img->layer = 0;
+   img->loader_private = loaderPrivate;
+
+   return img;
+}
+
+static __DRIimage *
+dri2_create_image_from_renderbuffer(__DRIcontext *context,
+				    int renderbuffer, void *loaderPrivate)
+{
+   struct dri_context *ctx = dri_context(context->driverPrivate);
+
+   if (!ctx->st->get_resource_for_egl_image)
+      return NULL;
+
+   /* TODO */
+   return NULL;
+}
+
+static __DRIimage *
+dri2_create_image(__DRIscreen *_screen,
+                   int width, int height, int format,
+                   unsigned int use, void *loaderPrivate)
+{
+   struct dri_screen *screen = dri_screen(_screen);
+   __DRIimage *img;
+   struct pipe_resource templ;
+   unsigned tex_usage;
+   enum pipe_format pf;
+
+   tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
+
+   switch (format) {
+   case __DRI_IMAGE_FORMAT_RGB565:
+      pf = PIPE_FORMAT_B5G6R5_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_XRGB8888:
+      pf = PIPE_FORMAT_B8G8R8X8_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_ARGB8888:
+      pf = PIPE_FORMAT_B8G8R8A8_UNORM;
+      break;
+   default:
+      pf = PIPE_FORMAT_NONE;
+      break;
+   }
+   if (pf == PIPE_FORMAT_NONE)
+      return NULL;
+
+   img = CALLOC_STRUCT(__DRIimageRec);
+   if (!img)
+      return NULL;
+
+   memset(&templ, 0, sizeof(templ));
+   templ.bind = tex_usage;
+   templ.format = pf;
+   templ.target = PIPE_TEXTURE_2D;
+   templ.last_level = 0;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+
+   img->texture = screen->base.screen->resource_create(screen->base.screen, &templ);
+   if (!img->texture) {
+      FREE(img);
+      return NULL;
+   }
+
+   img->level = 0;
+   img->layer = 0;
+
+   img->loader_private = loaderPrivate;
+   return img;
+}
+
+static GLboolean
+dri2_query_image(__DRIimage *image, int attrib, int *value)
+{
+   struct winsys_handle whandle;
+   memset(&whandle, 0, sizeof(whandle));
+
+   switch (attrib) {
+   case __DRI_IMAGE_ATTRIB_STRIDE:
+      image->texture->screen->resource_get_handle(image->texture->screen,
+            image->texture, &whandle);
+      *value = whandle.stride;
+      return GL_TRUE;
+   case __DRI_IMAGE_ATTRIB_HANDLE:
+      whandle.type = DRM_API_HANDLE_TYPE_KMS;
+      image->texture->screen->resource_get_handle(image->texture->screen,
+         image->texture, &whandle);
+      *value = whandle.handle;
+      return GL_TRUE;
+   case __DRI_IMAGE_ATTRIB_NAME:
+      whandle.type = DRM_API_HANDLE_TYPE_SHARED;
+      image->texture->screen->resource_get_handle(image->texture->screen,
+         image->texture, &whandle);
+      *value = whandle.handle;
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+static void
+dri2_destroy_image(__DRIimage *img)
+{
+   pipe_resource_reference(&img->texture, NULL);
+   FREE(img);
+}
+
+static struct __DRIimageExtensionRec dri2ImageExtension = {
+    { __DRI_IMAGE, __DRI_IMAGE_VERSION },
+    dri2_create_image_from_name,
+    dri2_create_image_from_renderbuffer,
+    dri2_destroy_image,
+    dri2_create_image,
+    dri2_query_image,
+};
+
+/*
+ * Backend function init_screen.
+ */
+
+static const __DRIextension *dri_screen_extensions[] = {
+   &driReadDrawableExtension,
+   &driCopySubBufferExtension.base,
+   &driSwapControlExtension.base,
+   &driMediaStreamCounterExtension.base,
+   &driTexBufferExtension.base,
+   &dri2FlushExtension.base,
+   &dri2ImageExtension.base,
+   &dri2ConfigQueryExtension.base,
+   NULL
+};
+
+/**
+ * This is the driver specific part of the createNewScreen entry point.
+ *
+ * Returns the struct gl_config supported by this driver.
+ */
+static const __DRIconfig **
+dri2_init_screen(__DRIscreen * sPriv)
+{
+   const __DRIconfig **configs;
+   struct dri_screen *screen;
+   struct pipe_screen *pscreen;
+
+   screen = CALLOC_STRUCT(dri_screen);
+   if (!screen)
+      return NULL;
+
+   screen->sPriv = sPriv;
+   screen->fd = sPriv->fd;
+
+   sPriv->private = (void *)screen;
+   sPriv->extensions = dri_screen_extensions;
+
+   pscreen = driver_descriptor.create_screen(screen->fd);
+   /* dri_init_screen_helper checks pscreen for us */
+
+   configs = dri_init_screen_helper(screen, pscreen, 32);
+   if (!configs)
+      goto fail;
+
+   sPriv->api_mask = 0;
+   if (screen->st_api->profile_mask & ST_PROFILE_DEFAULT_MASK)
+      sPriv->api_mask |= 1 << __DRI_API_OPENGL;
+   if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES1_MASK)
+      sPriv->api_mask |= 1 << __DRI_API_GLES;
+   if (screen->st_api->profile_mask & ST_PROFILE_OPENGL_ES2_MASK)
+      sPriv->api_mask |= 1 << __DRI_API_GLES2;
+
+   screen->auto_fake_front = dri_with_format(sPriv);
+   screen->broken_invalidate = !sPriv->dri2.useInvalidate;
+   screen->lookup_egl_image = dri2_lookup_egl_image;
+
+   return configs;
+fail:
+   dri_destroy_screen_helper(screen);
+   FREE(screen);
+   return NULL;
+}
+
+static boolean
+dri2_create_context(gl_api api, const struct gl_config * visual,
+                    __DRIcontext * cPriv, void *sharedContextPrivate)
+{
+   struct dri_context *ctx = NULL;
+
+   if (!dri_create_context(api, visual, cPriv, sharedContextPrivate))
+      return FALSE;
+
+   ctx = cPriv->driverPrivate;
+
+   return TRUE;
+}
+
+static boolean
+dri2_create_buffer(__DRIscreen * sPriv,
+                   __DRIdrawable * dPriv,
+                   const struct gl_config * visual, boolean isPixmap)
+{
+   struct dri_drawable *drawable = NULL;
+
+   if (!dri_create_buffer(sPriv, dPriv, visual, isPixmap))
+      return FALSE;
+
+   drawable = dPriv->driverPrivate;
+
+   drawable->allocate_textures = dri2_allocate_textures;
+   drawable->flush_frontbuffer = dri2_flush_frontbuffer;
+
+   return TRUE;
+}
+
+/**
+ * DRI driver virtual function table.
+ *
+ * DRI versions differ in their implementation of init_screen and swap_buffers.
+ */
+const struct __DriverAPIRec driDriverAPI = {
+   .InitScreen = NULL,
+   .InitScreen2 = dri2_init_screen,
+   .DestroyScreen = dri_destroy_screen,
+   .CreateContext = dri2_create_context,
+   .DestroyContext = dri_destroy_context,
+   .CreateBuffer = dri2_create_buffer,
+   .DestroyBuffer = dri_destroy_buffer,
+   .MakeCurrent = dri_make_current,
+   .UnbindContext = dri_unbind_context,
+
+   .GetSwapInfo = NULL,
+   .GetDrawableMSC = NULL,
+   .WaitForMSC = NULL,
+
+   .SwapBuffers = NULL,
+   .CopySubBuffer = NULL,
+};
+
+/* This is the table of extensions that the loader will dlsym() for. */
+PUBLIC const __DRIextension *__driDriverExtensions[] = {
+    &driCoreExtension.base,
+    &driLegacyExtension.base,
+    &driDRI2Extension.base,
+    NULL
+};
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/sw/Makefile b/dist/Mesa/src/gallium/state_trackers/dri/sw/Makefile
new file mode 100644
index 000000000..33bc0ed9c
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/sw/Makefile
@@ -0,0 +1,25 @@
+TOP = ../../../../..
+include $(TOP)/configs/current
+
+LIBNAME = drisw
+
+LIBRARY_DEFINES = -D__NOT_HAVE_DRM_H
+
+LIBRARY_INCLUDES = \
+	-I../dri \
+	-I$(TOP)/include \
+	-I$(TOP)/src/mapi \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/src/gallium/state_trackers/dri/common \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+	-I$(TOP)/src/mesa/main \
+	-D__NOT_HAVE_DRM_H
+
+
+C_SOURCES = \
+	dri_context.c \
+	dri_screen.c \
+	dri_drawable.c \
+	drisw.c
+
+include ../../../Makefile.template
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/sw/SConscript b/dist/Mesa/src/gallium/state_trackers/dri/sw/SConscript
new file mode 100644
index 000000000..d0c3efc6f
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/sw/SConscript
@@ -0,0 +1,28 @@
+#######################################################################
+# SConscript for dri state_tracker
+
+Import('*')
+
+env = env.Clone()
+
+env.Append(CPPPATH = [
+    '#/src/mapi',
+    '#/src/mesa',
+    '#/src/gallium/state_trackers/dri/common',
+    '#/src/mesa/drivers/dri/common',
+])
+
+env.Append(CPPDEFINES = [('__NOT_HAVE_DRM_H', '1')])
+
+sources = [
+    'dri_context.c',
+    'dri_drawable.c',
+    'dri_screen.c',
+    'drisw.c',
+]
+
+st_drisw = env.ConvenienceLibrary(
+    target = 'st_drisw',
+    source = sources,
+)
+Export('st_drisw')
diff --git a/dist/Mesa/src/gallium/state_trackers/dri/sw/drisw.c b/dist/Mesa/src/gallium/state_trackers/dri/sw/drisw.c
new file mode 100644
index 000000000..30088b096
--- /dev/null
+++ b/dist/Mesa/src/gallium/state_trackers/dri/sw/drisw.c
@@ -0,0 +1,320 @@
+/**************************************************************************
+ *
+ * Copyright 2009, VMware, Inc.
+ * All Rights Reserved.
+ * Copyright 2010 George Sapountzis <gsapountzis@gmail.com>
+ *
+ * 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.
+ *
+ **************************************************************************/
+
+/* TODO:
+ *
+ * xshm / texture_from_pixmap / EGLImage:
+ *
+ * Allow the loaders to use the XSHM extension. It probably requires callbacks
+ * for createImage/destroyImage similar to DRI2 getBuffers.
+ */
+
+#include "util/u_format.h"
+#include "util/u_memory.h"
+#include "util/u_inlines.h"
+#include "pipe/p_context.h"
+#include "state_tracker/drisw_api.h"
+
+#include "dri_screen.h"
+#include "dri_context.h"
+#include "dri_drawable.h"
+
+DEBUG_GET_ONCE_BOOL_OPTION(swrast_no_present, "SWRAST_NO_PRESENT", FALSE);
+static boolean swrast_no_present = FALSE;
+
+static INLINE void
+get_drawable_info(__DRIdrawable *dPriv, int *w, int *h)
+{
+   __DRIscreen *sPriv = dPriv->driScreenPriv;
+   const __DRIswrastLoaderExtension *loader = sPriv->swrast_loader;
+   int x, y;
+
+   loader->getDrawableInfo(dPriv,
+                           &x, &y, w, h,
+                           dPriv->loaderPrivate);
+}
+
+static INLINE void
+put_image(__DRIdrawable *dPriv, void *data, unsigned width, unsigned height)
+{
+   __DRIscreen *sPriv = dPriv->driScreenPriv;
+   const __DRIswrastLoaderExtension *loader = sPriv->swrast_loader;
+
+   loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,
+                    0, 0, width, height,
+                    data, dPriv->loaderPrivate);
+}
+
+static void
+drisw_update_drawable_info(struct dri_drawable *drawable)
+{
+   __DRIdrawable *dPriv = drawable->dPriv;
+
+   get_drawable_info(dPriv, &dPriv->w, &dPriv->h);
+}
+
+static void
+drisw_put_image(struct dri_drawable *drawable,
+                void *data, unsigned width, unsigned height)
+{
+   __DRIdrawable *dPriv = drawable->dPriv;
+
+   put_image(dPriv, data, width, height);
+}
+
+static INLINE void
+drisw_present_texture(__DRIdrawable *dPriv,
+                      struct pipe_resource *ptex)
+{
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+   struct dri_screen *screen = dri_screen(drawable->sPriv);
+
+   if (swrast_no_present)
+      return;
+
+   screen->base.screen->flush_frontbuffer(screen->base.screen, ptex, 0, 0, drawable);
+}
+
+static INLINE void
+drisw_invalidate_drawable(__DRIdrawable *dPriv)
+{
+   struct dri_context *ctx = dri_get_current(dPriv->driScreenPriv);
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+
+   drawable->texture_stamp = dPriv->lastStamp - 1;
+
+   /* check if swapping currently bound buffer */
+   if (ctx && ctx->dPriv == dPriv)
+      ctx->st->notify_invalid_framebuffer(ctx->st, &drawable->base);
+}
+
+static INLINE void
+drisw_copy_to_front(__DRIdrawable * dPriv,
+                    struct pipe_resource *ptex)
+{
+   drisw_present_texture(dPriv, ptex);
+
+   drisw_invalidate_drawable(dPriv);
+}
+
+/*
+ * Backend functions for st_framebuffer interface and swap_buffers.
+ */
+
+static void
+drisw_swap_buffers(__DRIdrawable *dPriv)
+{
+   struct dri_context *ctx = dri_get_current(dPriv->driScreenPriv);
+   struct dri_drawable *drawable = dri_drawable(dPriv);
+   struct pipe_resource *ptex;
+
+   if (!ctx)
+      return;
+
+   ptex = drawable->textures[ST_ATTACHMENT_BACK_LEFT];
+
+   if (ptex) {
+      ctx->st->flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+      drisw_copy_to_front(dPriv, ptex);
+   }
+}
+
+static void
+drisw_flush_frontbuffer(struct dri_drawable *drawable,
+                        enum st_attachment_type statt)
+{
+   struct dri_context *ctx = dri_get_current(drawable->sPriv);
+   struct pipe_resource *ptex;
+
+   if (!ctx)
+      return;
+
+   ptex = drawable->textures[statt];
+
+   if (ptex) {
+      drisw_copy_to_front(ctx->dPriv, ptex);
+   }
+}
+
+/**
+ * Allocate framebuffer attachments.
+ *
+ * During fixed-size operation, the function keeps allocating new attachments
+ * as they are requested. Unused attachments are not removed, not until the
+ * framebuffer is resized or destroyed.
+ */
+static void
+drisw_allocate_textures(struct dri_drawable *drawable,
+                        const enum st_attachment_type *statts,
+                        unsigned count)
+{
+   struct dri_screen *screen = dri_screen(drawable->sPriv);
+   struct pipe_resource templ;
+   unsigned width, height;
+   boolean resized;
+   unsigned i;
+
+   width  = drawable->dPriv->w;
+   height = drawable->dPriv->h;
+
+   resized = (drawable->old_w != width ||
+              drawable->old_h != height);
+
+   /* remove outdated textures */
+   if (resized) {
+      for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+         pipe_resource_reference(&drawable->textures[i], NULL);
+   }
+
+   memset(&templ, 0, sizeof(templ));
+   templ.target = screen->target;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+   templ.array_size = 1;
+   templ.last_level = 0;
+
+   for (i = 0; i < count; i++) {
+      enum pipe_format format;
+      unsigned bind;
+
+      /* the texture already exists or not requested */
+      if (drawable->textures[statts[i]])
+         continue;
+
+      dri_drawable_get_format(drawable, statts[i], &format, &bind);
+
+      /* if we don't do any present, no need for display targets */
+      if (statts[i] != ST_ATTACHMENT_DEPTH_STENCIL && !swrast_no_present)
+         bind |= PIPE_BIND_DISPLAY_TARGET;
+
+      if (format == PIPE_FORMAT_NONE)
+         continue;
+
+      templ.format = format;
+      templ.bind = bind;
+
+      drawable->textures[statts[i]] =
+         screen->base.screen->resource_create(screen->base.screen, &templ);
+   }
+
+   drawable->old_w = width;
+   drawable->old_h = height;
+}
+
+/*
+ * Backend function for init_screen.
+ */
+
+static const __DRIextension *drisw_screen_extensions[] = {
+   NULL
+};
+
+static struct drisw_loader_funcs drisw_lf = {
+   .put_image = drisw_put_image
+};
+
+static const __DRIconfig **
+drisw_init_screen(__DRIscreen * sPriv)
+{
+   const __DRIconfig **configs;
+   struct dri_screen *screen;
+   struct pipe_screen *pscreen;
+
+   screen = CALLOC_STRUCT(dri_screen);
+   if (!screen)
+      return NULL;
+
+   screen->sPriv = sPriv;
+   screen->fd = -1;
+
+   swrast_no_present = debug_get_option_swrast_no_present();
+
+   sPriv->private = (void *)screen;
+   sPriv->extensions = drisw_screen_extensions;
+
+   pscreen = drisw_create_screen(&drisw_lf);
+   /* dri_init_screen_helper checks pscreen for us */
+
+   configs = dri_init_screen_helper(screen, pscreen, 32);
+   if (!configs)
+      goto fail;
+
+   return configs;
+fail:
+   dri_destroy_screen_helper(screen);
+   FREE(screen);
+   return NULL;
+}
+
+static boolean
+drisw_create_buffer(__DRIscreen * sPriv,
+                    __DRIdrawable * dPriv,
+                    const struct gl_config * visual, boolean isPixmap)
+{
+   struct dri_drawable *drawable = NULL;
+
+   if (!dri_create_buffer(sPriv, dPriv, visual, isPixmap))
+      return FALSE;
+
+   drawable = dPriv->driverPrivate;
+
+   drawable->allocate_textures = drisw_allocate_textures;
+   drawable->update_drawable_info = drisw_update_drawable_info;
+   drawable->flush_frontbuffer = drisw_flush_frontbuffer;
+
+   return TRUE;
+}
+
+/**
+ * DRI driver virtual function table.
+ *
+ * DRI versions differ in their implementation of init_screen and swap_buffers.
+ */
+const struct __DriverAPIRec driDriverAPI = {
+   .InitScreen = drisw_init_screen,
+   .DestroyScreen = dri_destroy_screen,
+   .CreateContext = dri_create_context,
+   .DestroyContext = dri_destroy_context,
+   .CreateBuffer = drisw_create_buffer,
+   .DestroyBuffer = dri_destroy_buffer,
+   .MakeCurrent = dri_make_current,
+   .UnbindContext = dri_unbind_context,
+
+   .SwapBuffers = drisw_swap_buffers,
+};
+
+/* This is the table of extensions that the loader will dlsym() for. */
+PUBLIC const __DRIextension *__driDriverExtensions[] = {
+    &driCoreExtension.base,
+    &driSWRastExtension.base,
+    NULL
+};
+
+/* vim: set sw=3 ts=8 sts=3 expandtab: */