Import of XFree86 3.9.18X_3_9_18

91 files changed, 19714 insertions, 134 deletions

diff --git a/xc/lib/GL/mesa/dri/Imakefile b/xc/lib/GL/mesa/dri/Imakefile
new file mode 100644
index 000000000..f927089d2
--- /dev/null
+++ b/xc/lib/GL/mesa/dri/Imakefile
@@ -0,0 +1,42 @@
+XCOMM $XFree86: xc/lib/GL/mesa/dri/Imakefile,v 1.1 2000/02/08 17:18:35 dawes Exp $
+XCOMM $PI$
+
+#define DoNormalLib NormalLibGlx
+#define DoSharedLib SharedLibGlx
+#define DoExtraLib SharedLibGlx
+#define DoDebugLib DebugLibGlx
+#define DoProfileLib ProfileLibGlx
+
+#if Malloc0ReturnsNull
+ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
+#endif
+
+#if BuildXF86DRI
+  DRI_DEFINES = GlxDefines
+ DRI_INCLUDES = -I../../glx -I../../dri \
+		-I$(TOP)/include -I$(TOP)/include/GL \
+		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri
+#endif
+
+MESA_INCLUDES = -I. -I.. -I../include
+
+      DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
+     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(DRI_INCLUDES) $(MESA_INCLUDES)
+         SRCS = dri_mesa.c
+         OBJS = dri_mesa.o
+
+#if !GlxUseBuiltInDRIDriver
+#undef DoNormalLib NormalLibGlx
+#undef DoExtraLib SharedLibGlx
+#undef DoDebugLib DebugLibGlx
+#undef DoProfileLib ProfileLibGlx
+#endif
+
+#include <Library.tmpl>
+
+LibraryObjectRule()
+
+SubdirLibraryRule($(OBJS))
+NormalLintTarget($(SRCS))
+
+DependTarget()
diff --git a/xc/lib/GL/mesa/dri/dri_mesa.c b/xc/lib/GL/mesa/dri/dri_mesa.c
new file mode 100644
index 000000000..0e814b78c
--- /dev/null
+++ b/xc/lib/GL/mesa/dri/dri_mesa.c
@@ -0,0 +1,746 @@
+/* $XFree86: xc/lib/GL/mesa/dri/dri_mesa.c,v 1.4 2000/02/15 07:13:28 martin Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ * $PI: xc/lib/GL/dri/dri_mesa.c,v 1.18 1999/08/04 18:13:27 faith Exp $
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <unistd.h>
+#include <Xlibint.h>
+#include <Xext.h>
+#include <extutil.h>
+#include "glxclient.h"
+#include "GL/xmesa.h"
+#include "xf86dri.h"
+#include "sarea.h"
+#include "dri_mesaint.h"
+#include "dri_xmesaapi.h"
+#ifdef BRIAN
+#include <dlfcn.h>
+#endif
+
+
+#if XMESA_MAJOR_VERSION != 3 || XMESA_MINOR_VERSION != 3
+#error using wrong version of Mesa (need 3.3)
+#endif
+
+
+/* Context binding */
+static Bool driMesaBindContext(Display *dpy, int scrn,
+			       GLXDrawable draw, GLXContext gc);
+static Bool driMesaUnbindContext(Display *dpy, int scrn,
+				 GLXDrawable draw, GLXContext gc);
+
+/* Drawable methods */
+static void *driMesaCreateDrawable(Display *dpy, int scrn, GLXDrawable draw,
+				   VisualID vid, __DRIdrawable *pdraw);
+static __DRIdrawable *driMesaGetDrawable(Display *dpy, GLXDrawable draw);
+static void driMesaSwapBuffers(Display *dpy, void *private);
+static void driMesaDestroyDrawable(Display *dpy, void *private);
+
+/* Context methods */
+static void *driMesaCreateContext(Display *dpy, XVisualInfo *vis, void *shared,
+				  __DRIcontext *pctx);
+static void driMesaDestroyContext(Display *dpy, int scrn, void *private);
+
+/* Screen methods */
+static void *driMesaCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+				 int numConfigs, __GLXvisualConfig *config);
+static void driMesaDestroyScreen(Display *dpy, int scrn, void *private);
+
+
+/*****************************************************************/
+
+/* Maintain a list of drawables */
+
+void *drawHash = NULL; /* Hash table to hold DRI drawables */
+
+static Bool __driMesaAddDrawable(__DRIdrawable *pdraw)
+{
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
+
+    /* Create the hash table */
+    if (!drawHash) drawHash = drmHashCreate();
+
+    if (drmHashInsert(drawHash, pdp->draw, pdraw))
+	return GL_FALSE;
+
+    return GL_TRUE;
+}
+
+static __DRIdrawable *__driMesaFindDrawable(GLXDrawable draw)
+{
+    int retcode;
+    __DRIdrawable *pdraw;
+
+    /* Create the hash table */
+    if (!drawHash) drawHash = drmHashCreate();
+
+    retcode = drmHashLookup(drawHash, draw, (void **)&pdraw);
+    if (retcode)
+	return NULL;
+
+    return pdraw;
+}
+
+static void __driMesaRemoveDrawable(__DRIdrawable *pdraw)
+{
+    int retcode;
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
+
+    /* Create the hash table */
+    if (!drawHash) drawHash = drmHashCreate();
+
+    retcode = drmHashLookup(drawHash, pdp->draw, (void **)&pdraw);
+    if (!retcode) { /* Found */
+	drmHashDelete(drawHash, pdp->draw);
+    }
+}
+
+/*****************************************************************/
+
+static void driMesaInitAPI(__XMESAapi *XMesaAPI)
+{
+    XMesaAPI->InitDriver = XMesaInitDriver;
+    XMesaAPI->ResetDriver = XMesaResetDriver;
+    XMesaAPI->CreateVisual = XMesaCreateVisual;
+    XMesaAPI->DestroyVisual = XMesaDestroyVisual;
+    XMesaAPI->CreateContext = XMesaCreateContext;
+    XMesaAPI->DestroyContext = XMesaDestroyContext;
+    XMesaAPI->CreateWindowBuffer = XMesaCreateWindowBuffer;
+    XMesaAPI->CreatePixmapBuffer = XMesaCreatePixmapBuffer;
+    XMesaAPI->DestroyBuffer = XMesaDestroyBuffer;
+    XMesaAPI->SwapBuffers = XMesaSwapBuffers;
+    XMesaAPI->MakeCurrent = XMesaMakeCurrent;
+    XMesaAPI->UnbindContext = XMesaUnbindContext;
+}
+
+/*****************************************************************/
+
+static Bool driMesaUnbindContext(Display *dpy, int scrn,
+				 GLXDrawable draw, GLXContext gc)
+{
+    __DRIdrawable *pdraw;
+    __DRIcontextPrivate *pcp;
+    __DRIscreenPrivate *psp;
+    __DRIdrawablePrivate *pdp;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driMesaUnbindContext.
+    */
+
+    if (gc == NULL || draw == None) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pdraw = __driMesaFindDrawable(draw);
+    if (!pdraw) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pcp = (__DRIcontextPrivate *)gc->driContext.private;
+    pdp = (__DRIdrawablePrivate *)pdraw->private;
+    psp = pdp->driScreenPriv;
+    if (!psp) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    /* Unbind Mesa's drawable from Mesa's context */
+    (*psp->XMesaAPI.UnbindContext)(pcp->xm_ctx);
+
+    if (pdp->refcount == 0) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    } else if (--pdp->refcount == 0) {
+#if 0
+	/*
+	** NOT_DONE: When a drawable is unbound from one direct
+	** rendering context and then bound to another, we do not want
+	** to destroy the drawable data structure each time only to
+	** recreate it immediatly afterwards when binding to the next
+	** context.  This also causes conflicts with caching of the
+	** drawable stamp.
+	**
+	** When GLX 1.3 is integrated, the create and destroy drawable
+	** functions will have user level counterparts and the memory
+	** will be able to be recovered.
+	*/
+
+	/* Delete drawable if no longer referenced by any contexts */
+	(*pdraw->destroyDrawable)(dpy, pdraw->private);
+	__driMesaRemoveDrawable(pdraw);
+	Xfree(pdraw);
+#endif
+    }
+
+    /* Unbind the drawable */
+    pcp->driDrawablePriv = NULL;
+    pdp->driContextPriv = &psp->dummyContextPriv;
+
+    return GL_TRUE;
+}
+
+static Bool driMesaBindContext(Display *dpy, int scrn,
+			       GLXDrawable draw, GLXContext gc)
+{
+    __DRIdrawable *pdraw;
+    __DRIdrawablePrivate *pdp;
+    __DRIscreenPrivate *psp;
+    __DRIcontextPrivate *pcp;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driMesaBindContext.
+    */
+
+    if (gc == NULL || draw == None) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    pdraw = __driMesaFindDrawable(draw);
+    if (!pdraw) {
+	/* Allocate a new drawable */
+	pdraw = (__DRIdrawable *)Xmalloc(sizeof(__DRIdrawable));
+	if (!pdraw) {
+	    /* ERROR!!! */
+	    return GL_FALSE;
+	}
+
+	/* Create a new drawable */
+	pdraw->private = driMesaCreateDrawable(dpy, scrn, draw, gc->vid,
+					       pdraw);
+	if (!pdraw->private) {
+	    /* ERROR!!! */
+	    Xfree(pdraw);
+	    return GL_FALSE;
+	}
+
+	/* Add pdraw to drawable list */
+	if (!__driMesaAddDrawable(pdraw)) {
+	    /* ERROR!!! */
+	    (*pdraw->destroyDrawable)(dpy, pdraw->private);
+	    Xfree(pdraw);
+	    return GL_FALSE;
+	}
+    }
+
+    pdp = (__DRIdrawablePrivate *)pdraw->private;
+    psp = pdp->driScreenPriv;
+    if (!psp) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    /* Bind the drawable to the context */
+    pcp = (__DRIcontextPrivate *)gc->driContext.private;
+    pcp->driDrawablePriv = pdp;
+    pdp->driContextPriv = pcp;
+    pdp->refcount++;
+
+    /*
+    ** Now that we have a context associated with this drawable, we can
+    ** initialize the drawable information if has not been done before.
+    */
+    if (!pdp->pStamp) {
+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+	driMesaUpdateDrawableInfo(dpy, scrn, pdp);
+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+    }
+
+    /* Bind Mesa's drawable to Mesa's context */
+    (*psp->XMesaAPI.MakeCurrent)(pcp->xm_ctx, pdp->xm_buf);
+
+    return GL_TRUE;
+}
+
+/*****************************************************************/
+
+void driMesaUpdateDrawableInfo(Display *dpy, int scrn,
+			       __DRIdrawablePrivate *pdp)
+{
+    __DRIscreenPrivate *psp;
+    __DRIcontextPrivate *pcp = pdp->driContextPriv;
+    
+    if (!pcp || (pdp != pcp->driDrawablePriv)) {
+	/* ERROR!!! */
+	return;
+    }
+
+    psp = pdp->driScreenPriv;
+    if (!psp) {
+	/* ERROR!!! */
+	return;
+    }
+
+    if (pdp->pClipRects) {
+	Xfree(pdp->pClipRects); 
+    }
+
+    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+    if (!XF86DRIGetDrawableInfo(dpy, scrn, pdp->draw,
+				&pdp->index, &pdp->lastStamp,
+				&pdp->x, &pdp->y, &pdp->w, &pdp->h,
+				&pdp->numClipRects, &pdp->pClipRects)) {
+	pdp->numClipRects = 0;
+	pdp->pClipRects = NULL;
+	/* ERROR!!! */
+    }
+
+    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+    pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
+}
+
+/*****************************************************************/
+
+static void *driMesaCreateDrawable(Display *dpy, int scrn, GLXDrawable draw,
+				   VisualID vid, __DRIdrawable *pdraw)
+{
+    __DRIscreen *pDRIScreen;
+    __DRIscreenPrivate *psp;
+    __DRIdrawablePrivate *pdp;
+    int i;
+    XMesaVisual xm_vis = NULL;
+
+    pdp = (__DRIdrawablePrivate *)Xmalloc(sizeof(__DRIdrawablePrivate));
+    if (!pdp) {
+	return NULL;
+    }
+
+    if (!XF86DRICreateDrawable(dpy, scrn, draw, &pdp->hHWDrawable)) {
+	Xfree(pdp);
+	return NULL;
+    }
+
+    pdp->draw = draw;
+    pdp->refcount = 0;
+    pdp->pStamp = NULL;
+    pdp->lastStamp = 0;
+    pdp->index = 0;
+    pdp->x = 0;
+    pdp->y = 0;
+    pdp->w = 0;
+    pdp->h = 0;
+    pdp->numClipRects = 0;
+    pdp->pClipRects = NULL;
+
+    pDRIScreen = __glXFindDRIScreen(dpy, scrn);
+    pdp->driScreenPriv = psp = (__DRIscreenPrivate *)pDRIScreen->private;
+
+    pdp->driContextPriv = &psp->dummyContextPriv;
+
+    for (i = 0; i < psp->numVisuals; i++) {
+	if (vid == psp->visuals[i].vid) {
+	    xm_vis = psp->visuals[i].xm_vis;
+	    break;
+	}
+    }
+
+    if (1 /* NOT_DONE: Determine if it is a pixmap or not */) {
+	pdp->xm_buf = (*psp->XMesaAPI.CreateWindowBuffer)(xm_vis, draw, pdp);
+    } else {
+	XMesaVisual xm_vis = NULL;
+	XMesaColormap cmap = 0;
+	pdp->xm_buf = (*psp->XMesaAPI.CreatePixmapBuffer)(xm_vis, draw, cmap,
+							  pdp);
+    }
+    if (!pdp->xm_buf) {
+	(void)XF86DRIDestroyDrawable(dpy, scrn, pdp->draw);
+	Xfree(pdp);
+	return NULL;
+    }
+
+    pdraw->destroyDrawable = driMesaDestroyDrawable;
+    pdraw->swapBuffers = driMesaSwapBuffers;
+
+    return (void *)pdp;
+}
+
+static __DRIdrawable *driMesaGetDrawable(Display *dpy, GLXDrawable draw)
+{
+    /*
+    ** Make sure this routine returns NULL if the drawable is not bound
+    ** to a direct rendering context!
+    */
+    return __driMesaFindDrawable(draw);
+}
+
+static void driMesaSwapBuffers(Display *dpy, void *private)
+{
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)private;
+    __DRIscreenPrivate *psp = pdp->driScreenPriv;
+
+    (*psp->XMesaAPI.SwapBuffers)(pdp->xm_buf);
+}
+
+static void driMesaDestroyDrawable(Display *dpy, void *private)
+{
+    __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)private;
+    __DRIscreenPrivate *psp = pdp->driScreenPriv;
+    int scrn = psp->myNum;
+
+    if (pdp) {
+	(*psp->XMesaAPI.DestroyBuffer)(pdp->xm_buf);
+	(void)XF86DRIDestroyDrawable(dpy, scrn, pdp->draw);
+	if (pdp->pClipRects)
+	    Xfree(pdp->pClipRects);
+	Xfree(pdp);
+    }
+}
+
+/*****************************************************************/
+
+static void *driMesaCreateContext(Display *dpy, XVisualInfo *vis, void *shared,
+				  __DRIcontext *pctx)
+{
+    __DRIcontextPrivate *pcp;
+    __DRIcontextPrivate *pshare = (__DRIcontextPrivate *)shared;
+    XMesaContext shared_xm_ctx = (pshare ?
+				  pshare->xm_ctx : (XMesaContext)NULL);
+    __DRIscreenPrivate *psp;
+    __DRIscreen *pDRIScreen;
+    int i;
+
+    pDRIScreen = __glXFindDRIScreen(dpy, vis->screen);
+    psp = (__DRIscreenPrivate *)pDRIScreen->private;
+
+    if (!psp->dummyContextPriv.driScreenPriv) {
+	if (!XF86DRICreateContext(dpy, vis->screen, vis->visual,
+				  &psp->dummyContextPriv.contextID,
+				  &psp->dummyContextPriv.hHWContext)) {
+	    return NULL;
+	}
+	psp->dummyContextPriv.driScreenPriv = psp;
+	psp->dummyContextPriv.xm_ctx = NULL;
+	psp->dummyContextPriv.driDrawablePriv = NULL;
+	/* No other fields should be used! */
+    }
+
+    pcp = (__DRIcontextPrivate *)Xmalloc(sizeof(__DRIcontextPrivate));
+    if (!pcp) {
+	return NULL;
+    }
+
+    pcp->driScreenPriv = psp;
+    pcp->xm_ctx = NULL;
+    pcp->driDrawablePriv = NULL;
+
+    if (!XF86DRICreateContext(dpy, vis->screen, vis->visual,
+			      &pcp->contextID, &pcp->hHWContext)) {
+	Xfree(pcp);
+	return NULL;
+    }
+
+    for (i = 0; i < psp->numVisuals; i++)
+	if (psp->visuals[i].vid == vis->visualid)
+	    pcp->xm_ctx = (*psp->XMesaAPI.CreateContext)
+		(psp->visuals[i].xm_vis, shared_xm_ctx, pcp);
+
+    if (!pcp->xm_ctx) {
+	(void)XF86DRIDestroyContext(dpy, vis->screen, pcp->contextID);
+	Xfree(pcp);
+	return NULL;
+    }
+
+    pctx->destroyContext = driMesaDestroyContext;
+    pctx->bindContext    = driMesaBindContext;
+    pctx->unbindContext  = driMesaUnbindContext;
+
+    return pcp;
+}
+
+static void driMesaDestroyContext(Display *dpy, int scrn, void *private)
+{
+    __DRIcontextPrivate *pcp = (__DRIcontextPrivate *)private;
+
+    if (pcp) {
+	(void)XF86DRIDestroyContext(dpy, scrn, pcp->contextID);
+	(*pcp->driScreenPriv->XMesaAPI.DestroyContext)(pcp->xm_ctx);
+	Xfree(pcp);
+    }
+}
+
+/*****************************************************************/
+
+static void *driMesaCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+				 int numConfigs, __GLXvisualConfig *config)
+{
+    int directCapable, i, n;
+    __DRIscreenPrivate *psp;
+    XVisualInfo visTmpl, *visinfo;
+    drmHandle hFB, hSAREA;
+    char *BusID, *driverName;
+    drmMagic magic;
+
+    if (!XF86DRIQueryDirectRenderingCapable(dpy, scrn, &directCapable)) {
+	return NULL;
+    }
+
+    if (!directCapable) {
+	return NULL;
+    }
+
+    psp = (__DRIscreenPrivate *)Xmalloc(sizeof(__DRIscreenPrivate));
+    if (!psp) {
+	return NULL;
+    }
+
+    psp->myNum = scrn;
+
+    if (!XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
+	Xfree(psp);
+	return NULL;
+    }
+
+    /*
+    ** NOT_DONE: This is used by the X server to detect when the client
+    ** has died while holding the drawable lock.  The client sets the
+    ** drawable lock to this value.
+    */
+    psp->drawLockID = 1;
+
+    psp->fd = drmOpen(NULL,BusID);
+    if (!psp->fd) {
+	Xfree(BusID);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+    Xfree(BusID); /* No longer needed */
+
+    if (drmGetMagic(psp->fd, &magic)) {
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    if (!XF86DRIAuthConnection(dpy, scrn, magic)) {
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    if (!XF86DRIGetClientDriverName(dpy, scrn,
+				    &psp->major,
+				    &psp->minor,
+				    &psp->patch,
+				    &driverName)) {
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    driMesaInitAPI(&psp->XMesaAPI);
+
+    if (!XF86DRIGetDeviceInfo(dpy, scrn,
+			      &hFB,
+			      &psp->fbOrigin,
+			      &psp->fbSize,
+			      &psp->fbStride,
+			      &psp->devPrivSize,
+			      &psp->pDevPriv)) {
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+    psp->fbWidth = DisplayWidth(dpy, scrn);
+    psp->fbHeight = DisplayHeight(dpy, scrn);
+    psp->fbBPP = 32; /* NOT_DONE: Get this from X server */
+
+    if (drmMap(psp->fd, hFB, psp->fbSize, (drmAddressPtr)&psp->pFB)) {
+	Xfree(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    if (drmMap(psp->fd, hSAREA, SAREA_MAX, (drmAddressPtr)&psp->pSAREA)) {
+	(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	Xfree(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    psp->numVisuals = numConfigs;
+    psp->visuals = (__DRIvisualPrivate *)Xmalloc(numConfigs *
+						 sizeof(__DRIvisualPrivate));
+    if (!psp->visuals) {
+	(void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	Xfree(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    visTmpl.screen = scrn;
+    visinfo = XGetVisualInfo(dpy, VisualScreenMask, &visTmpl, &n);
+    if (n != numConfigs) {
+	(void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	Xfree(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+	(void)XF86DRICloseConnection(dpy, scrn);
+	return NULL;
+    }
+
+    for (i = 0; i < numConfigs; i++, config++) {
+	psp->visuals[i].vid = visinfo[i].visualid;
+	psp->visuals[i].xm_vis =
+	    (*psp->XMesaAPI.CreateVisual)(dpy,
+					  &visinfo[i],
+					  config->rgba,
+					  (config->alphaSize > 0),
+					  config->doubleBuffer,
+					  config->stereo,
+					  GL_TRUE, /* ximage_flag */
+					  config->depthSize,
+					  config->stencilSize,
+					  config->accumRedSize,
+					  config->level);
+	if (!psp->visuals[i].xm_vis) {
+	    /* Free the visuals so far created */
+	    while (--i >= 0) {
+		(*psp->XMesaAPI.DestroyVisual)(psp->visuals[i].xm_vis);
+	    }
+	    Xfree(psp->visuals);
+	    XFree(visinfo);
+	    (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	    (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	    Xfree(psp->pDevPriv);
+	    (void)drmClose(psp->fd);
+	    Xfree(psp);
+	    (void)XF86DRICloseConnection(dpy, scrn);
+	    return NULL;
+	}
+    }
+    XFree(visinfo);
+
+    /* Initialize the screen specific GLX driver */
+    if (psp->XMesaAPI.InitDriver) {
+	if (!(*psp->XMesaAPI.InitDriver)(psp)) {
+	    while (--psp->numVisuals >= 0) {
+		(*psp->XMesaAPI.DestroyVisual)
+		    (psp->visuals[psp->numVisuals].xm_vis);
+	    }
+	    Xfree(psp->visuals);
+	    (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	    (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	    Xfree(psp->pDevPriv);
+	    (void)drmClose(psp->fd);
+	    Xfree(psp);
+	    (void)XF86DRICloseConnection(dpy, scrn);
+	    return NULL;
+	}
+    }
+
+    /*
+    ** Do not init dummy context here; actual initialization will be
+    ** done when the first DRI context is created.  Init screen priv ptr
+    ** to NULL to let CreateContext routine that it needs to be inited.
+    */
+    psp->dummyContextPriv.driScreenPriv = NULL;
+
+    psc->destroyScreen  = driMesaDestroyScreen;
+    psc->createContext  = driMesaCreateContext;
+    psc->createDrawable = driMesaCreateDrawable;
+    psc->getDrawable    = driMesaGetDrawable;
+
+    return (void *)psp;
+}
+
+static void driMesaDestroyScreen(Display *dpy, int scrn, void *private)
+{
+    __DRIscreenPrivate *psp = (__DRIscreenPrivate *)private;
+
+    if (psp) {
+	if (psp->dummyContextPriv.driScreenPriv) {
+	    (void)XF86DRIDestroyContext(dpy, scrn,
+					psp->dummyContextPriv.contextID);
+	}
+	if (psp->XMesaAPI.ResetDriver)
+	    (*psp->XMesaAPI.ResetDriver)(psp);
+	while (--psp->numVisuals >= 0) {
+	    (*psp->XMesaAPI.DestroyVisual)
+		(psp->visuals[psp->numVisuals].xm_vis);
+	}
+	Xfree(psp->visuals);
+	(void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	Xfree(psp->pDevPriv);
+	(void)drmClose(psp->fd);
+	Xfree(psp);
+
+#if 0
+	/*
+	** NOT_DONE: Normally, we would call XF86DRICloseConnection()
+	** here, but since this routine is called after the
+	** XCloseDisplay() function has already shut down the connection
+	** to the Display, there is no protocol stream open to the X
+	** server anymore.  Luckily, XF86DRICloseConnection() does not
+	** really do anything (for now).
+	*/
+	(void)XF86DRICloseConnection(dpy, scrn);
+#endif
+    }
+}
+
+
+/*
+ * This is the entrypoint into the driver.
+ * The driCreateScreen name is the symbol that libGL.so fetches.
+ */
+void *driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                      int numConfigs, __GLXvisualConfig *config)
+{
+   return driMesaCreateScreen(dpy, scrn, psc, numConfigs, config);
+}
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/dri/dri_mesa.h b/xc/lib/GL/mesa/dri/dri_mesa.h
new file mode 100644
index 000000000..8b421eff0
--- /dev/null
+++ b/xc/lib/GL/mesa/dri/dri_mesa.h
@@ -0,0 +1,48 @@
+/* $XFree86: xc/lib/GL/mesa/dri/dri_mesa.h,v 1.1 2000/02/08 17:18:36 dawes Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ * $PI: xc/lib/GL/dri/dri_mesa.h,v 1.5 1999/04/05 05:24:31 martin Exp $
+ */
+
+#ifndef _DRI_MESA_H_
+#define _DRI_MESA_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+typedef struct __DRIdisplayPrivateRec  __DRIdisplayPrivate;
+typedef struct __DRIscreenPrivateRec   __DRIscreenPrivate;
+typedef struct __DRIvisualPrivateRec   __DRIvisualPrivate;
+typedef struct __DRIcontextPrivateRec  __DRIcontextPrivate;
+typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
+
+#endif
+#endif /* _DRI_MESA_H_ */
diff --git a/xc/lib/GL/mesa/dri/dri_mesaint.h b/xc/lib/GL/mesa/dri/dri_mesaint.h
new file mode 100644
index 000000000..d77d7cd63
--- /dev/null
+++ b/xc/lib/GL/mesa/dri/dri_mesaint.h
@@ -0,0 +1,246 @@
+/* $XFree86: xc/lib/GL/mesa/dri/dri_mesaint.h,v 1.5 2000/02/15 07:13:28 martin Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ * $PI: xc/lib/GL/dri/dri_mesaint.h,v 1.8 1999/06/14 21:10:35 faith Exp $
+ */
+
+#ifndef _DRI_MESAINT_H_
+#define _DRI_MESAINT_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <GL/glx.h>
+#include "xf86dri.h"
+#include "sarea.h"
+#include "GL/xmesa.h"
+#include "dri_mesa.h"
+#include "dri_xmesaapi.h"
+
+#define DRI_MESA_VALIDATE_DRAWABLE_INFO(dpy,scrn,pDrawPriv)  \
+    do {                                                     \
+	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {  \
+	    driMesaUpdateDrawableInfo(dpy,scrn,pDrawPriv);   \
+	}                                                    \
+    } while (0)
+
+
+struct __DRIdrawablePrivateRec {
+    /*
+    ** Kernel drawable handle (not currently used).
+    */
+    drmDrawable hHWDrawable;
+
+    /*
+    ** Mesa's private context information.  This structure is opaque.
+    */
+    XMesaBuffer xm_buf;
+
+    /*
+    ** X's drawable ID associated with this private drawable.
+    */
+    GLXDrawable draw;
+
+    /*
+    ** Reference count for number of context's currently bound to this
+    ** drawable.  Once the refcount reaches 0, the drawable can be
+    ** destroyed.  This behavior will change with GLX 1.3.
+    */
+    int refcount;
+
+    /*
+    ** Index of this drawable's information in the SAREA.
+    */
+    unsigned int index;
+
+    /*
+    ** Pointer to the "drawable has changed ID" stamp in the SAREA.
+    */
+    unsigned int *pStamp;
+
+    /*
+    ** Last value of the stamp.  If this differs from the value stored
+    ** at *pStamp, then the drawable information has been modified by
+    ** the X server, and the drawable information (below) should be
+    ** retrieved from the X server.
+    */
+    unsigned int lastStamp;
+
+    /*
+    ** Drawable information used in software fallbacks.
+    */
+    int x;
+    int y;
+    int w;
+    int h;
+    int numClipRects;
+    XF86DRIClipRectPtr pClipRects;
+
+    /*
+    ** Pointer to context to which this drawable is currently bound.
+    */
+    __DRIcontextPrivate *driContextPriv;
+
+    /*
+    ** Pointer to screen on which this drawable was created.
+    */
+    __DRIscreenPrivate *driScreenPriv;
+};
+
+struct __DRIcontextPrivateRec {
+    /*
+    ** Kernel context handle used to access the device lock.
+    */
+    XID contextID;
+
+    /*
+    ** Kernel context handle used to access the device lock.
+    */
+    drmContext hHWContext;
+
+    /*
+    ** Mesa's private context information.  This structure is opaque.
+    */
+    XMesaContext xm_ctx;
+
+    /*
+    ** Pointer to drawable currently bound to this context.
+    */
+    __DRIdrawablePrivate *driDrawablePriv;
+
+    /*
+    ** Pointer to screen on which this context was created.
+    */
+    __DRIscreenPrivate *driScreenPriv;
+};
+
+struct __DRIvisualPrivateRec {
+    /*
+    ** Mesa's private visual information.  This structure is opaque.
+    */
+    XMesaVisual xm_vis;
+
+    /*
+    ** X's visual ID associated with this private visual.
+    */
+    VisualID vid;
+};
+
+struct __DRIscreenPrivateRec {
+    /*
+    ** Current screen's number
+    */
+    int myNum;
+
+    /*
+    ** Core rendering library's visuals associated with the current
+    ** screen.
+    */
+    __DRIvisualPrivate *visuals;
+    int numVisuals;
+
+    /*
+    ** Function pointers associated with Mesa's GLX functions.
+    */
+    __XMESAapi XMesaAPI;
+
+    /*
+    ** Core rendering library's driver version information.
+    */
+    int major;
+    int minor;
+    int patch;
+
+    /*
+    ** ID used when the client sets the drawable lock.  The X server
+    ** uses this value to detect if the client has died while holding
+    ** the drawable lock.
+    */
+    int drawLockID;
+
+    /*
+    ** File descriptor returned when the kernel device driver is opened.
+    ** It is used to:
+    **   - authenticate client to kernel
+    **   - map the frame buffer, SAREA, etc.
+    **   - close the kernel device driver
+    */
+    int fd;
+
+    /*
+    ** SAREA pointer used to access:
+    **   - the device lock
+    **   - the device-independent per-drawable and per-context(?) information
+    */
+    XF86DRISAREAPtr pSAREA;
+
+    /*
+    ** Direct frame buffer access information used for software
+    ** fallbacks.
+    */
+    unsigned char *pFB;
+    int fbSize;
+    int fbOrigin;
+    int fbStride;
+    int fbWidth;
+    int fbHeight;
+    int fbBPP;
+
+    /*
+    ** Device-dependent private information (stored in the SAREA).  This
+    ** data is accessed by the client driver only.
+    */
+    void *pDevPriv;
+    int devPrivSize;
+
+    /*
+    ** Dummy context to which drawables are bound when not bound to any
+    ** other context. A dummy hHWContext is created for this context,
+    ** and is used by the GL core when a HW lock is required but the
+    ** drawable is not currently bound (e.g., potentially during a
+    ** SwapBuffers request).  The dummy context is created when the
+    ** first "real" context is created on this screen.
+    */
+    __DRIcontextPrivate dummyContextPriv;
+
+    /*
+    ** Device-dependent private information (not stored in the SAREA).
+    ** This pointer is never touched by the DRI layer.
+    */
+    void *private;
+};
+
+
+extern void driMesaUpdateDrawableInfo(Display *dpy, int scrn,
+				      __DRIdrawablePrivate *pdp);
+
+#endif
+#endif /* _DRI_MESAINT_H_ */
diff --git a/xc/lib/GL/mesa/dri/dri_xmesaapi.h b/xc/lib/GL/mesa/dri/dri_xmesaapi.h
new file mode 100644
index 000000000..0db1d1296
--- /dev/null
+++ b/xc/lib/GL/mesa/dri/dri_xmesaapi.h
@@ -0,0 +1,77 @@
+/* $XFree86: xc/lib/GL/mesa/dri/dri_xmesaapi.h,v 1.2 2000/02/15 07:13:29 martin Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ * $PI: xc/lib/GL/dri/dri_xmesaapi.h,v 1.4 1999/04/05 05:24:31 martin Exp $
+ */
+
+#ifndef _DRI_XMESAAPI_H_
+#define _DRI_XMESAAPI_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include "GL/xmesa.h"
+#include "dri_mesa.h"
+
+typedef struct __XMESAapiRec __XMESAapi;
+
+struct __XMESAapiRec {
+    /* XMESA Functions */
+    GLboolean    (*InitDriver)(__DRIscreenPrivate *driScrnPriv);
+    void         (*ResetDriver)(__DRIscreenPrivate *driScrnPriv);
+    XMesaVisual  (*CreateVisual)(XMesaDisplay *display,
+				 XMesaVisualInfo visinfo,
+				 GLboolean rgb_flag,
+				 GLboolean alpha_flag,
+				 GLboolean db_flag,
+				 GLboolean stereo_flag,
+				 GLboolean ximage_flag,
+				 GLint depth_size,
+				 GLint stencil_size,
+				 GLint accum_size,
+				 GLint level);
+    void         (*DestroyVisual)(XMesaVisual v);
+    XMesaContext (*CreateContext)(XMesaVisual v, XMesaContext share_list,
+				  __DRIcontextPrivate *driContextPriv);
+    void         (*DestroyContext)(XMesaContext c);
+    XMesaBuffer  (*CreateWindowBuffer)(XMesaVisual v, XMesaWindow w,
+				       __DRIdrawablePrivate *driDrawPriv);
+    XMesaBuffer  (*CreatePixmapBuffer)(XMesaVisual v, XMesaPixmap p,
+				       XMesaColormap c,
+				       __DRIdrawablePrivate *driDrawPriv);
+    void         (*DestroyBuffer)(XMesaBuffer b);
+    void         (*SwapBuffers)(XMesaBuffer b);
+    GLboolean    (*MakeCurrent)(XMesaContext c, XMesaBuffer b);
+    GLboolean    (*UnbindContext)(XMesaContext c);
+};
+
+#endif
+#endif /* _DRI_XMESAAPI_H_ */
diff --git a/xc/lib/GL/mesa/include/GL/Imakefile b/xc/lib/GL/mesa/include/GL/Imakefile
new file mode 100644
index 000000000..fec9e3354
--- /dev/null
+++ b/xc/lib/GL/mesa/include/GL/Imakefile
@@ -0,0 +1,13 @@
+XCOMM $XFree86: xc/lib/GL/mesa/include/GL/Imakefile,v 1.1 2000/02/08 17:18:37 dawes Exp $
+XCOMM $PI: xc/programs/Xserver/GL/mesa/include/GL/Imakefile,v 1.6 1999/03/15 21:36:09 martin Exp $
+
+#define IHaveModules
+#include <Server.tmpl>
+
+      DEFINES = $(GLX_DEFINES)
+
+LinkSourceFile(gl.h, ../../../../../extras/Mesa/include/GL)
+LinkSourceFile(glx.h, ../../../../../extras/Mesa/include/GL)
+LinkSourceFile(xmesa.h, ../../../../../extras/Mesa/include/GL)
+LinkSourceFile(xmesa_x.h, ../../../../../extras/Mesa/include/GL)
+LinkSourceFile(xmesa_xf86.h, ../../../../../extras/Mesa/include/GL)
diff --git a/xc/lib/GL/mesa/src/Imakefile b/xc/lib/GL/mesa/src/Imakefile
index be1de5f3e..b3dade36c 100644
--- a/xc/lib/GL/mesa/src/Imakefile
+++ b/xc/lib/GL/mesa/src/Imakefile
@@ -1,5 +1,6 @@
-XCOMM $XFree86: xc/lib/GL/mesa/src/Imakefile,v 1.5 1999/12/14 01:32:25 robin Exp $
-XCOMM $PI: xc/lib/GL/mesa/src/Imakefile,v 1.5 1999/06/21 05:13:55 martin Exp $
+XCOMM $XFree86: xc/lib/GL/mesa/src/Imakefile,v 1.9 2000/02/15 07:13:29 martin Exp $
+
+#include <Threads.tmpl>
 
 #define DoNormalLib NormalLibGlx
 #define DoSharedLib SharedLibGlx
@@ -22,10 +23,6 @@ LinkSourceFile(alpha.c, ../../../../extras/Mesa/src)
 LinkSourceFile(alpha.h, ../../../../extras/Mesa/src)
 LinkSourceFile(alphabuf.c, ../../../../extras/Mesa/src)
 LinkSourceFile(alphabuf.h, ../../../../extras/Mesa/src)
-LinkSourceFile(api.h, ../../../../extras/Mesa/src)
-LinkSourceFile(api1.c, ../../../../extras/Mesa/src)
-LinkSourceFile(api2.c, ../../../../extras/Mesa/src)
-LinkSourceFile(apiext.c, ../../../../extras/Mesa/src)
 LinkSourceFile(attrib.c, ../../../../extras/Mesa/src)
 LinkSourceFile(attrib.h, ../../../../extras/Mesa/src)
 LinkSourceFile(bbox.c, ../../../../extras/Mesa/src)
@@ -34,6 +31,8 @@ LinkSourceFile(bitmap.c, ../../../../extras/Mesa/src)
 LinkSourceFile(bitmap.h, ../../../../extras/Mesa/src)
 LinkSourceFile(blend.c, ../../../../extras/Mesa/src)
 LinkSourceFile(blend.h, ../../../../extras/Mesa/src)
+LinkSourceFile(buffers.c, ../../../../extras/Mesa/src)
+LinkSourceFile(buffers.h, ../../../../extras/Mesa/src)
 LinkSourceFile(clip.c, ../../../../extras/Mesa/src)
 LinkSourceFile(clip.h, ../../../../extras/Mesa/src)
 LinkSourceFile(clip_funcs.h, ../../../../extras/Mesa/src)
@@ -77,12 +76,24 @@ LinkSourceFile(fog_tmp.h, ../../../../extras/Mesa/src)
 LinkSourceFile(general_clip.h, ../../../../extras/Mesa/src)
 LinkSourceFile(get.c, ../../../../extras/Mesa/src)
 LinkSourceFile(get.h, ../../../../extras/Mesa/src)
-LinkSourceFile(glmisc.c, ../../../../extras/Mesa/src)
-LinkSourceFile(glmisc.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glapi.c, ../../../../extras/Mesa/src)
+LinkSourceFile(glapi.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glapinoop.c, ../../../../extras/Mesa/src)
+LinkSourceFile(glapinoop.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glapioffsets.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glapitable.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glapitemp.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glheader.h, ../../../../extras/Mesa/src)
+LinkSourceFile(glthread.c, ../../../../extras/Mesa/src)
+LinkSourceFile(glthread.h, ../../../../extras/Mesa/src)
 LinkSourceFile(hash.c, ../../../../extras/Mesa/src)
 LinkSourceFile(hash.h, ../../../../extras/Mesa/src)
+LinkSourceFile(hint.c, ../../../../extras/Mesa/src)
+LinkSourceFile(hint.h, ../../../../extras/Mesa/src)
 LinkSourceFile(image.c, ../../../../extras/Mesa/src)
 LinkSourceFile(image.h, ../../../../extras/Mesa/src)
+LinkSourceFile(imaging.c, ../../../../extras/Mesa/src)
+LinkSourceFile(imaging.h, ../../../../extras/Mesa/src)
 LinkSourceFile(indirect_tmp.h, ../../../../extras/Mesa/src)
 LinkSourceFile(interp_tmp.h, ../../../../extras/Mesa/src)
 LinkSourceFile(light.c, ../../../../extras/Mesa/src)
@@ -98,10 +109,10 @@ LinkSourceFile(masking.c, ../../../../extras/Mesa/src)
 LinkSourceFile(masking.h, ../../../../extras/Mesa/src)
 LinkSourceFile(matrix.c, ../../../../extras/Mesa/src)
 LinkSourceFile(matrix.h, ../../../../extras/Mesa/src)
+LinkSourceFile(mem.c, ../../../../extras/Mesa/src)
+LinkSourceFile(mem.h, ../../../../extras/Mesa/src)
 LinkSourceFile(mmath.c, ../../../../extras/Mesa/src)
 LinkSourceFile(mmath.h, ../../../../extras/Mesa/src)
-LinkSourceFile(mthreads.c, ../../../../extras/Mesa/src)
-LinkSourceFile(mthreads.h, ../../../../extras/Mesa/src)
 LinkSourceFile(norm_tmp.h, ../../../../extras/Mesa/src)
 LinkSourceFile(pb.c, ../../../../extras/Mesa/src)
 LinkSourceFile(pb.h, ../../../../extras/Mesa/src)
@@ -109,8 +120,6 @@ LinkSourceFile(pipeline.c, ../../../../extras/Mesa/src)
 LinkSourceFile(pipeline.h, ../../../../extras/Mesa/src)
 LinkSourceFile(pixel.c, ../../../../extras/Mesa/src)
 LinkSourceFile(pixel.h, ../../../../extras/Mesa/src)
-LinkSourceFile(pointers.c, ../../../../extras/Mesa/src)
-LinkSourceFile(pointers.h, ../../../../extras/Mesa/src)
 LinkSourceFile(points.c, ../../../../extras/Mesa/src)
 LinkSourceFile(points.h, ../../../../extras/Mesa/src)
 LinkSourceFile(polygon.c, ../../../../extras/Mesa/src)
@@ -134,6 +143,8 @@ LinkSourceFile(span.c, ../../../../extras/Mesa/src)
 LinkSourceFile(span.h, ../../../../extras/Mesa/src)
 LinkSourceFile(stages.c, ../../../../extras/Mesa/src)
 LinkSourceFile(stages.h, ../../../../extras/Mesa/src)
+LinkSourceFile(state.c, ../../../../extras/Mesa/src)
+LinkSourceFile(state.h, ../../../../extras/Mesa/src)
 LinkSourceFile(stencil.c, ../../../../extras/Mesa/src)
 LinkSourceFile(stencil.h, ../../../../extras/Mesa/src)
 LinkSourceFile(texgen_tmp.h, ../../../../extras/Mesa/src)
@@ -178,41 +189,157 @@ LinkSourceFile(xform_tmp.h, ../../../../extras/Mesa/src)
 LinkSourceFile(zoom.c, ../../../../extras/Mesa/src)
 LinkSourceFile(zoom.h, ../../../../extras/Mesa/src)
 
-    CORE_SRCS = accum.c alpha.c alphabuf.c api1.c api2.c apiext.c \
-                attrib.c bitmap.c blend.c clip.c colortab.c context.c \
-                copypix.c depth.c dlist.c drawpix.c enable.c eval.c \
-                feedback.c fog.c get.c hash.c image.c light.c lines.c \
-                logic.c masking.c matrix.c glmisc.c mmath.c mthreads.c \
-                pb.c pixel.c points.c pointers.c polygon.c quads.c \
-                rastpos.c readpix.c rect.c scissor.c shade.c span.c \
-                stencil.c teximage.c texobj.c texstate.c texture.c \
-                triangle.c varray.c winpos.c vb.c vbfill.c vbrender.c \
-                vbxform.c xform.c zoom.c stages.c \
-		bbox.c config.c cva.c enums.c extensions.c \
-		pipeline.c translate.c vbcull.c vbindirect.c vector.c \
-		vertices.c
+    CORE_SRCS = accum.c \
+		alpha.c \
+		alphabuf.c \
+		attrib.c \
+		bbox.c \
+		bitmap.c \
+		blend.c \
+		buffers.c \
+		clip.c \
+		colortab.c \
+		config.c \
+		context.c \
+		copypix.c \
+		cva.c \
+		debug_xform.c \
+		depth.c \
+		dlist.c \
+		drawpix.c \
+		enable.c \
+		enums.c \
+		eval.c \
+		extensions.c \
+		feedback.c \
+		fog.c \
+		get.c \
+		glapi.c \
+		glapinoop.c \
+		glthread.c \
+		hash.c \
+		hint.c \
+		image.c \
+		imaging.o \
+		light.c \
+		lines.c \
+		logic.c \
+		masking.c \
+		matrix.c \
+		mem.c \
+		mmath.c \
+		pb.c \
+		pipeline.c \
+		pixel.c \
+		points.c \
+		polygon.c \
+		quads.c \
+		rastpos.c \
+		readpix.c \
+		rect.c \
+		scissor.c \
+		shade.c \
+		span.c \
+		stages.c \
+		state.c \
+		stencil.c \
+		teximage.c \
+		texobj.c \
+		texstate.c \
+		texture.c \
+		translate.c \
+		triangle.c \
+		varray.c \
+		vb.c \
+		vbcull.c \
+		vbfill.c \
+		vbindirect.c \
+		vbrender.c \
+		vbxform.c \
+		vector.c \
+		vertices.c \
+		winpos.c \
+		xform.c \
+		zoom.c
 
-    CORE_OBJS = accum.o alpha.o alphabuf.o api1.o api2.o apiext.o \
-                attrib.o bitmap.o blend.o clip.o colortab.o context.o \
-                copypix.o depth.o dlist.o drawpix.o enable.o eval.o \
-                feedback.o fog.o get.o hash.o image.o light.o lines.o \
-                logic.o masking.o matrix.o glmisc.o mmath.o mthreads.o \
-                pb.o pixel.o points.o pointers.o polygon.o quads.o \
-                rastpos.o readpix.o rect.o scissor.o shade.o span.o \
-                stencil.o teximage.o texobj.o texstate.o texture.o \
-                triangle.o varray.o winpos.o vb.o vbfill.o vbrender.o \
-                vbxform.o xform.o zoom.o stages.o \
-		bbox.o config.o cva.o enums.o extensions.o \
-		pipeline.o translate.o vbcull.o vbindirect.o vector.o \
-		vertices.o
+    CORE_OBJS = accum.o \
+		alpha.o \
+		alphabuf.o \
+		attrib.o \
+		bbox.o \
+		bitmap.o \
+		blend.o \
+		buffers.o \
+		clip.o \
+		colortab.o \
+		config.o \
+		context.o \
+		copypix.o \
+		cva.o \
+		debug_xform.o \
+		depth.o \
+		dlist.o \
+		drawpix.o \
+		enable.o \
+		enums.o \
+		eval.o \
+		extensions.o \
+		feedback.o \
+		fog.o \
+		get.o \
+		hash.o \
+		hint.o \
+		image.o \
+		imaging.o \
+		light.o \
+		lines.o \
+		logic.o \
+		masking.o \
+		matrix.o \
+		mem.o \
+		mmath.o \
+		pb.o \
+		pipeline.o \
+		pixel.o \
+		points.o \
+		polygon.o \
+		quads.o \
+		rastpos.o \
+		readpix.o \
+		rect.o \
+		scissor.o \
+		shade.o \
+		span.o \
+		stages.o \
+		state.o \
+		stencil.o \
+		teximage.o \
+		texobj.o \
+		texstate.o \
+		texture.o \
+		translate.o \
+		triangle.o \
+		varray.o \
+		vb.o \
+		vbcull.o \
+		vbfill.o \
+		vbindirect.o \
+		vbrender.o \
+		vbxform.o \
+		vector.o \
+		vertices.o \
+		winpos.o \
+		xform.o \
+		zoom.o
 
+#ifdef i386Architecture
      ASM_SRCS = 
      ASM_OBJS = 
-     ASM_DEFS = -DUSE_MMX_ASM -DUSE_X86_ASM 
-# -DUSE_3DNOW_ASM
+     ASM_DEFS = -DUSE_MMX_ASM -DUSE_X86_ASM -DUSE_3DNOW_ASM
+#endif
 
       DEFINES = $(ALLOC_DEFINES) GlxDefines $(TDFX_DEFS) $(ASM_DEFS)
-     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) -I../include -I../../dri
+     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) -I../include -I../../dri -I. -I../../../../include
          SRCS = $(CORE_SRCS) $(ASM_SRCS)
          OBJS = $(CORE_OBJS) $(ASM_OBJS)
 
@@ -250,7 +377,7 @@ LIBNAME = mesa_dri.so
 ALL_OBJS = $(CORE_OBJS) X/?*.o X86/?*.o
 ALL_DEPS = $(SUBDIRS) DONE X/DONE X86/DONE
 SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
-InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+InstallDynamicModule($(LIBNAME),$(MODULEDIR)/dri,.)
 #endif
 
 DependTarget()
diff --git a/xc/lib/GL/mesa/src/X/Imakefile b/xc/lib/GL/mesa/src/X/Imakefile
index bf0671c0b..b01a469e9 100644
--- a/xc/lib/GL/mesa/src/X/Imakefile
+++ b/xc/lib/GL/mesa/src/X/Imakefile
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/lib/GL/mesa/src/X/Imakefile,v 1.3 1999/12/14 01:33:34 robin Exp $
+XCOMM $XFree86: xc/lib/GL/mesa/src/X/Imakefile,v 1.4 2000/02/08 17:18:40 dawes Exp $
 XCOMM $PI: xc/lib/GL/mesa/src/X/Imakefile,v 1.4 1999/06/21 05:13:55 martin Exp $
 
 #define DoNormalLib NormalLibGlx
@@ -11,6 +11,8 @@ LinkSourceFile(xmesa1.c, ../../../../../extras/Mesa/src/X)
 LinkSourceFile(xmesa2.c, ../../../../../extras/Mesa/src/X)
 LinkSourceFile(xmesa3.c, ../../../../../extras/Mesa/src/X)
 LinkSourceFile(xmesa4.c, ../../../../../extras/Mesa/src/X)
+LinkSourceFile(xmesaP.h, ../../../../../extras/Mesa/src/X)
+LinkSourceFile(glxheader.h, ../../../../../extras/Mesa/src/X)
 
 
 #if Malloc0ReturnsNull
@@ -19,17 +21,11 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 
 #if BuildXF86DRI
   DRI_DEFINES = GlxDefines
- DRI_INCLUDES = -I../../../dri -I../../../glx \
+ DRI_INCLUDES = -I../../../dri -I../../../glx -I../../dri \
 		-I$(TOP)/include -I$(TOP)/include/GL \
 		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri
 #endif
 
-LinkSourceFile(xmesa1.c, ../../../../../extras/Mesa/src/X)
-LinkSourceFile(xmesa2.c, ../../../../../extras/Mesa/src/X)
-LinkSourceFile(xmesa3.c, ../../../../../extras/Mesa/src/X)
-LinkSourceFile(xmesa4.c, ../../../../../extras/Mesa/src/X)
-LinkSourceFile(xmesaP.h, ../../../../../extras/Mesa/src/X)
-
 MESA_INCLUDES = -I. -I.. -I../../include
 
       DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
diff --git a/xc/lib/GL/mesa/src/X86/Imakefile b/xc/lib/GL/mesa/src/X86/Imakefile
index 31df38154..99dfd8ea8 100644
--- a/xc/lib/GL/mesa/src/X86/Imakefile
+++ b/xc/lib/GL/mesa/src/X86/Imakefile
@@ -1,5 +1,4 @@
-XCOMM $XFree86: xc/lib/GL/mesa/src/X86/Imakefile,v 1.1 1999/12/14 01:49:19 robin Exp $
-XCOMM $PI: xc/lib/GL/mesa/src/Imakefile,v 1.5 1999/06/21 05:13:55 martin Exp $
+XCOMM $XFree86: xc/lib/GL/mesa/src/X86/Imakefile,v 1.4 2000/02/18 16:23:10 dawes Exp $
 
 #define DoNormalLib NormalLibGlx
 #define DoSharedLib SharedLibGlx
@@ -7,8 +6,20 @@ XCOMM $PI: xc/lib/GL/mesa/src/Imakefile,v 1.5 1999/06/21 05:13:55 martin Exp $
 #define DoDebugLib DebugLibGlx
 #define DoProfileLib ProfileLibGlx
 
-/* #define HAVE_3DNOW  1 */
-#define HAVE_MMX_   1
+LinkSourceFile(assyntax.h, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(common_x86.c, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(common_x86asm.S, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(common_x86asm.h, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(glapi_x86.S, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(x86.c, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(x86.h, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(x86a.S, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(vertex.S, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(x86flatregs.m4, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(x86a.S.m4, ../../../../../extras/Mesa/src/X86)
+
+LinkSourceFile(mmx.h, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(mmx_blend.S, ../../../../../extras/Mesa/src/X86)
 
 LinkSourceFile(3dnow.c, ../../../../../extras/Mesa/src/X86)
 LinkSourceFile(3dnow.h, ../../../../../extras/Mesa/src/X86)
@@ -23,61 +34,51 @@ LinkSourceFile(3dnow_xform_raw3.S, ../../../../../extras/Mesa/src/X86)
 LinkSourceFile(3dnow_xform_raw4.S, ../../../../../extras/Mesa/src/X86)
 LinkSourceFile(vertex_3dnow.S, ../../../../../extras/Mesa/src/X86)
 
-LinkSourceFile(mmx.h, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(mmx_blend.S, ../../../../../extras/Mesa/src/X86)
-
-LinkSourceFile(x86a.S, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(assyntax.h, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(common_x86.c, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(common_x86asm.S, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(common_x86asm.h, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(x86.c, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(x86.h, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(vertex.S, ../../../../../extras/Mesa/src/X86)
-
-LinkSourceFile(x86flatregs.m4, ../../../../../extras/Mesa/src/X86)
-LinkSourceFile(x86a.S.m4, ../../../../../extras/Mesa/src/X86)
+LinkSourceFile(glapioffsets.h, ../../../../../extras/Mesa/src)
 
 #if Malloc0ReturnsNull
 ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 #endif
 
-#if HAVE_3DNOW
+#ifdef i386Architecture
+XCOMM We'll learn at runtime whether 3dNow, MMX, etc are really present.
+      X86_SRCS = x86a.S common_x86.c common_x86asm.S glapi_x86.S x86.c vertex.S
+
+      X86_OBJS = x86a.o common_x86.o common_x86asm.o x86.o vertex.o
+
+      X86_DEFS = -DUSE_X86_ASM
+
+
+      MMX_SRCS = mmx_blend.S
+
+      MMX_OBJS = mmx_blend.o
+
+      MMX_DEFS = -DUSE_MMX_ASM
+
+
+XCOMM Disabling 3DNow code for the time being
+#if 0
     3DNOW_SRCS = 3dnow.c 3dnow_norm_raw.S 3dnow_xform_masked1.S \
 		 3dnow_xform_masked2.S 3dnow_xform_masked3.S \
-		 3dnow_xform_masked3.S 3dnow_xform_raw1.S \
+		 3dnow_xform_masked4.S 3dnow_xform_raw1.S \
 		 3dnow_xform_raw2.S 3dnow_xform_raw3.S 3dnow_xform_raw4.S \
 		 vertex_3dnow.S
 
     3DNOW_OBJS = 3dnow.o 3dnow_norm_raw.o 3dnow_xform_masked1.o \
 		 3dnow_xform_masked2.o 3dnow_xform_masked3.o \
-		 3dnow_xform_masked3.o 3dnow_xform_raw1.o \
+		 3dnow_xform_masked4.o 3dnow_xform_raw1.o \
 		 3dnow_xform_raw2.o 3dnow_xform_raw3.o 3dnow_xform_raw4.o \
 		 vertex_3dnow.o
 
     3DNOW_DEFS = -DUSE_3DNOW_ASM
 #endif
 
-#if HAVE_MMX_
-      MMX_SRCS = mmx_blend.S
-
-      MMX_OBJS = mmx_blend.o
-
-      MMX_DEFS = -DUSE_MMX_ASM
 #endif
 
-      X86_SRCS = x86a.S common_x86.c common_x86asm.S x86.c vertex.S \
-		 $(MMX_SRCS) $(3DNOW_SRCS)
-
-      X86_OBJS = x86a.o common_x86.o common_x86asm.o x86.o vertex.o \
-		 $(MMX_OBJS) $(3DNOW_OBJS)
-
-      X86_DEFS = -DUSE_X86_ASM $(MXX_DEFS) $(3DNOW_DEFS)
-
-      DEFINES = $(ALLOC_DEFINES) GlxDefines -DFX $(X86_DEFS) $(3DNOW_DEFS) $(MMX_DEFS)
+      DEFINES = $(ALLOC_DEFINES) GlxDefines -DFX $(X86_DEFS) $(MMX_DEFS) $(3DNOW_DEFS)
      INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) -I../include -I../../dri -I..
-         SRCS = $(X86_SRCS) $(3DNOW_SRCS) $(MMX_SRCS)
-         OBJS = $(X86_OBJS) $(3DNOW_OBJS) $(MMX_OBJS)
+         SRCS = $(X86_SRCS) $(MMX_SRCS) $(3DNOW_SRCS)
+         OBJS = $(X86_OBJS) $(MMX_OBJS) $(3DNOW_OBJS)
 
 #if !GlxUseBuiltInDRIDriver
 #undef DoNormalLib NormalLibGlx
@@ -90,16 +91,34 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 
 LibraryObjectRule()
 
+STD_CPP_DEFINES = StandardDefines $(PROJECT_DEFINES)
+
 SubdirLibraryRule($(OBJS))
 NormalLintTarget($(SRCS))
-#if 1
+
+#ifdef HAVE_3DNOW
+ObjectFromAsmSource(3dnow_norm_raw, NullParameter)
+ObjectFromAsmSource(3dnow_xform_masked1, NullParameter)
+ObjectFromAsmSource(3dnow_xform_masked2, NullParameter)
+ObjectFromAsmSource(3dnow_xform_masked3, NullParameter)
+ObjectFromAsmSource(3dnow_xform_masked4, NullParameter)
+ObjectFromAsmSource(3dnow_xform_raw1, NullParameter)
+ObjectFromAsmSource(3dnow_xform_raw2, NullParameter)
+ObjectFromAsmSource(3dnow_xform_raw3, NullParameter)
+ObjectFromAsmSource(3dnow_xform_raw4, NullParameter)
+ObjectFromAsmSource(vertex_3dnow, NullParameter)
+#endif
+
+#ifdef HAVE_MMX
+ObjectFromAsmSource(mmx_blend, NullParameter)
 #endif
 
+ObjectFromAsmSource(common_x86asm, NullParameter)
+ObjectFromAsmSource(vertex, NullParameter)
+ObjectFromAsmSource(x86a, NullParameter)
+
 DependTarget()
 
 x86a.S: x86flatregs.m4
 x86a.S: x86a.S.m4
 	m4 $< >$@
-
-x86a.asm: x86a.S
-	gcc -E -P -DNASM_ASSEMBLER $< >$@
diff --git a/xc/lib/GL/mesa/src/drv/Imakefile b/xc/lib/GL/mesa/src/drv/Imakefile
index d22e1576c..471021749 100644
--- a/xc/lib/GL/mesa/src/drv/Imakefile
+++ b/xc/lib/GL/mesa/src/drv/Imakefile
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/lib/GL/mesa/src/drv/Imakefile,v 1.4 1999/12/29 00:44:13 robin Exp $
+XCOMM $XFree86: xc/lib/GL/mesa/src/drv/Imakefile,v 1.6 2000/02/14 06:27:12 martin Exp $
 XCOMM $PI: xc/lib/GL/mesa/src/drv/Imakefile,v 1.3 1999/06/14 21:10:41 faith Exp $
 
 #define DoNormalLib NormalLibGlx
diff --git a/xc/lib/GL/mesa/src/drv/common/Imakefile b/xc/lib/GL/mesa/src/drv/common/Imakefile
new file mode 100644
index 000000000..2bd674ffd
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/Imakefile
@@ -0,0 +1,56 @@
+XCOMM $PI:$
+
+#define DoNormalLib NormalLibGlx
+#define DoSharedLib SharedLibGlx
+#define DoExtraLib SharedLibGlx
+#define DoDebugLib DebugLibGlx
+#define DoProfileLib ProfileLibGlx
+
+#if Malloc0ReturnsNull
+ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
+#endif
+
+#if BuildXF86DRI
+  DRI_DEFINES = GlxDefines -DDRIVERTS
+ DRI_INCLUDES = -I../../../../dri -I../../../../glx \
+		-I$(TOP)/include -I$(TOP)/include/GL \
+		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \
+		-I../../../include -I../.. -I../common -I../../X
+#endif
+
+MESA_INCLUDES = -I. -I.. -I../../include
+
+
+
+      DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
+     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \
+		-I/usr/include/glide
+      DRISRCS = hwlog.c mm.c
+      DRIOBJS = hwlog.o mm.o
+
+	 SRCS = $(DRISRCS) 
+	 OBJS = $(DRIOBJS) 
+
+#if !GlxUseBuiltInDRIDriver
+#undef DoNormalLib NormalLibGlx
+#undef DoExtraLib SharedLibGlx
+#undef DoDebugLib DebugLibGlx
+#undef DoProfileLib ProfileLibGlx
+#endif
+
+#include <Library.tmpl>
+
+LibraryObjectRule()
+
+SubdirLibraryRule($(OBJS))
+NormalLintTarget($(SRCS))
+
+#if !GlxUseBuiltInDRIDriver
+LIBNAME = i810_dri.so
+ALL_OBJS = $(OBJS)
+ALL_DEPS = DONE
+SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
+InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+#endif
+
+DependTarget()
diff --git a/xc/lib/GL/mesa/src/drv/common/hwlog.c b/xc/lib/GL/mesa/src/drv/common/hwlog.c
new file mode 100644
index 000000000..d8d69703a
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/hwlog.c
@@ -0,0 +1,107 @@
+/*
+ * GLX Hardware Device Driver common code 
+ * 
+ * Based on the original MGA G200 driver (c) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+ 
+#include "hwlog.h"
+hwlog_t hwlog = { 0,0,0, "[???] "};
+
+
+/* Should be shared, but is this a good place for it?
+ */
+#include <sys/time.h>
+
+
+int usec( void ) 
+{
+   struct timeval tv;
+   struct timezone tz;
+   
+   gettimeofday( &tv, &tz );
+   
+   return (tv.tv_sec & 2047) * 1000000 + tv.tv_usec;
+}
+
+
+#ifdef HW_LOG_ENABLED
+int hwOpenLog(const char *filename, char *prefix)
+{
+  hwCloseLog();
+  hwSetLogLevel(0);
+  hwlog.prefix=prefix;
+  if (!filename)
+    return -1;
+  if ((hwlog.file = fopen(filename,"w")) == NULL)
+      return -1;
+  return 0;
+}
+
+void hwCloseLog()
+{
+  if (hwlog.file) {
+    fclose(hwlog.file);
+    hwlog.file = NULL;
+  }
+}
+
+int hwIsLogReady()
+{
+  return (hwlog.file != NULL);
+}
+
+void hwSetLogLevel(int level)
+{
+  hwlog.level = level;
+}
+
+int hwGetLogLevel()
+{
+  return hwlog.level;
+}
+
+void hwLog(int level, const char *format, ...)
+{
+  va_list ap;
+  va_start(ap,format);
+  hwLogv(level,format,ap);
+  va_end(ap);
+}
+
+void hwLogv(int l, const char *format, va_list ap)
+{
+  if (hwlog.file && (l <= hwlog.level)) {
+    vfprintf(hwlog.file,format,ap);
+    fflush(hwlog.file);
+  }
+}
+
+#else /* ifdef HW_LOG_ENABLED */
+
+int hwlogdummy()
+{
+  return 0;
+}
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/common/hwlog.h b/xc/lib/GL/mesa/src/drv/common/hwlog.h
new file mode 100644
index 000000000..42e378afd
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/hwlog.h
@@ -0,0 +1,115 @@
+/*
+ * GLX Hardware Device Driver common code
+ *
+ * Based on the original MGA G200 driver (c) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+ 
+/* Usage:
+ * - use mgaError for error messages. Always write to X error and log file.
+ * - use mgaMsg for debugging. Can be disabled by undefining MGA_LOG_ENABLED.
+ */
+ 
+#ifndef HWLOG_INC
+#define HWLOG_INC
+#include <stdio.h>
+
+#define DBG_LEVEL_BASE          1
+#define DBG_LEVEL_VERBOSE       10
+#define DBG_LEVEL_ENTEREXIT     20
+
+typedef struct
+{
+  FILE *file;
+  int   level;
+  unsigned int timeTemp;
+  char *prefix;
+} hwlog_t;
+
+extern hwlog_t hwlog;
+
+
+#ifdef HW_LOG_ENABLED
+#include <stdarg.h>
+
+/* open and close log file. */
+int  hwOpenLog(const char *filename, char *prefix);
+void hwCloseLog();
+
+/* return 1 if log file is succesfully opened */
+int  hwIsLogReady();
+
+/* set current log level to 'level'. Messages with level less than or equal
+   the current log level will be written to the log file. */
+void hwSetLogLevel(int level);
+int  hwGetLogLevel();
+
+/* hwLog and hwLogv write a message to the log file.	*/
+/* do not call these directly, use hwMsg() instead	*/
+void hwLog(int level, const char *format, ...);
+void hwLogv(int level, const char *format, va_list ap);
+
+
+int usec( void );
+
+
+/* hwMsg writes a message to the log file or to the standard X error file. */
+#define hwMsg(level_,format, args...) if ( level_ <= hwlog.level ) {	\
+  if (hwIsLogReady()) {				\
+  	int __t=usec();hwLog(level_,"%6i:",__t-hwlog.timeTemp);hwlog.timeTemp=__t; \
+    hwLog(level_,format, ## args);		\
+  } else {					\
+    if (level_ <= hwGetLogLevel()) {		\
+      fprintf(stderr,hwlog.prefix);			\
+      fprintf(stderr,format, ## args);			\
+    } 						\
+  }						\
+}
+
+#define hwError(format, args...) do {		\
+  fprintf(stderr, hwlog.prefix);		\
+  fprintf(stderr, format, ## args);		\
+  hwLog(0,format, ## args);			\
+} while(0)
+
+#else
+
+static __inline__ int hwOpenLog(const char *f, char *prefix) { hwlog.prefix=prefix; return -1; }
+static __inline__ int hwIsLogReady( void ) { return 0; }
+static __inline__ int hwGetLogLevel( void ) { return -1; }
+static __inline__ int hwLogLevel(int level) { return 0; }
+
+#define hwCloseLog()
+#define hwSetLogLevel(x)
+#define hwLog(l,f,a...)
+#define hwLogv(l,f,a)
+#define hwMsg(l,f,a...)
+
+#define hwError(format, args...) do {		\
+  fprintf(stderr, hwlog.prefix);				\
+  fprintf(stderr, format, ## args);			\
+} while(0)
+
+#endif
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/common/mm.c b/xc/lib/GL/mesa/src/drv/common/mm.c
new file mode 100644
index 000000000..c4ff8ae71
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/mm.c
@@ -0,0 +1,262 @@
+/*
+ * GLX Hardware Device Driver common code
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdlib.h>
+#include <stdio.h>
+
+#include "mm.h"
+#include "hwlog.h"
+
+#define ISFREE(bptr) ((bptr)->free)
+/*  #define PRINTF(f,a...) hwMsg(1,f, ## a) */
+#define PRINTF(f,a...) fprintf(stderr, f, ## a)
+
+void mmDumpMemInfo( memHeap_t *heap )
+{
+  TMemBlock *p;
+
+  PRINTF("Memory heap %p:\n", heap);
+  if (heap == 0) {
+    PRINTF("  heap == 0\n");
+  } else {
+    p = (TMemBlock *)heap;
+    while (p) {
+      PRINTF("  Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
+	     p->free ? '.':'U',
+	     p->reserved ? 'R':'.');
+      p = p->next;
+    }
+  }
+  PRINTF("End of memory blocks\n");
+}
+
+memHeap_t *mmInit(int ofs,
+		  int size)
+{
+   PMemBlock blocks;
+  
+   if (size <= 0) {
+      return 0;
+   }
+   blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock));
+   if (blocks) {
+      blocks->ofs = ofs;
+      blocks->size = size;
+      blocks->free = 1;
+      return (memHeap_t *)blocks;
+   } else
+      return 0;
+}
+
+/* Kludgey workaround for existing i810 server.  Remove soon.
+ */
+memHeap_t *mmAddRange( memHeap_t *heap,
+		       int ofs,
+		       int size )
+{
+   PMemBlock blocks;
+   blocks = (TMemBlock *) calloc(2,sizeof(TMemBlock));
+   if (blocks) {
+      blocks[0].size = size;
+      blocks[0].free = 1;
+      blocks[0].ofs = ofs;
+      blocks[0].next = &blocks[1];
+
+      /* Discontinuity - stops JoinBlock from trying to join non-adjacent
+       * ranges.
+       */
+      blocks[1].size = 0;
+      blocks[1].free = 0;
+      blocks[1].ofs = ofs+size;
+      blocks[1].next = (PMemBlock) heap;      
+      return (memHeap_t *)blocks;
+   } 
+   else
+      return heap;
+}
+
+static TMemBlock* SliceBlock(TMemBlock *p, 
+			     int startofs, int size, 
+			     int reserved, int alignment)
+{
+  TMemBlock *newblock;
+
+  /* break left */
+  if (startofs > p->ofs) {
+    newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
+    newblock->ofs = startofs;
+    newblock->size = p->size - (startofs - p->ofs);
+    newblock->free = 1;
+    newblock->next = p->next;
+    p->size -= newblock->size;
+    p->next = newblock;
+    p = newblock;
+  }
+
+  /* break right */
+  if (size < p->size) {
+    newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
+    newblock->ofs = startofs + size;
+    newblock->size = p->size - size;
+    newblock->free = 1;
+    newblock->next = p->next;
+    p->size = size;
+    p->next = newblock;
+  }
+
+  /* p = middle block */
+  p->align = alignment;
+  p->free = 0;
+  p->reserved = reserved;
+  return p;
+}
+
+PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch)
+{
+  int mask,startofs,endofs;
+  TMemBlock *p;
+
+  if (!heap || align2 < 0 || size <= 0)
+    return NULL;
+  mask = (1 << align2)-1;
+  startofs = 0;
+  p = (TMemBlock *)heap;
+  while (p) {
+    if (ISFREE(p)) {
+      startofs = (p->ofs + mask) & ~mask;
+      if ( startofs < startSearch ) {
+      	startofs = startSearch;
+      }
+      endofs = startofs+size;
+      if (endofs <= (p->ofs+p->size))
+	break;
+    }
+    p = p->next;
+  }
+  if (!p)
+    return NULL;
+  p = SliceBlock(p,startofs,size,0,mask+1);
+  p->heap = heap;
+  return p;
+}
+
+static __inline__ int Join2Blocks(TMemBlock *p)
+{
+  if (p->free && p->next && p->next->free) {
+    TMemBlock *q = p->next;
+    p->size += q->size;
+    p->next = q->next;
+    free(q);
+    return 1;
+  }
+  return 0;
+}
+
+int mmFreeMem(PMemBlock b)
+{
+  TMemBlock *p,*prev;
+
+  if (!b)
+    return 0;
+  if (!b->heap) {
+     fprintf(stderr, "no heap\n");
+     return -1;
+  }
+  p = b->heap;
+  prev = NULL;
+  while (p && p != b) {
+    prev = p;
+    p = p->next;
+  }
+  if (!p || p->free || p->reserved) {
+     if (!p)
+	fprintf(stderr, "block not found in heap\n");
+     else if (p->free)
+	fprintf(stderr, "block already free\n");
+     else
+	fprintf(stderr, "block is reserved\n");
+    return -1;
+  }
+  p->free = 1;
+  Join2Blocks(p);
+  if (prev)
+    Join2Blocks(prev);
+  return 0;
+}
+
+int mmReserveMem(memHeap_t *heap, int offset,int size)
+{
+  int endofs;
+  TMemBlock *p;
+
+  if (!heap || size <= 0)
+    return -1;
+  endofs = offset+size;
+  p = (TMemBlock *)heap;
+  while (p && p->ofs <= offset) {
+    if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
+      SliceBlock(p,offset,size,1,1);
+      return 0;
+    }
+    p = p->next;
+  }
+  return -1;
+}
+
+int mmFreeReserved(memHeap_t *heap, int offset)
+{
+  TMemBlock *p,*prev;
+
+  if (!heap)
+    return -1;
+  p = (TMemBlock *)heap;
+  prev = NULL;
+  while (p && p->ofs != offset) {
+    prev = p;
+    p = p->next;
+  }
+  if (!p || !p->reserved)
+    return -1;
+  p->free = 1;
+  p->reserved = 0;
+  Join2Blocks(p);
+  if (prev)
+    Join2Blocks(prev);
+  return 0;
+}
+
+void mmDestroy(memHeap_t *heap)
+{
+  TMemBlock *p,*q;
+
+  if (!heap)
+    return;
+  p = (TMemBlock *)heap;
+  while (p) {
+    q = p->next;
+    free(p);
+    p = q;
+  }
+}
diff --git a/xc/lib/GL/mesa/src/drv/common/mm.h b/xc/lib/GL/mesa/src/drv/common/mm.h
new file mode 100644
index 000000000..6fa6e8b69
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/mm.h
@@ -0,0 +1,101 @@
+/*
+ * GLX Hardware Device Driver common code
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 MM_INC
+#define MM_INC
+
+struct mem_block_t {
+  struct mem_block_t *next;
+  struct mem_block_t *heap;
+  int ofs,size;
+  int align;
+  int free:1;
+  int reserved:1;
+};
+typedef struct mem_block_t TMemBlock;
+typedef struct mem_block_t *PMemBlock;
+
+/* a heap is just the first block in a chain */
+typedef struct mem_block_t memHeap_t;
+
+static __inline__ int mmBlockSize(PMemBlock b)
+{ return b->size; }
+
+static __inline__ int mmOffset(PMemBlock b)
+{ return b->ofs; }
+
+static __inline__ void mmMarkReserved(PMemBlock b)
+{ b->reserved = 1; }
+
+/* 
+ * input: total size in bytes
+ * return: a heap pointer if OK, NULL if error
+ */
+memHeap_t *mmInit( int ofs, int size );
+
+
+
+memHeap_t *mmAddRange( memHeap_t *heap,
+		       int ofs,
+		       int size );
+
+
+/*
+ * Allocate 'size' bytes with 2^align2 bytes alignment,
+ * restrict the search to free memory after 'startSearch'
+ * depth and back buffers should be in different 4mb banks
+ * to get better page hits if possible
+ * input:	size = size of block
+ *       	align2 = 2^align2 bytes alignment
+ *		startSearch = linear offset from start of heap to begin search
+ * return: pointer to the allocated block, 0 if error
+ */
+PMemBlock  mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch );
+
+/*
+ * Free block starts at offset
+ * input: pointer to a block
+ * return: 0 if OK, -1 if error
+ */
+int  mmFreeMem( PMemBlock b );
+
+/*
+ * Reserve 'size' bytes block start at offset
+ * This is used to prevent allocation of memory already used
+ * by the X server for the front buffer, pixmaps, and cursor
+ * input: size, offset
+ * output: 0 if OK, -1 if error
+ */
+int mmReserveMem( memHeap_t *heap, int offset,int size );
+int mmFreeReserved( memHeap_t *heap, int offset );
+
+/*
+ * destroy MM
+ */
+void mmDestroy( memHeap_t *mmInit );
+
+/* For debuging purpose. */
+void mmDumpMemInfo( memHeap_t *mmInit );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/common/mmx.h b/xc/lib/GL/mesa/src/drv/common/mmx.h
new file mode 100644
index 000000000..49ce7e3e3
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/mmx.h
@@ -0,0 +1,560 @@
+/*	mmx.h
+
+	MultiMedia eXtensions GCC interface library for IA32.
+
+	To use this library, simply include this header file
+	and compile with GCC.  You MUST have inlining enabled
+	in order for mmx_ok() to work; this can be done by
+	simply using -O on the GCC command line.
+
+	Compiling with -DMMX_TRACE will cause detailed trace
+	output to be sent to stderr for each mmx operation.
+	This adds lots of code, and obviously slows execution to
+	a crawl, but can be very useful for debugging.
+
+	THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
+	EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
+	LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+	AND FITNESS FOR ANY PARTICULAR PURPOSE.
+
+	1997-98 by H. Dietz and R. Fisher
+
+ History:
+	97-98*	R.Fisher	Early versions
+	980501	R.Fisher	Original Release
+	980611*	H.Dietz		Rewrite, correctly implementing inlines, and
+		R.Fisher	 including direct register accesses.
+	980616	R.Fisher	Release of 980611 as 980616.
+	980714	R.Fisher	Minor corrections to Makefile, etc.
+	980715	R.Fisher	mmx_ok() now prevents optimizer from using
+				 clobbered values.
+				mmx_ok() now checks if cpuid instruction is
+				 available before trying to use it.
+	980726*	R.Fisher	mm_support() searches for AMD 3DNow, Cyrix
+				 Extended MMX, and standard MMX.  It returns a
+				 value which is positive if any of these are
+				 supported, and can be masked with constants to
+				 see which.  mmx_ok() is now a call to this
+	980726*	R.Fisher	Added i2r support for shift functions
+	980919	R.Fisher	Fixed AMD extended feature recognition bug.
+	980921	R.Fisher	Added definition/check for _MMX_H.
+				Added "float s[2]" to mmx_t for use with
+				  3DNow and EMMX.  So same mmx_t can be used.
+	981013	R.Fisher	Fixed cpuid function 1 bug (looked at wrong reg)
+				Fixed psllq_i2r error in mmxtest.c
+
+	* Unreleased (internal or interim) versions
+
+ Notes:
+	It appears that the latest gas has the pand problem fixed, therefore
+	  I'll undefine BROKEN_PAND by default.
+	String compares may be quicker than the multiple test/jumps in vendor
+	  test sequence in mmx_ok(), but I'm not concerned with that right now.
+
+ Acknowledgments:
+	Jussi Laako for pointing out the errors ultimately found to be
+	  connected to the failure to notify the optimizer of clobbered values.
+	Roger Hardiman for reminding us that CPUID isn't everywhere, and that
+	  someone may actually try to use this on a machine without CPUID.
+	  Also for suggesting code for checking this.
+	Robert Dale for pointing out the AMD recognition bug.
+	Jimmy Mayfield and Carl Witty for pointing out the Intel recognition
+	  bug.
+	Carl Witty for pointing out the psllq_i2r test bug.
+*/
+
+#ifndef _MMX_H
+#define _MMX_H
+
+//#define MMX_TRACE
+
+/*	Warning:  at this writing, the version of GAS packaged
+	with most Linux distributions does not handle the
+	parallel AND operation mnemonic correctly.  If the
+	symbol BROKEN_PAND is defined, a slower alternative
+	coding will be used.  If execution of mmxtest results
+	in an illegal instruction fault, define this symbol.
+*/
+#undef	BROKEN_PAND
+
+
+/*	The type of an value that fits in an MMX register
+	(note that long long constant values MUST be suffixed
+	 by LL and unsigned long long values by ULL, lest
+	 they be truncated by the compiler)
+*/
+typedef	union {
+	long long		q;	/* Quadword (64-bit) value */
+	unsigned long long	uq;	/* Unsigned Quadword */
+	int			d[2];	/* 2 Doubleword (32-bit) values */
+	unsigned int		ud[2];	/* 2 Unsigned Doubleword */
+	short			w[4];	/* 4 Word (16-bit) values */
+	unsigned short		uw[4];	/* 4 Unsigned Word */
+	char			b[8];	/* 8 Byte (8-bit) values */
+	unsigned char		ub[8];	/* 8 Unsigned Byte */
+	float			s[2];	/* Single-precision (32-bit) value */
+} mmx_t;
+
+/*	Helper functions for the instruction macros that follow...
+	(note that memory-to-register, m2r, instructions are nearly
+	 as efficient as register-to-register, r2r, instructions;
+	 however, memory-to-memory instructions are really simulated
+	 as a convenience, and are only 1/3 as efficient)
+*/
+#ifdef	MMX_TRACE
+
+/*	Include the stuff for printing a trace to stderr...
+*/
+
+#include <stdio.h>
+
+#define	mmx_i2r(op, imm, reg) \
+	{ \
+		mmx_t mmx_trace; \
+		mmx_trace = (imm); \
+		fprintf(stderr, #op "_i2r(" #imm "=0x%016llx, ", mmx_trace.q); \
+		__asm__ __volatile__ ("movq %%" #reg ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #reg "=0x%016llx) => ", mmx_trace.q); \
+		__asm__ __volatile__ (#op " %0, %%" #reg \
+				      : /* nothing */ \
+				      : "X" (imm)); \
+		__asm__ __volatile__ ("movq %%" #reg ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #reg "=0x%016llx\n", mmx_trace.q); \
+	}
+
+#define	mmx_m2r(op, mem, reg) \
+	{ \
+		mmx_t mmx_trace; \
+		mmx_trace = (mem); \
+		fprintf(stderr, #op "_m2r(" #mem "=0x%016llx, ", mmx_trace.q); \
+		__asm__ __volatile__ ("movq %%" #reg ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #reg "=0x%016llx) => ", mmx_trace.q); \
+		__asm__ __volatile__ (#op " %0, %%" #reg \
+				      : /* nothing */ \
+				      : "X" (mem)); \
+		__asm__ __volatile__ ("movq %%" #reg ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #reg "=0x%016llx\n", mmx_trace.q); \
+	}
+
+#define	mmx_r2m(op, reg, mem) \
+	{ \
+		mmx_t mmx_trace; \
+		__asm__ __volatile__ ("movq %%" #reg ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #op "_r2m(" #reg "=0x%016llx, ", mmx_trace.q); \
+		mmx_trace = (mem); \
+		fprintf(stderr, #mem "=0x%016llx) => ", mmx_trace.q); \
+		__asm__ __volatile__ (#op " %%" #reg ", %0" \
+				      : "=X" (mem) \
+				      : /* nothing */ ); \
+		mmx_trace = (mem); \
+		fprintf(stderr, #mem "=0x%016llx\n", mmx_trace.q); \
+	}
+
+#define	mmx_r2r(op, regs, regd) \
+	{ \
+		mmx_t mmx_trace; \
+		__asm__ __volatile__ ("movq %%" #regs ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #op "_r2r(" #regs "=0x%016llx, ", mmx_trace.q); \
+		__asm__ __volatile__ ("movq %%" #regd ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #regd "=0x%016llx) => ", mmx_trace.q); \
+		__asm__ __volatile__ (#op " %" #regs ", %" #regd); \
+		__asm__ __volatile__ ("movq %%" #regd ", %0" \
+				      : "=X" (mmx_trace) \
+				      : /* nothing */ ); \
+		fprintf(stderr, #regd "=0x%016llx\n", mmx_trace.q); \
+	}
+
+#define	mmx_m2m(op, mems, memd) \
+	{ \
+		mmx_t mmx_trace; \
+		mmx_trace = (mems); \
+		fprintf(stderr, #op "_m2m(" #mems "=0x%016llx, ", mmx_trace.q); \
+		mmx_trace = (memd); \
+		fprintf(stderr, #memd "=0x%016llx) => ", mmx_trace.q); \
+		__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
+				      #op " %1, %%mm0\n\t" \
+				      "movq %%mm0, %0" \
+				      : "=X" (memd) \
+				      : "X" (mems)); \
+		mmx_trace = (memd); \
+		fprintf(stderr, #memd "=0x%016llx\n", mmx_trace.q); \
+	}
+
+#else
+
+/*	These macros are a lot simpler without the tracing...
+*/
+
+#define	mmx_i2r(op, imm, reg) \
+	__asm__ __volatile__ (#op " $" #imm ", %%" #reg \
+			      : /* nothing */ \
+			      : /* nothing */);
+
+#define	mmx_m2r(op, mem, reg) \
+	__asm__ __volatile__ (#op " %0, %%" #reg \
+			      : /* nothing */ \
+			      : "X" (mem))
+
+#define	mmx_r2m(op, reg, mem) \
+	__asm__ __volatile__ (#op " %%" #reg ", %0" \
+			      : "=X" (mem) \
+			      : /* nothing */ )
+
+#define	mmx_r2r(op, regs, regd) \
+	__asm__ __volatile__ (#op " %" #regs ", %" #regd)
+
+#define	mmx_m2m(op, mems, memd) \
+	__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
+			      #op " %1, %%mm0\n\t" \
+			      "movq %%mm0, %0" \
+			      : "=X" (memd) \
+			      : "X" (mems))
+
+#endif
+
+
+/*	1x64 MOVe Quadword
+	(this is both a load and a store...
+	 in fact, it is the only way to store)
+*/
+#define	movq_m2r(var, reg)	mmx_m2r(movq, var, reg)
+#define	movq_r2m(reg, var)	mmx_r2m(movq, reg, var)
+#define	movq_r2r(regs, regd)	mmx_r2r(movq, regs, regd)
+#define	movq(vars, vard) \
+	__asm__ __volatile__ ("movq %1, %%mm0\n\t" \
+			      "movq %%mm0, %0" \
+			      : "=X" (vard) \
+			      : "X" (vars))
+
+
+/*	1x32 MOVe Doubleword
+	(like movq, this is both load and store...
+	 but is most useful for moving things between
+	 mmx registers and ordinary registers)
+*/
+#define	movd_m2r(var, reg)	mmx_m2r(movd, var, reg)
+#define	movd_r2m(reg, var)	mmx_r2m(movd, reg, var)
+#define	movd_r2r(regs, regd)	mmx_r2r(movd, regs, regd)
+#define	movd(vars, vard) \
+	__asm__ __volatile__ ("movd %1, %%mm0\n\t" \
+			      "movd %%mm0, %0" \
+			      : "=X" (vard) \
+			      : "X" (vars))
+
+
+/*	2x32, 4x16, and 8x8 Parallel ADDs
+*/
+#define	paddd_m2r(var, reg)	mmx_m2r(paddd, var, reg)
+#define	paddd_r2r(regs, regd)	mmx_r2r(paddd, regs, regd)
+#define	paddd(vars, vard)	mmx_m2m(paddd, vars, vard)
+
+#define	paddw_m2r(var, reg)	mmx_m2r(paddw, var, reg)
+#define	paddw_r2r(regs, regd)	mmx_r2r(paddw, regs, regd)
+#define	paddw(vars, vard)	mmx_m2m(paddw, vars, vard)
+
+#define	paddb_m2r(var, reg)	mmx_m2r(paddb, var, reg)
+#define	paddb_r2r(regs, regd)	mmx_r2r(paddb, regs, regd)
+#define	paddb(vars, vard)	mmx_m2m(paddb, vars, vard)
+
+
+/*	4x16 and 8x8 Parallel ADDs using Saturation arithmetic
+*/
+#define	paddsw_m2r(var, reg)	mmx_m2r(paddsw, var, reg)
+#define	paddsw_r2r(regs, regd)	mmx_r2r(paddsw, regs, regd)
+#define	paddsw(vars, vard)	mmx_m2m(paddsw, vars, vard)
+
+#define	paddsb_m2r(var, reg)	mmx_m2r(paddsb, var, reg)
+#define	paddsb_r2r(regs, regd)	mmx_r2r(paddsb, regs, regd)
+#define	paddsb(vars, vard)	mmx_m2m(paddsb, vars, vard)
+
+
+/*	4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
+*/
+#define	paddusw_m2r(var, reg)	mmx_m2r(paddusw, var, reg)
+#define	paddusw_r2r(regs, regd)	mmx_r2r(paddusw, regs, regd)
+#define	paddusw(vars, vard)	mmx_m2m(paddusw, vars, vard)
+
+#define	paddusb_m2r(var, reg)	mmx_m2r(paddusb, var, reg)
+#define	paddusb_r2r(regs, regd)	mmx_r2r(paddusb, regs, regd)
+#define	paddusb(vars, vard)	mmx_m2m(paddusb, vars, vard)
+
+
+/*	2x32, 4x16, and 8x8 Parallel SUBs
+*/
+#define	psubd_m2r(var, reg)	mmx_m2r(psubd, var, reg)
+#define	psubd_r2r(regs, regd)	mmx_r2r(psubd, regs, regd)
+#define	psubd(vars, vard)	mmx_m2m(psubd, vars, vard)
+
+#define	psubw_m2r(var, reg)	mmx_m2r(psubw, var, reg)
+#define	psubw_r2r(regs, regd)	mmx_r2r(psubw, regs, regd)
+#define	psubw(vars, vard)	mmx_m2m(psubw, vars, vard)
+
+#define	psubb_m2r(var, reg)	mmx_m2r(psubb, var, reg)
+#define	psubb_r2r(regs, regd)	mmx_r2r(psubb, regs, regd)
+#define	psubb(vars, vard)	mmx_m2m(psubb, vars, vard)
+
+
+/*	4x16 and 8x8 Parallel SUBs using Saturation arithmetic
+*/
+#define	psubsw_m2r(var, reg)	mmx_m2r(psubsw, var, reg)
+#define	psubsw_r2r(regs, regd)	mmx_r2r(psubsw, regs, regd)
+#define	psubsw(vars, vard)	mmx_m2m(psubsw, vars, vard)
+
+#define	psubsb_m2r(var, reg)	mmx_m2r(psubsb, var, reg)
+#define	psubsb_r2r(regs, regd)	mmx_r2r(psubsb, regs, regd)
+#define	psubsb(vars, vard)	mmx_m2m(psubsb, vars, vard)
+
+
+/*	4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
+*/
+#define	psubusw_m2r(var, reg)	mmx_m2r(psubusw, var, reg)
+#define	psubusw_r2r(regs, regd)	mmx_r2r(psubusw, regs, regd)
+#define	psubusw(vars, vard)	mmx_m2m(psubusw, vars, vard)
+
+#define	psubusb_m2r(var, reg)	mmx_m2r(psubusb, var, reg)
+#define	psubusb_r2r(regs, regd)	mmx_r2r(psubusb, regs, regd)
+#define	psubusb(vars, vard)	mmx_m2m(psubusb, vars, vard)
+
+
+/*	4x16 Parallel MULs giving Low 4x16 portions of results
+*/
+#define	pmullw_m2r(var, reg)	mmx_m2r(pmullw, var, reg)
+#define	pmullw_r2r(regs, regd)	mmx_r2r(pmullw, regs, regd)
+#define	pmullw(vars, vard)	mmx_m2m(pmullw, vars, vard)
+
+
+/*	4x16 Parallel MULs giving High 4x16 portions of results
+*/
+#define	pmulhw_m2r(var, reg)	mmx_m2r(pmulhw, var, reg)
+#define	pmulhw_r2r(regs, regd)	mmx_r2r(pmulhw, regs, regd)
+#define	pmulhw(vars, vard)	mmx_m2m(pmulhw, vars, vard)
+
+
+/*	4x16->2x32 Parallel Mul-ADD
+	(muls like pmullw, then adds adjacent 16-bit fields
+	 in the multiply result to make the final 2x32 result)
+*/
+#define	pmaddwd_m2r(var, reg)	mmx_m2r(pmaddwd, var, reg)
+#define	pmaddwd_r2r(regs, regd)	mmx_r2r(pmaddwd, regs, regd)
+#define	pmaddwd(vars, vard)	mmx_m2m(pmaddwd, vars, vard)
+
+
+/*	1x64 bitwise AND
+*/
+#ifdef	BROKEN_PAND
+#define	pand_m2r(var, reg) \
+	{ \
+		mmx_m2r(pandn, (mmx_t) -1LL, reg); \
+		mmx_m2r(pandn, var, reg); \
+	}
+#define	pand_r2r(regs, regd) \
+	{ \
+		mmx_m2r(pandn, (mmx_t) -1LL, regd); \
+		mmx_r2r(pandn, regs, regd) \
+	}
+#define	pand(vars, vard) \
+	{ \
+		movq_m2r(vard, mm0); \
+		mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
+		mmx_m2r(pandn, vars, mm0); \
+		movq_r2m(mm0, vard); \
+	}
+#else
+#define	pand_m2r(var, reg)	mmx_m2r(pand, var, reg)
+#define	pand_r2r(regs, regd)	mmx_r2r(pand, regs, regd)
+#define	pand(vars, vard)	mmx_m2m(pand, vars, vard)
+#endif
+
+
+/*	1x64 bitwise AND with Not the destination
+*/
+#define	pandn_m2r(var, reg)	mmx_m2r(pandn, var, reg)
+#define	pandn_r2r(regs, regd)	mmx_r2r(pandn, regs, regd)
+#define	pandn(vars, vard)	mmx_m2m(pandn, vars, vard)
+
+
+/*	1x64 bitwise OR
+*/
+#define	por_m2r(var, reg)	mmx_m2r(por, var, reg)
+#define	por_r2r(regs, regd)	mmx_r2r(por, regs, regd)
+#define	por(vars, vard)	mmx_m2m(por, vars, vard)
+
+
+/*	1x64 bitwise eXclusive OR
+*/
+#define	pxor_m2r(var, reg)	mmx_m2r(pxor, var, reg)
+#define	pxor_r2r(regs, regd)	mmx_r2r(pxor, regs, regd)
+#define	pxor(vars, vard)	mmx_m2m(pxor, vars, vard)
+
+
+/*	2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
+	(resulting fields are either 0 or -1)
+*/
+#define	pcmpeqd_m2r(var, reg)	mmx_m2r(pcmpeqd, var, reg)
+#define	pcmpeqd_r2r(regs, regd)	mmx_r2r(pcmpeqd, regs, regd)
+#define	pcmpeqd(vars, vard)	mmx_m2m(pcmpeqd, vars, vard)
+
+#define	pcmpeqw_m2r(var, reg)	mmx_m2r(pcmpeqw, var, reg)
+#define	pcmpeqw_r2r(regs, regd)	mmx_r2r(pcmpeqw, regs, regd)
+#define	pcmpeqw(vars, vard)	mmx_m2m(pcmpeqw, vars, vard)
+
+#define	pcmpeqb_m2r(var, reg)	mmx_m2r(pcmpeqb, var, reg)
+#define	pcmpeqb_r2r(regs, regd)	mmx_r2r(pcmpeqb, regs, regd)
+#define	pcmpeqb(vars, vard)	mmx_m2m(pcmpeqb, vars, vard)
+
+
+/*	2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
+	(resulting fields are either 0 or -1)
+*/
+#define	pcmpgtd_m2r(var, reg)	mmx_m2r(pcmpgtd, var, reg)
+#define	pcmpgtd_r2r(regs, regd)	mmx_r2r(pcmpgtd, regs, regd)
+#define	pcmpgtd(vars, vard)	mmx_m2m(pcmpgtd, vars, vard)
+
+#define	pcmpgtw_m2r(var, reg)	mmx_m2r(pcmpgtw, var, reg)
+#define	pcmpgtw_r2r(regs, regd)	mmx_r2r(pcmpgtw, regs, regd)
+#define	pcmpgtw(vars, vard)	mmx_m2m(pcmpgtw, vars, vard)
+
+#define	pcmpgtb_m2r(var, reg)	mmx_m2r(pcmpgtb, var, reg)
+#define	pcmpgtb_r2r(regs, regd)	mmx_r2r(pcmpgtb, regs, regd)
+#define	pcmpgtb(vars, vard)	mmx_m2m(pcmpgtb, vars, vard)
+
+
+/*	1x64, 2x32, and 4x16 Parallel Shift Left Logical
+*/
+#define	psllq_i2r(imm, reg)	mmx_i2r(psllq, imm, reg)
+#define	psllq_m2r(var, reg)	mmx_m2r(psllq, var, reg)
+#define	psllq_r2r(regs, regd)	mmx_r2r(psllq, regs, regd)
+#define	psllq(vars, vard)	mmx_m2m(psllq, vars, vard)
+
+#define	pslld_i2r(imm, reg)	mmx_i2r(pslld, imm, reg)
+#define	pslld_m2r(var, reg)	mmx_m2r(pslld, var, reg)
+#define	pslld_r2r(regs, regd)	mmx_r2r(pslld, regs, regd)
+#define	pslld(vars, vard)	mmx_m2m(pslld, vars, vard)
+
+#define	psllw_i2r(imm, reg)	mmx_i2r(psllw, imm, reg)
+#define	psllw_m2r(var, reg)	mmx_m2r(psllw, var, reg)
+#define	psllw_r2r(regs, regd)	mmx_r2r(psllw, regs, regd)
+#define	psllw(vars, vard)	mmx_m2m(psllw, vars, vard)
+
+
+/*	1x64, 2x32, and 4x16 Parallel Shift Right Logical
+*/
+#define	psrlq_i2r(imm, reg)	mmx_i2r(psrlq, imm, reg)
+#define	psrlq_m2r(var, reg)	mmx_m2r(psrlq, var, reg)
+#define	psrlq_r2r(regs, regd)	mmx_r2r(psrlq, regs, regd)
+#define	psrlq(vars, vard)	mmx_m2m(psrlq, vars, vard)
+
+#define	psrld_i2r(imm, reg)	mmx_i2r(psrld, imm, reg)
+#define	psrld_m2r(var, reg)	mmx_m2r(psrld, var, reg)
+#define	psrld_r2r(regs, regd)	mmx_r2r(psrld, regs, regd)
+#define	psrld(vars, vard)	mmx_m2m(psrld, vars, vard)
+
+#define	psrlw_i2r(imm, reg)	mmx_i2r(psrlw, imm, reg)
+#define	psrlw_m2r(var, reg)	mmx_m2r(psrlw, var, reg)
+#define	psrlw_r2r(regs, regd)	mmx_r2r(psrlw, regs, regd)
+#define	psrlw(vars, vard)	mmx_m2m(psrlw, vars, vard)
+
+
+/*	2x32 and 4x16 Parallel Shift Right Arithmetic
+*/
+#define	psrad_i2r(imm, reg)	mmx_i2r(psrad, imm, reg)
+#define	psrad_m2r(var, reg)	mmx_m2r(psrad, var, reg)
+#define	psrad_r2r(regs, regd)	mmx_r2r(psrad, regs, regd)
+#define	psrad(vars, vard)	mmx_m2m(psrad, vars, vard)
+
+#define	psraw_i2r(imm, reg)	mmx_i2r(psraw, imm, reg)
+#define	psraw_m2r(var, reg)	mmx_m2r(psraw, var, reg)
+#define	psraw_r2r(regs, regd)	mmx_r2r(psraw, regs, regd)
+#define	psraw(vars, vard)	mmx_m2m(psraw, vars, vard)
+
+
+/*	2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
+	(packs source and dest fields into dest in that order)
+*/
+#define	packssdw_m2r(var, reg)	mmx_m2r(packssdw, var, reg)
+#define	packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
+#define	packssdw(vars, vard)	mmx_m2m(packssdw, vars, vard)
+
+#define	packsswb_m2r(var, reg)	mmx_m2r(packsswb, var, reg)
+#define	packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
+#define	packsswb(vars, vard)	mmx_m2m(packsswb, vars, vard)
+
+
+/*	4x16->8x8 PACK and Unsigned Saturate
+	(packs source and dest fields into dest in that order)
+*/
+#define	packuswb_m2r(var, reg)	mmx_m2r(packuswb, var, reg)
+#define	packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
+#define	packuswb(vars, vard)	mmx_m2m(packuswb, vars, vard)
+
+
+/*	2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
+	(interleaves low half of dest with low half of source
+	 as padding in each result field)
+*/
+#define	punpckldq_m2r(var, reg)	mmx_m2r(punpckldq, var, reg)
+#define	punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
+#define	punpckldq(vars, vard)	mmx_m2m(punpckldq, vars, vard)
+
+#define	punpcklwd_m2r(var, reg)	mmx_m2r(punpcklwd, var, reg)
+#define	punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
+#define	punpcklwd(vars, vard)	mmx_m2m(punpcklwd, vars, vard)
+
+#define	punpcklbw_m2r(var, reg)	mmx_m2r(punpcklbw, var, reg)
+#define	punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
+#define	punpcklbw(vars, vard)	mmx_m2m(punpcklbw, vars, vard)
+
+
+/*	2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
+	(interleaves high half of dest with high half of source
+	 as padding in each result field)
+*/
+#define	punpckhdq_m2r(var, reg)	mmx_m2r(punpckhdq, var, reg)
+#define	punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
+#define	punpckhdq(vars, vard)	mmx_m2m(punpckhdq, vars, vard)
+
+#define	punpckhwd_m2r(var, reg)	mmx_m2r(punpckhwd, var, reg)
+#define	punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
+#define	punpckhwd(vars, vard)	mmx_m2m(punpckhwd, vars, vard)
+
+#define	punpckhbw_m2r(var, reg)	mmx_m2r(punpckhbw, var, reg)
+#define	punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
+#define	punpckhbw(vars, vard)	mmx_m2m(punpckhbw, vars, vard)
+
+
+/*	Empty MMx State
+	(used to clean-up when going from mmx to float use
+	 of the registers that are shared by both; note that
+	 there is no float-to-mmx operation needed, because
+	 only the float tag word info is corruptible)
+*/
+#ifdef	MMX_TRACE
+
+#define	emms() \
+	{ \
+		fprintf(stderr, "emms()\n"); \
+		__asm__ __volatile__ ("emms"); \
+	}
+
+#else
+
+#define	emms()			__asm__ __volatile__ ("emms")
+
+#endif
+
+#endif
+
diff --git a/xc/lib/GL/mesa/src/drv/common/spantmp.h b/xc/lib/GL/mesa/src/drv/common/spantmp.h
new file mode 100644
index 000000000..e10dca1a2
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/common/spantmp.h
@@ -0,0 +1,199 @@
+
+static void TAG(WriteRGBASpan)( const GLcontext *ctx, 
+				GLuint n, GLint x, GLint y, 
+				const GLubyte rgba[][4], 
+				const GLubyte mask[] )
+{
+   GLuint x1,n1;
+   LOCAL_VARS;
+
+   y = Y_FLIP(y);
+
+   if (DBG) fprintf(stderr, "WriteRGBASpan\n");
+
+   HW_CLIPLOOP() 
+      {
+	 GLuint i = 0;
+	 CLIPSPAN(x,y,n,x1,n1,i);
+	 if (mask)
+	 {
+	    for (i=0;i<n1;i++,x1++)
+	       if (mask[i])
+		  WRITE_RGBA( x1, y, 
+			      rgba[i][0], rgba[i][1], 
+			      rgba[i][2], rgba[i][3] );
+	 }
+	 else
+	 {
+	    for (i=0;i<n1;i++,x1++)
+	       WRITE_RGBA( x1, y, 
+			   rgba[i][0], rgba[i][1], 
+			   rgba[i][2], rgba[i][3] );
+	 }
+      }
+   HW_ENDCLIPLOOP();
+}
+
+static void TAG(WriteRGBSpan)( const GLcontext *ctx,
+			       GLuint n, GLint x, GLint y,
+			       const GLubyte rgb[][3], 
+			       const GLubyte mask[] )
+{
+   GLuint x1,n1;
+   LOCAL_VARS;
+
+   y = Y_FLIP(y);
+
+
+   if (DBG) fprintf(stderr, "WriteRGBSpan\n");
+
+   HW_CLIPLOOP() 
+      {
+	 GLuint i = 0;
+	 CLIPSPAN(x,y,n,x1,n1,i);
+
+	 if (mask)
+	 {
+	    for (;i<n1;i++,x1++)
+	       if (mask[i])
+		  WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 );
+	 }
+	 else
+	 {
+	    for (;i<n1;i++,x1++)
+	       WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 );
+	 }
+      }
+   HW_ENDCLIPLOOP();
+}
+
+static void TAG(WriteRGBAPixels)( const GLcontext *ctx,
+			       GLuint n, 
+			       const GLint x[], 
+			       const GLint y[],
+			       const GLubyte rgba[][4], 
+			       const GLubyte mask[] )
+{
+   GLuint i;
+   LOCAL_VARS;
+
+   if (DBG) fprintf(stderr, "WriteRGBAPixels\n");
+
+   HW_CLIPLOOP()
+      {
+	 for (i=0;i<n;i++)
+	 {
+	    if (mask[i]) {
+	       const int fy = Y_FLIP(y[i]);
+	       if (CLIPPIXEL(x[i],fy))
+		  WRITE_RGBA( x[i], fy, 
+			      rgba[i][0], rgba[i][1], 
+			      rgba[i][2], rgba[i][3] );
+	    }
+	 }
+      }
+   HW_ENDCLIPLOOP();
+}
+
+
+static void TAG(WriteMonoRGBASpan)( const GLcontext *ctx,	
+				    GLuint n, GLint x, GLint y, 
+				    const GLubyte mask[] )
+{
+   GLuint x1,n1;
+   LOCAL_VARS;
+   INIT_MONO_PIXEL(p);
+
+   y = Y_FLIP( y );
+
+   if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n");
+
+   HW_CLIPLOOP() 
+      {
+	 GLuint i = 0;
+	 CLIPSPAN(x,y,n,x1,n1,i);
+	 for (;i<n1;i++,x1++)
+	    if (mask[i])
+	       WRITE_PIXEL( x1, y, p );
+      }
+   HW_ENDCLIPLOOP();
+}
+
+
+static void TAG(WriteMonoRGBAPixels)( const GLcontext *ctx,
+				      GLuint n, 
+				      const GLint x[], const GLint y[],
+				      const GLubyte mask[] ) 
+{
+   GLuint i;
+   LOCAL_VARS;
+   INIT_MONO_PIXEL(p);
+
+   if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n");
+
+   HW_CLIPLOOP()
+      {
+	 for (i=0;i<n;i++)
+	    if (mask[i]) {
+	       int fy = Y_FLIP(y[i]);
+	       if (CLIPPIXEL( x[i], fy ))
+		  WRITE_PIXEL( x[i], fy, p );
+	    }
+      }
+   HW_ENDCLIPLOOP();
+}
+
+
+
+/*
+ * Read a horizontal span of color pixels.
+ */
+static void TAG(ReadRGBASpan)( const GLcontext *ctx,
+			       GLuint n, GLint x, GLint y,
+			       GLubyte rgba[][4])
+{
+   GLuint x1,n1;
+   LOCAL_VARS;
+
+   y = Y_FLIP(y);
+
+   if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+   HW_CLIPLOOP() 
+      {
+	 GLuint i = 0;
+	 CLIPSPAN(x,y,n,x1,n1,i);
+	 for (;i<n1;i++)
+	    READ_RGBA( rgba[i], x1+i, y );
+      }
+   HW_ENDCLIPLOOP();
+}
+
+static void TAG(ReadRGBAPixels)( const GLcontext *ctx,
+				 GLuint n, const GLint x[], const GLint y[],
+				 GLubyte rgba[][4], const GLubyte mask[] )
+{
+   GLuint i;
+   LOCAL_VARS;
+
+   if (DBG) fprintf(stderr, "ReadRGBAPixels\n");
+ 
+   HW_CLIPLOOP()
+      {
+	 for (i=0;i<n;i++)
+	    if (mask[i]) {
+	       int fy = Y_FLIP( y[i] );
+	       if (CLIPPIXEL( x[i], fy ))
+		  READ_RGBA( rgba[i], x[i], fy );
+	    }
+      }
+   HW_ENDCLIPLOOP();
+}
+
+
+
+
+#undef WRITE_PIXEL
+#undef WRITE_RGBA
+#undef READ_RGBA
+#undef TAG
diff --git a/xc/lib/GL/mesa/src/drv/gamma/Imakefile b/xc/lib/GL/mesa/src/drv/gamma/Imakefile
index 68313f826..98caebf5d 100644
--- a/xc/lib/GL/mesa/src/drv/gamma/Imakefile
+++ b/xc/lib/GL/mesa/src/drv/gamma/Imakefile
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/lib/GL/mesa/src/drv/gamma/Imakefile,v 1.4 1999/12/14 01:33:38 robin Exp $
+XCOMM $XFree86: xc/lib/GL/mesa/src/drv/gamma/Imakefile,v 1.6 2000/02/15 07:13:30 martin Exp $
 XCOMM $PI: xc/lib/GL/mesa/src/drv/gamma/Imakefile,v 1.6 1999/06/21 05:13:55 martin Exp $
 
 #define DoNormalLib NormalLibGlx
@@ -14,6 +14,7 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 #if BuildXF86DRI
   DRI_DEFINES = GlxDefines
  DRI_INCLUDES = -I../../../../dri -I../../../../glx \
+		-I../../../dri \
 		-I$(TOP)/include -I$(TOP)/include/GL \
 		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \
 		-I$(XF86DRIVERSRC)/glint \
@@ -24,11 +25,33 @@ MESA_INCLUDES = -I. -I.. -I../../include
 
       DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
      INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES)
-         SRCS = gamma_gl.c gamma_xmesa.c gamma_init.c gamma_matrix.c \
+
+      DRISRCS = ../../../dri/dri_mesa.c \
+		../../../../dri/dri_tmm.c
+
+      DRIOBJS = ../../../dri/dri_mesa.o \
+		../../../../dri/dri_tmm.o
+
+      DRMSRCS = ../../../../dri/drm/xf86drm.c \
+		../../../../dri/drm/xf86drmHash.c \
+		../../../../dri/drm/xf86drmRandom.c \
+		../../../../dri/drm/xf86drmSL.c
+
+      DRMOBJS = ../../../../dri/drm/xf86drm.o \
+		../../../../dri/drm/xf86drmHash.o \
+		../../../../dri/drm/xf86drmRandom.o \
+		../../../../dri/drm/xf86drmSL.o
+
+    GAMMASRCS = gamma_gl.c gamma_xmesa.c gamma_init.c gamma_matrix.c \
                 gamma_inithw.c gamma_texture.c
-         OBJS = gamma_gl.o gamma_xmesa.o gamma_init.o gamma_matrix.o \
+
+    GAMMAOBJS = gamma_gl.o gamma_xmesa.o gamma_init.o gamma_matrix.o \
                 gamma_inithw.o gamma_texture.o
 
+	 SRCS = $(DRISRCS) $(DRMSRCS) $(GAMMASRCS)
+	 OBJS = $(DRIOBJS) $(DRMOBJS) $(GAMMAOBJS)
+
+
 #if !GlxUseBuiltInDRIDriver
 #undef DoNormalLib NormalLibGlx
 #undef DoExtraLib SharedLibGlx
@@ -48,7 +71,7 @@ LIBNAME = gamma_dri.so
 ALL_OBJS = $(OBJS)
 ALL_DEPS = DONE
 SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
-InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+InstallDynamicModule($(LIBNAME),$(MODULEDIR)/dri,.)
 #endif
 
 DependTarget()
diff --git a/xc/lib/GL/mesa/src/drv/i810/Imakefile b/xc/lib/GL/mesa/src/drv/i810/Imakefile
new file mode 100644
index 000000000..4212adbd6
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/Imakefile
@@ -0,0 +1,64 @@
+XCOMM $PI:$
+
+#define DoNormalLib NormalLibGlx
+#define DoSharedLib SharedLibGlx
+#define DoExtraLib SharedLibGlx
+#define DoDebugLib DebugLibGlx
+#define DoProfileLib ProfileLibGlx
+
+#if Malloc0ReturnsNull
+ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
+#endif
+
+#if BuildXF86DRI
+  DRI_DEFINES = GlxDefines -DDRIVERTS
+ DRI_INCLUDES = -I../../../../dri -I../../../../glx \
+		-I$(TOP)/include -I$(TOP)/include/GL \
+		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \
+		-I$(XF86DRIVERSRC)/i810  \
+		-I../../../include -I../.. -I../common -I../../X
+#endif
+
+MESA_INCLUDES = -I. -I.. -I../../include
+
+
+
+      DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
+     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \
+		-I/usr/include/glide
+      DRISRCS = i810_xmesa.c i810clear.c	\
+		i810dd.c i810depth.c i810dma.c i810ring.c		\
+		i810pipeline.c i810span.c i810state.c i810swap.c	\
+		i810tex.c i810tris.c i810vb.c i810fastpath.c
+
+      DRIOBJS = i810_xmesa.o i810clear.o	\
+		i810dd.o i810depth.o i810dma.o i810ring.o		\
+		i810pipeline.o i810span.o i810state.o i810swap.o	\
+		i810tex.o i810tris.o i810vb.o i810fastpath.o
+
+	 SRCS = $(DRISRCS) 
+	 OBJS = $(DRIOBJS) 
+
+#if !GlxUseBuiltInDRIDriver
+#undef DoNormalLib NormalLibGlx
+#undef DoExtraLib SharedLibGlx
+#undef DoDebugLib DebugLibGlx
+#undef DoProfileLib ProfileLibGlx
+#endif
+
+#include <Library.tmpl>
+
+LibraryObjectRule()
+
+SubdirLibraryRule($(OBJS))
+NormalLintTarget($(SRCS))
+
+#if !GlxUseBuiltInDRIDriver
+LIBNAME = i810_dri.so
+ALL_OBJS = $(OBJS)
+ALL_DEPS = DONE
+SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
+InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+#endif
+
+DependTarget()
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h b/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h
new file mode 100644
index 000000000..8e6942497
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h
@@ -0,0 +1,724 @@
+
+
+#ifndef I810_3D_REG_H
+#define I810_3D_REG_H
+
+#include "i810_reg.h"
+
+/* Registers not used in the X server
+ */
+
+#define I810_NOP_ID           0x2094
+#define I810_NOP_ID_MASK        ((1<<22)-1)
+
+
+/* 3D instructions
+ */
+
+
+/* GFXRENDERSTATE_PV_PIXELIZATION_RULE, p149
+ *
+ * Format:
+ *     0: GFX_OP_PV_RULE | PV_*
+ *
+ */
+#define GFX_OP_PV_RULE           ((0x3<<29)|(0x7<<24))
+#define PV_SMALL_TRI_FILTER_ENABLE   (0x1<<11)
+#define PV_UPDATE_PIXRULE            (0x1<<10)
+#define PV_PIXRULE_ENABLE            (0x1<<9)
+#define PV_UPDATE_LINELIST           (0x1<<8)
+#define PV_LINELIST_MASK             (0x3<<6)
+#define PV_LINELIST_PV0              (0x0<<6)
+#define PV_LINELIST_PV1              (0x1<<6)
+#define PV_UPDATE_TRIFAN             (0x1<<5)
+#define PV_TRIFAN_MASK               (0x3<<3)
+#define PV_TRIFAN_PV0                (0x0<<3)
+#define PV_TRIFAN_PV1                (0x1<<3)
+#define PV_TRIFAN_PV2                (0x2<<3)
+#define PV_UPDATE_TRISTRIP           (0x1<<2)
+#define PV_TRISTRIP_MASK             (0x3<<0)
+#define PV_TRISTRIP_PV0              (0x0<<0)
+#define PV_TRISTRIP_PV1              (0x1<<0)
+#define PV_TRISTRIP_PV2              (0x2<<0)
+
+
+/* GFXRENDERSTATE_SCISSOR_ENABLE, p146
+ *
+ * Format:
+ *     0: GFX_OP_SCISSOR | SC_*
+ */
+#define GFX_OP_SCISSOR         ((0x3<<29)|(0x1c<<24)|(0x10<<19))
+#define SC_UPDATE_SCISSOR       (0x1<<1)
+#define SC_ENABLE_MASK          (0x1<<0)
+#define SC_ENABLE               (0x1<<0)
+
+/* GFXRENDERSTATE_SCISSOR_INFO, p147
+ *
+ * Format:
+ *     0: GFX_OP_SCISSOR_INFO
+ *     1: SCI_MIN_*
+ *     2: SCI_MAX_*
+ */
+#define GFX_OP_SCISSOR_INFO    ((0x3<<29)|(0x1d<<24)|(0x81<<16)|(0x1))
+#define SCI_YMIN_MASK      (0xffff<<16)
+#define SCI_XMIN_MASK      (0xffff<<0)
+#define SCI_YMAX_MASK      (0xffff<<16)
+#define SCI_XMAX_MASK      (0xffff<<0)
+
+/* GFXRENDERSTATE_DRAWING_RECT_INFO, p144
+ *
+ * Format:
+ *     0: GFX_OP_DRAWRECT_INFO
+ *     1: DR1_*
+ *     2: DR2_*
+ *     3: DR3_*
+ *     4: DR4_*
+ */
+#define GFX_OP_DRAWRECT_INFO   ((0x3<<29)|(0x1d<<24)|(0x80<<16)|(0x3))
+#define DR1_RECT_CLIP_ENABLE   (0x0<<31)
+#define DR1_RECT_CLIP_DISABLE  (0x1<<31)
+#define DR1_X_DITHER_BIAS_MASK (0x3<<26)
+#define DR1_X_DITHER_BIAS_SHIFT      26
+#define DR1_Y_DITHER_BIAS_MASK (0x3<<24)
+#define DR1_Y_DITHER_BIAS_SHIFT      24
+#define DR2_YMIN_MASK          (0xffff<<16)
+#define DR2_XMIN_MASK          (0xffff<<0)
+#define DR3_YMAX_MASK          (0xffff<<16)
+#define DR3_XMAX_MASK          (0xffff<<0)
+#define DR4_YORG_MASK          (0x3ff<<16)
+#define DR4_XORG_MASK          (0x7ff<<0)
+
+   
+/* GFXRENDERSTATE_LINEWIDTH_CULL_SHADE_MODE, p140
+ *
+ * Format:
+ *     0: GFX_OP_LINEWIDTH_CULL_SHADE_MODE | LCS_*
+ */
+#define GFX_OP_LINEWIDTH_CULL_SHADE_MODE  ((0x3<<29)|(0x2<<24))
+#define LCS_UPDATE_ZMODE        (0x1<<20)
+#define LCS_Z_MASK              (0xf<<16)
+#define LCS_Z_NEVER             (0x1<<16)
+#define LCS_Z_LESS              (0x2<<16)
+#define LCS_Z_EQUAL             (0x3<<16)
+#define LCS_Z_LEQUAL            (0x4<<16)
+#define LCS_Z_GREATER           (0x5<<16)
+#define LCS_Z_NOTEQUAL          (0x6<<16)
+#define LCS_Z_GEQUAL            (0x7<<16)
+#define LCS_Z_ALWAYS            (0x8<<16)
+#define LCS_UPDATE_LINEWIDTH    (0x1<<15)
+#define LCS_LINEWIDTH_MASK      (0x7<<12)
+#define LCS_LINEWIDTH_SHIFT           12
+#define LCS_UPDATE_ALPHA_INTERP (0x1<<11)
+#define LCS_ALPHA_FLAT          (0x0<<10)
+#define LCS_ALPHA_INTERP        (0x1<<10)
+#define LCS_UPDATE_FOG_INTERP   (0x1<<9)
+#define LCS_FOG_INTERP          (0x0<<8)
+#define LCS_FOG_FLAT            (0x1<<8)
+#define LCS_UPDATE_SPEC_INTERP  (0x1<<7)
+#define LCS_SPEC_INTERP         (0x0<<6)
+#define LCS_SPEC_FLAT           (0x1<<6)
+#define LCS_UPDATE_RGB_INTERP   (0x1<<5)
+#define LCS_RGB_INTERP          (0x0<<4)
+#define LCS_RGB_FLAT            (0x1<<4)
+#define LCS_UPDATE_CULL_MODE    (0x1<<3)
+#define LCS_CULL_MASK           (0x7<<0)
+#define LCS_CULL_DISABLE        (0x1<<0)
+#define LCS_CULL_CW             (0x2<<0)
+#define LCS_CULL_CCW            (0x3<<0)
+#define LCS_CULL_BOTH           (0x4<<0)
+
+#define LCS_INTERP_FLAT (LCS_ALPHA_FLAT|LCS_RGB_FLAT|LCS_SPEC_FLAT)
+#define LCS_UPDATE_INTERP (LCS_UPDATE_ALPHA_INTERP| 	\
+			   LCS_UPDATE_RGB_INTERP|	\
+			   LCS_UPDATE_SPEC_INTERP)
+          
+
+/* GFXRENDERSTATE_BOOLEAN_ENA_1, p142
+ *
+ */
+#define GFX_OP_BOOL_1           ((0x3<<29)|(0x3<<24))
+#define B1_UPDATE_SPEC_SETUP_ENABLE   (1<<19)
+#define B1_SPEC_SETUP_ENABLE          (1<<18)
+#define B1_UPDATE_ALPHA_SETUP_ENABLE  (1<<17)
+#define B1_ALPHA_SETUP_ENABLE         (1<<16)
+#define B1_UPDATE_CI_KEY_ENABLE       (1<<15)
+#define B1_CI_KEY_ENABLE              (1<<14)
+#define B1_UPDATE_CHROMAKEY_ENABLE    (1<<13)
+#define B1_CHROMAKEY_ENABLE           (1<<12)
+#define B1_UPDATE_Z_BIAS_ENABLE       (1<<11)
+#define B1_Z_BIAS_ENABLE              (1<<10)
+#define B1_UPDATE_SPEC_ENABLE         (1<<9)
+#define B1_SPEC_ENABLE                (1<<8)
+#define B1_UPDATE_FOG_ENABLE          (1<<7)
+#define B1_FOG_ENABLE                 (1<<6)
+#define B1_UPDATE_ALPHA_TEST_ENABLE   (1<<5)
+#define B1_ALPHA_TEST_ENABLE          (1<<4)
+#define B1_UPDATE_BLEND_ENABLE        (1<<3)
+#define B1_BLEND_ENABLE               (1<<2)
+#define B1_UPDATE_Z_TEST_ENABLE       (1<<1)
+#define B1_Z_TEST_ENABLE              (1<<0)
+
+/* GFXRENDERSTATE_BOOLEAN_ENA_2, p143
+ *
+ */
+#define GFX_OP_BOOL_2          ((0x3<<29)|(0x4<<24))
+#define B2_UPDATE_MAP_CACHE_ENABLE     (1<<17)
+#define B2_MAP_CACHE_ENABLE            (1<<16)
+#define B2_UPDATE_ALPHA_DITHER_ENABLE  (1<<15)
+#define B2_ALPHA_DITHER_ENABLE         (1<<14)
+#define B2_UPDATE_FOG_DITHER_ENABLE    (1<<13)
+#define B2_FOG_DITHER_ENABLE           (1<<12)
+#define B2_UPDATE_SPEC_DITHER_ENABLE   (1<<11)
+#define B2_SPEC_DITHER_ENABLE          (1<<10)
+#define B2_UPDATE_RGB_DITHER_ENABLE    (1<<9)
+#define B2_RGB_DITHER_ENABLE           (1<<8)
+#define B2_UPDATE_FB_WRITE_ENABLE      (1<<3)
+#define B2_FB_WRITE_ENABLE             (1<<2)
+#define B2_UPDATE_ZB_WRITE_ENABLE      (1<<1)
+#define B2_ZB_WRITE_ENABLE             (1<<0)
+
+
+/* GFXRENDERSTATE_FOG_COLOR, p144
+ */
+#define GFX_OP_FOG_COLOR       ((0x3<<29)|(0x15<<24))
+#define FOG_RED_SHIFT          16
+#define FOG_GREEN_SHIFT        8
+#define FOG_BLUE_SHIFT         0
+#define FOG_RESERVED_MASK      ((0x7<<16)|(0x3<<8)|(0x3))
+
+
+/* GFXRENDERSTATE_Z_BIAS_ALPHA_FUNC_REF, p139
+ */
+#define GFX_OP_ZBIAS_ALPHAFUNC ((0x3<<29)|(0x14<<24))
+#define ZA_UPDATE_ZBIAS        (1<<22)
+#define ZA_ZBIAS_SHIFT         14
+#define ZA_ZBIAS_MASK          (0xff<<14)
+#define ZA_UPDATE_ALPHAFUNC    (1<<13)
+#define ZA_ALPHA_MASK          (0xf<<9)
+#define ZA_ALPHA_NEVER         (1<<9)
+#define ZA_ALPHA_LESS          (2<<9)
+#define ZA_ALPHA_EQUAL         (3<<9)
+#define ZA_ALPHA_LEQUAL        (4<<9)
+#define ZA_ALPHA_GREATER       (5<<9)
+#define ZA_ALPHA_NOTEQUAL      (6<<9)
+#define ZA_ALPHA_GEQUAL        (7<<9)
+#define ZA_ALPHA_ALWAYS        (8<<9)
+#define ZA_UPDATE_ALPHAREF     (1<<8)
+#define ZA_ALPHAREF_MASK       (0xff<<0)
+#define ZA_ALPHAREF_SHIFT      0
+#define ZA_ALPHAREF_RESERVED   (0x7<<0)
+
+
+/* GFXRENDERSTATE_SRC_DST_BLEND_MONO, p136
+ */
+#define GFX_OP_SRC_DEST_MONO    ((0x3<<29)|(0x8<<24))
+#define SDM_UPDATE_MONO_ENABLE      (1<<13)
+#define SDM_MONO_ENABLE             (1<<12)
+#define SDM_UPDATE_SRC_BLEND        (1<<11)
+#define SDM_SRC_MASK               (0xf<<6)
+#define SDM_SRC_ZERO               (0x1<<6)
+#define SDM_SRC_ONE                (0x2<<6)
+#define SDM_SRC_SRC_COLOR          (0x3<<6)
+#define SDM_SRC_INV_SRC_COLOR      (0x4<<6)
+#define SDM_SRC_SRC_ALPHA          (0x5<<6)
+#define SDM_SRC_INV_SRC_ALPHA      (0x6<<6)
+#define SDM_SRC_DST_COLOR          (0x9<<6)
+#define SDM_SRC_INV_DST_COLOR      (0xa<<6)
+#define SDM_SRC_BOTH_SRC_ALPHA     (0xc<<6)
+#define SDM_SRC_BOTH_INV_SRC_ALPHA (0xd<<6)
+#define SDM_UPDATE_DST_BLEND        (1<<5)
+#define SDM_DST_MASK               (0xf<<0)
+#define SDM_DST_ZERO               (0x1<<0)
+#define SDM_DST_ONE                (0x2<<0)
+#define SDM_DST_SRC_COLOR          (0x3<<0)
+#define SDM_DST_INV_SRC_COLOR      (0x4<<0)
+#define SDM_DST_SRC_ALPHA          (0x5<<0)
+#define SDM_DST_INV_SRC_ALPHA      (0x6<<0)
+#define SDM_DST_DST_COLOR          (0x9<<0)
+#define SDM_DST_INV_DST_COLOR      (0xa<<0)
+#define SDM_DST_BOTH_SRC_ALPHA     (0xc<<0)
+#define SDM_DST_BOTH_INV_SRC_ALPHA (0xd<<0)
+
+
+/* GFXRENDERSTATE_COLOR_FACTOR, p134
+ *
+ * Format:
+ *     0: GFX_OP_COLOR_FACTOR
+ *     1: ARGB8888 color factor
+ */
+#define GFX_OP_COLOR_FACTOR      ((0x3<<29)|(0x1d<<24)|(0x1<<16)|0x0)
+
+/* GFXRENDERSTATE_MAP_ALPHA_BLEND_STAGES, p132
+ */
+#define GFX_OP_MAP_ALPHA_STAGES  ((0x3<<29)|(0x1<<24))
+#define MA_STAGE_SHIFT           20
+#define MA_STAGE_0               (0<<20)
+#define MA_STAGE_1               (1<<20)
+#define MA_STAGE_2               (2<<20)
+#define MA_UPDATE_ARG1           (1<<18)
+#define MA_ARG1_MASK             ((0x7<<15)|(0x1<<13))
+#define MA_ARG1_ALPHA_FACTOR     (0x1<<15)
+#define MA_ARG1_ITERATED_ALPHA   (0x3<<15)
+#define MA_ARG1_CURRENT_ALPHA    (0x5<<15)
+#define MA_ARG1_TEX0_ALPHA       (0x6<<15)
+#define MA_ARG1_TEX1_ALPHA       (0x7<<15)
+#define MA_ARG1_INVERT           (0x1<<13)
+#define MA_ARG1_DONT_INVERT      (0x0<<13)
+#define MA_UPDATE_ARG2           (1<<12)
+#define MA_ARG2_MASK             ((0x7<<8)|(0x1<<6))
+#define MA_ARG2_ALPHA_FACTOR     (0x1<<8)
+#define MA_ARG2_ITERATED_ALPHA   (0x3<<8)
+#define MA_ARG2_CURRENT_ALPHA    (0x5<<8)
+#define MA_ARG2_TEX0_ALPHA       (0x6<<8)
+#define MA_ARG2_TEX1_ALPHA       (0x7<<8)
+#define MA_ARG2_INVERT           (0x1<<6)
+#define MA_ARG2_DONT_INVERT      (0x0<<6)
+#define MA_UPDATE_OP             (1<<5)
+#define MA_OP_MASK                   (0xf)
+#define MA_OP_ARG1                   (0x1)
+#define MA_OP_ARG2                   (0x2)
+#define MA_OP_MODULATE               (0x3)
+#define MA_OP_MODULATE_X2            (0x4)
+#define MA_OP_MODULATE_X4            (0x5)
+#define MA_OP_ADD                    (0x6)
+#define MA_OP_ADD_SIGNED             (0x7)
+#define MA_OP_LIN_BLEND_ITER_ALPHA   (0x8)
+#define MA_OP_LIN_BLEND_ALPHA_FACTOR (0xa)
+#define MA_OP_LIN_BLEND_TEX0_ALPHA   (0x10)
+#define MA_OP_LIN_BLEND_TEX1_ALPHA   (0x11)
+
+
+/* GFXRENDERSTATE_MAP_COLOR_BLEND_STAGES, p129
+ */
+#define GFX_OP_MAP_COLOR_STAGES  ((0x3<<29)|(0x0<<24))
+#define MC_STAGE_SHIFT           20
+#define MC_STAGE_0               (0<<20)
+#define MC_STAGE_1               (1<<20)
+#define MC_STAGE_2               (2<<20)
+#define MC_UPDATE_DEST           (1<<19)
+#define MC_DEST_MASK             (1<<18)
+#define MC_DEST_CURRENT          (0<<18)
+#define MC_DEST_ACCUMULATOR      (1<<18)
+#define MC_UPDATE_ARG1           (1<<17)
+#define MC_ARG1_MASK             ((0x7<<14)|(0x1<<13)|(0x1<<12))
+#define MC_ARG1_ONE              (0x0<<14)
+#define MC_ARG1_COLOR_FACTOR     (0x1<<14)
+#define MC_ARG1_ACCUMULATOR      (0x2<<14)
+#define MC_ARG1_ITERATED_COLOR   (0x3<<14)
+#define MC_ARG1_SPECULAR_COLOR   (0x4<<14)
+#define MC_ARG1_CURRENT_COLOR    (0x5<<14)
+#define MC_ARG1_TEX0_COLOR       (0x6<<14)
+#define MC_ARG1_TEX1_COLOR       (0x7<<14)
+#define MC_ARG1_DONT_REPLICATE_ALPHA   (0x0<<13)
+#define MC_ARG1_REPLICATE_ALPHA        (0x1<<13)
+#define MC_ARG1_DONT_INVERT      (0x0<<12)
+#define MC_ARG1_INVERT           (0x1<<12)
+#define MC_UPDATE_ARG2           (1<<11)
+#define MC_ARG2_MASK             ((0x7<<8)|(0x1<<7)|(0x1<<6))
+#define MC_ARG2_ONE              (0x0<<8)
+#define MC_ARG2_COLOR_FACTOR     (0x1<<8)
+#define MC_ARG2_ACCUMULATOR      (0x2<<8)
+#define MC_ARG2_ITERATED_COLOR   (0x3<<8)
+#define MC_ARG2_SPECULAR_COLOR   (0x4<<8)
+#define MC_ARG2_CURRENT_COLOR    (0x5<<8)
+#define MC_ARG2_TEX0_COLOR       (0x6<<8)
+#define MC_ARG2_TEX1_COLOR       (0x7<<8)
+#define MC_ARG2_DONT_REPLICATE_ALPHA   (0x0<<7)
+#define MC_ARG2_REPLICATE_ALPHA        (0x1<<7)
+#define MC_ARG2_DONT_INVERT      (0x0<<6)
+#define MC_ARG2_INVERT           (0x1<<6)
+#define MC_UPDATE_OP             (1<<5)
+#define MC_OP_MASK                   (0xf)
+#define MC_OP_DISABLE                (0x0)
+#define MC_OP_ARG1                   (0x1)
+#define MC_OP_ARG2                   (0x2)
+#define MC_OP_MODULATE               (0x3)
+#define MC_OP_MODULATE_X2            (0x4)
+#define MC_OP_MODULATE_X4            (0x5)
+#define MC_OP_ADD                    (0x6)
+#define MC_OP_ADD_SIGNED             (0x7)
+#define MC_OP_LIN_BLEND_ITER_ALPHA   (0x8)
+#define MC_OP_LIN_BLEND_ALPHA_FACTOR (0xa)
+#define MC_OP_LIN_BLEND_TEX0_ALPHA   (0x10)
+#define MC_OP_LIN_BLEND_TEX1_ALPHA   (0x11)
+#define MC_OP_LIN_BLEND_TEX0_COLOR   (0x12)
+#define MC_OP_LIN_BLEND_TEX1_COLOR   (0x13)
+#define MC_OP_SUBTRACT               (0x14)
+
+/* GFXRENDERSTATE_MAP_PALETTE_LOAD, p128
+ * 
+ * Format:
+ *     0:  GFX_OP_MAP_PALETTE_LOAD
+ *     1:  16bpp color[0]
+ *     ...
+ *     256: 16bpp color[255]
+ */
+#define GFX_OP_MAP_PALETTE_LOAD ((0x3<<29)|(0x1d<<24)|(0x82<<16)|0xff)
+
+/* GFXRENDERSTATE_MAP_LOD_CONTROL, p127
+ */
+#define GFX_OP_MAP_LOD_CTL       ((0x3<<29)|(0x1c<<24)|(0x4<<19))
+#define MLC_MAP_ID_SHIFT         16
+#define MLC_MAP_0                (0<<16)
+#define MLC_MAP_1                (1<<16)
+#define MLC_UPDATE_DITHER_WEIGHT (1<<10)
+#define MLC_DITHER_WEIGHT_MASK   (0x3<<8)
+#define MLC_DITHER_WEIGHT_FULL   (0x0<<8)
+#define MLC_DITHER_WEIGHT_50     (0x1<<8)
+#define MLC_DITHER_WEIGHT_25     (0x2<<8)
+#define MLC_DITHER_WEIGHT_12     (0x3<<8)
+#define MLC_UPDATE_LOD_BIAS      (1<<7)
+#define MLC_LOD_BIAS_MASK        ((1<<7)-1)
+
+/* GFXRENDERSTATE_MAP_LOD_LIMITS, p126
+ */
+#define GFX_OP_MAP_LOD_LIMITS   ((0x3<<29)|(0x1c<<24)|(0x3<<19))
+#define MLL_MAP_ID_SHIFT         16
+#define MLL_MAP_0                (0<<16)
+#define MLL_MAP_1                (1<<16)
+#define MLL_UPDATE_MAX_MIP       (1<<13)
+#define MLL_MAX_MIP_SHIFT        5
+#define MLL_MAX_MIP_MASK         (0xff<<5)
+#define MLL_MAX_MIP_ONE          (0x10<<5)
+#define MLL_UPDATE_MIN_MIP       (1<<4)
+#define MLL_MIN_MIP_SHIFT        0
+#define MLL_MIN_MIP_MASK         (0xf<<0)
+
+/* GFXRENDERSTATE_MAP_FILTER, p124
+ */
+#define GFX_OP_MAP_FILTER       ((0x3<<29)|(0x1c<<24)|(0x2<<19))
+#define MF_MAP_ID_SHIFT         16
+#define MF_MAP_0                (0<<16)
+#define MF_MAP_1                (1<<16)
+#define MF_UPDATE_ANISOTROPIC   (1<<12)
+#define MF_ANISOTROPIC_MASK     (1<<10)
+#define MF_ANISOTROPIC_ENABLE   (1<<10)
+#define MF_UPDATE_MIP_FILTER    (1<<9)
+#define MF_MIP_MASK             (0x3<<6)
+#define MF_MIP_NONE             (0x0<<6)
+#define MF_MIP_NEAREST          (0x1<<6)
+#define MF_MIP_DITHER           (0x2<<6)
+#define MF_UPDATE_MAG_FILTER    (1<<5)
+#define MF_MAG_MASK             (1<<3)
+#define MF_MAG_LINEAR           (1<<3)
+#define MF_MAG_NEAREST          (0<<3)
+#define MF_UPDATE_MIN_FILTER    (1<<2)
+#define MF_MIN_MASK             (1<<0)
+#define MF_MIN_LINEAR           (1<<0)
+#define MF_MIN_NEAREST          (0<<0)
+
+/* GFXRENDERSTATE_MAP_INFO, p118
+ */
+#define GFX_OP_MAP_INFO      ((0x3<<29)|(0x1d<<24)|0x2)
+#define MI1_MAP_ID_SHIFT         28
+#define MI1_MAP_0                (0<<28)
+#define MI1_MAP_1                (1<<28)
+#define MI1_FMT_MASK             (0x7<<24)
+#define MI1_FMT_8CI              (0x0<<24)
+#define MI1_FMT_8BPP             (0x1<<24)
+#define MI1_FMT_16BPP            (0x2<<24)
+#define MI1_FMT_422              (0x5<<24)
+#define MI1_PF_MASK              (0x3<<21)
+#define MI1_PF_8CI_RGB565         (0x0<<21)
+#define MI1_PF_8CI_ARGB1555       (0x1<<21)
+#define MI1_PF_8CI_ARGB4444       (0x2<<21)
+#define MI1_PF_8CI_AY88           (0x3<<21)
+#define MI1_PF_16BPP_RGB565       (0x0<<21)
+#define MI1_PF_16BPP_ARGB1555     (0x1<<21)
+#define MI1_PF_16BPP_ARGB4444     (0x2<<21)
+#define MI1_PF_16BPP_AY88         (0x3<<21)
+#define MI1_PF_422_YCRCB_SWAP_Y   (0x0<<21)
+#define MI1_PF_422_YCRCB          (0x1<<21)
+#define MI1_PF_422_YCRCB_SWAP_UV  (0x2<<21)
+#define MI1_PF_422_YCRCB_SWAP_YUV (0x3<<21)
+#define MI1_OUTPUT_CHANNEL_MASK   (0x3<<19)
+#define MI1_COLOR_CONV_ENABLE     (1<<18)
+#define MI1_VERT_STRIDE_MASK      (1<<17)
+#define MI1_VERT_STRIDE_1         (1<<17)
+#define MI1_VERT_OFFSET_MASK      (1<<16)
+#define MI1_VERT_OFFSET_1         (1<<16)
+#define MI1_ENABLE_FENCE_REGS     (1<<10)
+#define MI1_TILED_SURFACE         (1<<9)
+#define MI1_TILE_WALK_X           (0<<8)
+#define MI1_TILE_WALK_Y           (1<<8)
+#define MI1_PITCH_MASK            (0xf<<0)
+#define MI2_DIMENSIONS_ARE_LOG2   (1<<31)
+#define MI2_DIMENSIONS_ARE_EXACT  (0<<31)
+#define MI2_HEIGHT_SHIFT          16
+#define MI2_HEIGHT_MASK           (0x1ff<<16)
+#define MI2_WIDTH_SHIFT           0
+#define MI2_WIDTH_MASK            (0x1ff<<0)
+#define MI3_BASE_ADDR_MASK        (~0xf)
+
+/* GFXRENDERSTATE_MAP_COORD_SETS, p116
+ */
+#define GFX_OP_MAP_COORD_SETS ((0x3<<29)|(0x1c<<24)|(0x1<<19))
+#define MCS_COORD_ID_SHIFT         16
+#define MCS_COORD_0                (0<<16)
+#define MCS_COORD_1                (1<<16)
+#define MCS_UPDATE_NORMALIZED      (1<<15)
+#define MCS_NORMALIZED_COORDS_MASK (1<<14)
+#define MCS_NORMALIZED_COORDS      (1<<14)
+#define MCS_UPDATE_V_STATE         (1<<7)
+#define MCS_V_STATE_MASK           (0x3<<4)
+#define MCS_V_WRAP                 (0x0<<4)
+#define MCS_V_MIRROR               (0x1<<4)
+#define MCS_V_CLAMP                (0x2<<4)
+#define MCS_V_WRAP_SHORTEST        (0x3<<4)
+#define MCS_UPDATE_U_STATE         (1<<3)
+#define MCS_U_STATE_MASK           (0x3<<0)
+#define MCS_U_WRAP                 (0x0<<0)
+#define MCS_U_MIRROR               (0x1<<0)
+#define MCS_U_CLAMP                (0x2<<0)
+#define MCS_U_WRAP_SHORTEST        (0x3<<0)
+
+/* GFXRENDERSTATE_MAP_TEXELS, p115
+ */
+#define GFX_OP_MAP_TEXELS   ((0x3<<29)|(0x1c<<24)|(0x0<<19))
+#define MT_UPDATE_TEXEL1_STATE     (1<<15)
+#define MT_TEXEL1_DISABLE          (0<<14)
+#define MT_TEXEL1_ENABLE           (1<<14)
+#define MT_TEXEL1_COORD0           (0<<11)
+#define MT_TEXEL1_COORD1           (1<<11)
+#define MT_TEXEL1_MAP0             (0<<8)
+#define MT_TEXEL1_MAP1             (1<<8)
+#define MT_UPDATE_TEXEL0_STATE     (1<<7)
+#define MT_TEXEL0_DISABLE          (0<<6)
+#define MT_TEXEL0_ENABLE           (1<<6)
+#define MT_TEXEL0_COORD0           (0<<3)
+#define MT_TEXEL0_COORD1           (1<<3)
+#define MT_TEXEL0_MAP0             (0<<0)
+#define MT_TEXEL0_MAP1             (1<<0)
+
+/* GFXRENDERSTATE_VERTEX_FORMAT, p110
+ */
+#define GFX_OP_VERTEX_FMT  ((0x3<<29)|(0x5<<24))
+#define VF_TEXCOORD_COUNT_SHIFT    8
+#define VF_TEXCOORD_COUNT_0        (0<<8)
+#define VF_TEXCOORD_COUNT_1        (1<<8)
+#define VF_TEXCOORD_COUNT_2        (2<<8)
+#define VF_SPEC_FOG_ENABLE         (1<<7)
+#define VF_RGBA_ENABLE             (1<<6)
+#define VF_Z_OFFSET_ENABLE         (1<<5)
+#define VF_XYZ                     (0x1<<1)
+#define VF_XYZW                    (0x2<<1)
+#define VF_XY                      (0x3<<1)
+#define VF_XYW                     (0x4<<1)
+
+
+#define VERT_X_MASK       (~0xf)
+#define VERT_X_EDGE_V2V0  (1<<2)
+#define VERT_X_EDGE_V1V2  (1<<1)
+#define VERT_X_EDGE_V0V1  (1<<0)
+
+/* Not enabled fields should not be sent to hardware:
+ */
+typedef struct {
+   union {
+      float x;
+      unsigned int edge_flags;
+   } x;
+   float y;
+   float z;
+   float z_bias;
+   float oow;
+   unsigned int argb;
+   unsigned int fog_spec_rgb;	/* spec g and r ignored. */
+   float tu0;
+   float tv0;
+   float tu1;
+   float tv1;
+} i810_full_vertex;
+      
+
+/* GFX_PRIMITIVE, p106
+ */
+#define GFX_OP_PRIMITIVE     ((0x3<<29)|(0x1f<<24))
+#define PR_TRIANGLES         (0x0<<18)
+#define PR_TRISTRIP_0        (0x1<<18)
+#define PR_TRISTRIP_1        (0x2<<18)
+#define PR_TRIFAN            (0x3<<18)
+#define PR_POLYGON           (0x4<<18)
+#define PR_LINES             (0x5<<18)
+#define PR_LINESTRIP         (0x6<<18)
+#define PR_RECTS             (0x7<<18)
+#define PR_DWORD_COUNT_SHIFT 0
+
+/* GFXCMDPARSER_BATCH_BUFFER, p105
+ *
+ * Not clear whether start address must be shifted or not.  Not clear
+ * whether address is physical system memory, or subject to GTT
+ * translation.  Because the address appears to be 32 bits long,
+ * perhaps it refers to physical system memory...
+ */
+#define CMD_OP_BATCH_BUFFER  ((0x0<<29)|(0x30<<23)|0x1)
+#define BB1_START_ADDR_MASK   (~0x7)
+#define BB1_PROTECTED         (1<<0)
+#define BB1_UNPROTECTED       (0<<0)
+#define BB2_END_ADDR_MASK     (~0x7)
+
+/* Hardware seems to barf on buffers larger than this (in strange ways)...
+ */
+#define MAX_BATCH (512*1024)
+
+
+/* GFXCMDPARSER_Z_BUFFER_INFO, p98
+ *
+ * Base address is in GTT space, and must be 4K aligned
+ */
+#define CMD_OP_Z_BUFFER_INFO  ((0x0<<29)|(0x16<<23))
+#define ZB_BASE_ADDR_SHIFT     0
+#define ZB_BASE_ADDR_MASK     (~((1<<12)-1))
+#define ZB_PITCH_512B         (0x0<<0)
+#define ZB_PITCH_1K           (0x1<<0)
+#define ZB_PITCH_2K           (0x2<<0)
+#define ZB_PITCH_4K           (0x3<<0)
+
+/* GFXCMDPARSER_FRONT_BUFFER_INFO, p97
+ *
+ * Format:
+ *     0:  CMD_OP_FRONT_BUFFER_INFO | (pitch<<FB0_PITCH_SHIFT) | FB0_*
+ *     1:  FB1_*
+ */
+#define CMD_OP_FRONT_BUFFER_INFO ((0x0<<29)|(0x14<<23))
+#define FB0_PITCH_SHIFT           8
+#define FB0_FLIP_SYNC            (0<<6)
+#define FB0_FLIP_ASYNC           (1<<6)
+#define FB0_BASE_ADDR_SHIFT       0
+#define FB0_BASE_ADDR_MASK        0x03FFFFF8
+
+/* GFXCMDPARSER_DEST_BUFFER_INFO, p96
+ *
+ * Format:
+ */
+#define CMD_OP_DESTBUFFER_INFO ((0x0<<29)|(0x15<<23))
+#define DB1_BASE_ADDR_SHIFT       0
+#define DB1_BASE_ADDR_MASK        0x03FFF000
+#define DB1_PITCH_512B            (0x0<<0)
+#define DB1_PITCH_1K              (0x1<<0)
+#define DB1_PITCH_2K              (0x2<<0)
+#define DB1_PITCH_4K              (0x4<<0)
+
+
+/* GFXRENDERSTATE_DEST_BUFFER_VARIABLES, p152
+ *
+ * Format:
+ *     0:  GFX_OP_DESTBUFFER_VARS
+ *     1:  DEST_* 
+ */
+#define GFX_OP_DESTBUFFER_VARS   ((0x3<<29)|(0x1d<<24)|(0x85<<16)|0x0)
+#define DV_HORG_BIAS_MASK      (0xf<<20)
+#define DV_HORG_BIAS_OGL       (0x0<<20)
+#define DV_VORG_BIAS_MASK      (0xf<<16)
+#define DV_VORG_BIAS_OGL       (0x0<<16)
+#define DV_PF_MASK             (0x7<<8)
+#define DV_PF_INDEX            (0x0<<8)
+#define DV_PF_555           (0x1<<8)
+#define DV_PF_565           (0x2<<8)
+
+
+
+
+#define GFX_OP_ANTIALIAS         ((0x3<<29)|(0x6<<24))
+#define AA_UPDATE_EDGEFLAG       (1<<13)
+#define AA_ENABLE_EDGEFLAG       (1<<12)
+#define AA_UPDATE_POLYWIDTH      (1<<11)
+#define AA_POLYWIDTH_05          (1<<9)
+#define AA_POLYWIDTH_10          (2<<9)
+#define AA_POLYWIDTH_20          (3<<9)
+#define AA_POLYWIDTH_40          (4<<9)
+#define AA_UPDATE_LINEWIDTH      (1<<8)
+#define AA_LINEWIDTH_05          (1<<6)
+#define AA_LINEWIDTH_10          (2<<6)
+#define AA_LINEWIDTH_20          (3<<6)
+#define AA_LINEWIDTH_40          (4<<6)
+#define AA_UPDATE_BB_EXPANSION   (1<<5)
+#define AA_BB_EXPANSION_SHIFT    2
+#define AA_UPDATE_AA_ENABLE      (1<<1)
+#define AA_ENABLE                (1<<0)
+
+#define GFX_OP_STIPPLE           ((0x3<<29)|(0x1d<<24)|(0x83<<16))
+#define ST1_ENABLE               (1<<16)
+#define ST1_MASK                 (0xffff)
+
+
+/* Indices into buf.Setup where various bits of state are mirrored per
+ * context and per buffer.  These can be fired at the card as a unit,
+ * or in a piecewise fashion as required.
+ */
+
+/* Destbuffer state 
+ *    - backbuffer linear offset and pitch -- invarient in the current dri
+ *    - zbuffer linear offset and pitch -- also invarient
+ *    - drawing origin in back and depth buffers.
+ *
+ * Keep the depth/back buffer state here to acommodate private buffers
+ * in the future.
+ */
+#define I810_DESTREG_DI0  0	/* CMD_OP_DESTBUFFER_INFO (2 dwords) */
+#define I810_DESTREG_DI1  1
+#define I810_DESTREG_ZB0  2	/* CMD_OP_Z_BUFFER_INFO */
+#define I810_DESTREG_ZB1  3	/* CMD_OP_Z_BUFFER_INFO */
+#define I810_DESTREG_DV0  4	/* GFX_OP_DESTBUFFER_VARS (2 dwords) */
+#define I810_DESTREG_DV1  5
+#define I810_DESTREG_DR0  6	/* GFX_OP_DRAWRECT_INFO (4 dwords) */
+#define I810_DESTREG_DR1  7
+#define I810_DESTREG_DR2  8
+#define I810_DESTREG_DR3  9
+#define I810_DESTREG_DR4  10
+
+#define I810_DEST_SETUP_SIZE (11+1)
+
+/* Context state
+ */
+#define I810_CTXREG_VF    0	/* GFX_OP_VERTEX_FMT */
+#define I810_CTXREG_MT    1	/* GFX_OP_MAP_TEXELS */
+#define I810_CTXREG_MC0   2	/* GFX_OP_MAP_COLOR_STAGES - stage 0 */
+#define I810_CTXREG_MC1   3	/* GFX_OP_MAP_COLOR_STAGES - stage 1 */
+#define I810_CTXREG_MC2   4	/* GFX_OP_MAP_COLOR_STAGES - stage 2 */
+#define I810_CTXREG_MA0   5	/* GFX_OP_MAP_ALPHA_STAGES - stage 0 */
+#define I810_CTXREG_MA1   6	/* GFX_OP_MAP_ALPHA_STAGES - stage 1 */
+#define I810_CTXREG_MA2   7	/* GFX_OP_MAP_ALPHA_STAGES - stage 2 */
+#define I810_CTXREG_SDM   8	/* GFX_OP_SRC_DEST_MONO */
+#define I810_CTXREG_CF0   9	/* GFX_OP_COLOR_FACTOR */
+#define I810_CTXREG_CF1   10	
+#define I810_CTXREG_FOG   11	/* GFX_OP_FOG_COLOR */
+#define I810_CTXREG_B1    12	/* GFX_OP_BOOL_1 */
+#define I810_CTXREG_B2    13	/* GFX_OP_BOOL_2 */
+#define I810_CTXREG_LCS   14	/* GFX_OP_LINEWIDTH_CULL_SHADE_MODE */
+#define I810_CTXREG_PV    15	/* GFX_OP_PV_RULE -- Invarient! */
+#define I810_CTXREG_ZA    16	/* GFX_OP_ZBIAS_ALPHAFUNC */
+#define I810_CTXREG_ST0   17    /* GFX_OP_STIPPLE */
+#define I810_CTXREG_ST1   18
+#define I810_CTXREG_AA    19	/* GFX_OP_ANTIALIAS */
+#define I810_CTX_SETUP_SIZE (20) /* pad to qword */
+
+
+/* Cliprect state - keep seperate from context as it is used for
+ *                  drawing triangles to the shared backbuffer, and
+ *                  changes more frequently than the 'normal' context.
+ */
+#define I810_CLIPREG_SCI0  0 	/* GFX_OP_SCISSOR_INFO (3 dwords) */
+#define I810_CLIPREG_SCI1  1	
+#define I810_CLIPREG_SCI2  2	
+#define I810_CLIPREG_SC    3	/* GFX_OP_SCISSOR */
+
+#define I810_CLIP_SETUP_SIZE 4
+
+/* Texture state (per tex_buffer)
+ */
+#define I810_TEXREG_MI0  0	/* GFX_OP_MAP_INFO (4 dwords) */
+#define I810_TEXREG_MI1  1	
+#define I810_TEXREG_MI2  2	
+#define I810_TEXREG_MI3  3	
+#define I810_TEXREG_MF   4	/* GFX_OP_MAP_FILTER */
+#define I810_TEXREG_MLC  5	/* GFX_OP_MAP_LOD_CTL */
+#define I810_TEXREG_MLL  6	/* GFX_OP_MAP_LOD_LIMITS */
+#define I810_TEXREG_MCS  7	/* GFX_OP_MAP_COORD_SETS ??? */
+
+#define I810_TEX_SETUP_SIZE 8
+
+
+#define I810_SET_FIELD( var, mask, value ) (var &= ~(mask), var |= value)
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_init.h b/xc/lib/GL/mesa/src/drv/i810/i810_init.h
new file mode 100644
index 000000000..f676a204f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810_init.h
@@ -0,0 +1,135 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Keith Whitwell <keithw@precisioninsight.com>
+ *   Daryll Strauss <daryll@precisioninsight.com> (Origninal tdfx driver).
+ *
+ * $PI: $
+ */
+
+#ifndef _I810_INIT_H_
+#define _I810_INIT_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <sys/time.h>
+#include "dri_tmm.h"
+#include "dri_mesaint.h"
+#include "dri_mesa.h"
+#include "types.h"
+#include "xmesaP.h"
+
+typedef struct {
+  drmHandle handle;
+  drmSize size;
+  drmAddress map;
+} i810Region, *i810RegionPtr;
+
+typedef struct {
+   i810Region regs;
+
+   int deviceID;
+   int width;
+   int height;
+   int mem;
+
+   int cpp;			/* for front and back buffers */
+   int bitsPerPixel;
+
+   int fbFormat;
+   int fbOffset;
+   int fbStride;
+
+   int backOffset;
+   int depthOffset;
+
+   int auxPitch;
+   int auxPitchBits;
+
+   int textureOffset;
+   int textureSize;
+   int logTextureGranularity;
+
+   __DRIscreenPrivate *driScrnPriv;
+
+} i810ScreenPrivate;
+
+
+#include "i810context.h"
+
+extern void i810XMesaUpdateState( i810ContextPtr imesa );
+extern void i810EmitHwStateLocked( i810ContextPtr imesa );
+extern void i810EmitScissorValues( i810ContextPtr imesa, int box_nr, int emit );
+extern void i810EmitDrawingRectangle( i810ContextPtr imesa );
+extern void i810XMesaSetBackClipRects( i810ContextPtr imesa );
+extern void i810XMesaSetFrontClipRects( i810ContextPtr imesa );
+
+
+/* Lock the hardware and validate our state.  
+ */
+#define LOCK_HARDWARE( imesa )				\
+  do {							\
+    char __ret=0;					\
+    DRM_CAS(imesa->driHwLock, imesa->hHWContext,	\
+	    (DRM_LOCK_HELD|imesa->hHWContext), __ret);	\
+    if (__ret) {					\
+        drmGetLock(imesa->driFd, imesa->hHWContext, 0);	\
+        i810XMesaUpdateState( imesa );			\
+    }							\
+  } while (0)
+
+
+/* Unlock the hardware using the global current context 
+ */
+#define UNLOCK_HARDWARE(imesa)					\
+    DRM_UNLOCK(imesa->driFd, imesa->driHwLock, imesa->hHWContext);	
+
+
+/*
+  This pair of macros makes a loop over the drawing operations
+  so it is not self contained and doesn't have the nice single 
+  statement semantics of most macros
+*/
+#define BEGIN_CLIP_LOOP(imesa)						\
+  do {									\
+    int _nc;								\
+    LOCK_HARDWARE( imesa );						\
+    for (_nc = imesa->numClipRects; _nc ; _nc--) {			\
+      if (imesa->needClip)						\
+        i810EmitScissorValues(imesa, _nc-1, 1);
+
+
+
+#define END_CLIP_LOOP(imesa)			\
+    }						\
+    UNLOCK_HARDWARE(imesa);			\
+  } while (0)
+
+#endif
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c b/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c
new file mode 100644
index 000000000..cdac028b5
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c
@@ -0,0 +1,611 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Keith Whitwell <keithw@precisioninsight.com>
+ *
+ * $PI: $
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <X11/Xlibint.h>
+#include <stdio.h>
+
+#include "i810_init.h"
+#include "context.h"
+#include "vbxform.h"
+#include "matrix.h"
+#include "simple_list.h"
+
+#include "i810dd.h"
+#include "i810state.h"
+#include "i810tex.h"
+#include "i810span.h"
+#include "i810depth.h"
+#include "i810tris.h"
+#include "i810swap.h"
+#include "i810pipeline.h"
+
+#include "i810_dri.h"
+
+
+
+#ifndef I810_DEBUG
+int I810_DEBUG = (0
+   		  | DEBUG_ALWAYS_SYNC 
+		  | DEBUG_VERBOSE_RING   
+		  | DEBUG_VERBOSE_OUTREG 
+/*  		  | DEBUG_VERBOSE_MSG */
+/*  		  | DEBUG_NO_OUTRING */
+/*  		  | DEBUG_NO_OUTREG */
+/*  		  | DEBUG_VERBOSE_API */
+/*  		  | DEBUG_VERBOSE_2D */
+/*  		  | DEBUG_VERBOSE_DRI */
+		  | DEBUG_VALIDATE_RING
+		  );
+#endif
+
+
+static i810ContextPtr      i810Ctx = 0;
+
+i810Glx_t	i810glx;
+
+static int count_bits(unsigned int n)
+{
+   int bits = 0;
+
+   while (n > 0) {
+      if (n & 1) bits++;
+      n >>= 1;
+   }
+   return bits;
+}
+
+/* These functions are accessed by dlsym from dri_mesa_init.c:
+ *
+ * XMesaInitDriver
+ * XMesaResetDriver
+ * XMesaCreateVisual
+ * XMesaDestroyVisual
+ * XMesaCreateContext 
+ * XMesaDestroyContext
+ * XMesaCreateWindowBuffer
+ * XMesaCreatePixmapBuffer
+ * XMesaDestroyBuffer
+ * XMesaSwapBuffers
+ * XMesaMakeCurrent
+ *
+ * So this is kind of the public interface to the driver.  The driver
+ * uses the X11 mesa driver context as a kind of wrapper around its
+ * own driver context - but there isn't much justificiation for doing
+ * it that way - the DRI might as well use a (void *) to refer to the
+ * driver contexts.  Nothing in the X context really gets used.
+ */
+
+
+GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv)
+{
+   i810ScreenPrivate *i810Screen;
+   I810DRIPtr         gDRIPriv = (I810DRIPtr)sPriv->pDevPriv;
+
+   /* Allocate the private area */
+   i810Screen = (i810ScreenPrivate *)Xmalloc(sizeof(i810ScreenPrivate));
+   if (!i810Screen) return GL_FALSE;
+
+   i810Screen->driScrnPriv = sPriv;
+   sPriv->private = (void *)i810Screen;
+
+   i810Screen->regs.handle=gDRIPriv->regs;
+   i810Screen->regs.size=gDRIPriv->regsSize;
+   i810Screen->deviceID=gDRIPriv->deviceID;
+   i810Screen->width=gDRIPriv->width;
+   i810Screen->height=gDRIPriv->height;
+   i810Screen->mem=gDRIPriv->mem;
+   i810Screen->cpp=gDRIPriv->cpp;
+   i810Screen->fbStride=gDRIPriv->fbStride;
+   i810Screen->fbOffset=gDRIPriv->fbOffset;
+
+   if (gDRIPriv->bitsPerPixel == 15) 
+      i810Screen->fbFormat = DV_PF_555;
+   else
+      i810Screen->fbFormat = DV_PF_565;
+
+   i810Screen->backOffset=gDRIPriv->backOffset; 
+   i810Screen->depthOffset=gDRIPriv->depthOffset;
+   i810Screen->auxPitch = gDRIPriv->auxPitch;
+   i810Screen->auxPitchBits = gDRIPriv->auxPitchBits;
+   i810Screen->textureOffset=gDRIPriv->textureOffset;
+   i810Screen->textureSize=gDRIPriv->textureSize;
+   i810Screen->logTextureGranularity = gDRIPriv->logTextureGranularity;
+
+
+   if (0)
+      fprintf(stderr, "Tex heap size %x, granularity %x bytes\n",
+	      i810Screen->textureSize, 1<<(i810Screen->logTextureGranularity));
+    
+   if (drmMap(sPriv->fd, 
+	      i810Screen->regs.handle, 
+	      i810Screen->regs.size, 
+	      &i810Screen->regs.map) != 0) 
+   {
+      Xfree(i810Screen);
+      return GL_FALSE;
+   }
+
+   /* Ditch i810glx in favor of i810Screen?
+    */
+   memset(&i810glx, 0, sizeof(i810glx));
+
+   i810glx.LpRing.mem.Start = gDRIPriv->ringOffset;
+   i810glx.LpRing.mem.Size = gDRIPriv->ringSize;
+   i810glx.LpRing.mem.End = gDRIPriv->ringOffset + gDRIPriv->ringSize;
+   i810glx.LpRing.virtual_start = sPriv->pFB + i810glx.LpRing.mem.Start;
+   i810glx.LpRing.tail_mask = i810glx.LpRing.mem.Size - 1;
+   i810glx.MMIOBase = i810Screen->regs.map;
+   i810glx.texVirtual = sPriv->pFB + i810Screen->textureOffset;
+
+   
+   i810DDFastPathInit();
+   i810DDTrifuncInit();
+   i810DDSetupInit();
+
+   return GL_TRUE;
+}
+
+/* Accessed by dlsym from dri_mesa_init.c
+ */
+void XMesaResetDriver(__DRIscreenPrivate *sPriv)
+{
+   i810ScreenPrivate *i810Screen = (i810ScreenPrivate *)sPriv->private;
+
+   drmUnmap(i810Screen->regs.map, i810Screen->regs.size);
+   Xfree(i810Screen);
+}
+
+/* Accessed by dlsym from dri_mesa_init.c
+ */
+XMesaVisual XMesaCreateVisual(XMesaDisplay *display,
+			      XMesaVisualInfo visinfo,
+			      GLboolean rgb_flag,
+			      GLboolean alpha_flag,
+			      GLboolean db_flag,
+			      GLboolean stereo_flag,
+			      GLboolean ximage_flag,
+			      GLint depth_size,
+			      GLint stencil_size,
+			      GLint accum_size,
+			      GLint level)
+{
+   XMesaVisual v;
+
+   /* Only RGB visuals are supported on the I810 boards */
+   if (!rgb_flag) return 0;
+
+   v = (XMesaVisual)Xmalloc(sizeof(struct xmesa_visual));
+   if (!v) return 0;
+
+   v->visinfo = (XVisualInfo *)Xmalloc(sizeof(*visinfo));
+   if(!v->visinfo) {
+      Xfree(v);
+      return 0;
+   }
+   memcpy(v->visinfo, visinfo, sizeof(*visinfo));
+
+   v->display = display;
+   v->level = level;
+  
+   v->gl_visual = (GLvisual *)Xmalloc(sizeof(GLvisual));
+   if (!v->gl_visual) {
+      Xfree(v->visinfo);
+      XFree(v);
+      return 0;
+   }
+
+   v->gl_visual->RGBAflag   = rgb_flag;
+   v->gl_visual->DBflag     = db_flag;
+   v->gl_visual->StereoFlag = stereo_flag;
+
+   v->gl_visual->RedBits   = count_bits(visinfo->red_mask);
+   v->gl_visual->GreenBits = count_bits(visinfo->green_mask);
+   v->gl_visual->BlueBits  = count_bits(visinfo->blue_mask);
+   v->gl_visual->AlphaBits = 0; /* Not currently supported */
+
+   v->gl_visual->AccumBits   = accum_size;
+   v->gl_visual->DepthBits   = depth_size;
+   v->gl_visual->StencilBits = stencil_size;
+
+   return v;
+}
+
+void XMesaDestroyVisual(XMesaVisual v)
+{
+   Xfree(v->gl_visual);
+   Xfree(v->visinfo);
+   Xfree(v);
+}
+
+XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list,
+				__DRIcontextPrivate *driContextPriv)
+{
+   GLcontext *ctx;
+   XMesaContext c;
+   i810ContextPtr imesa;
+   __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
+   i810ScreenPrivate *i810Screen = (i810ScreenPrivate *)sPriv->private;
+   I810SAREAPriv *saPriv=(I810SAREAPriv*)(((char*)sPriv->pSAREA)+
+					  sizeof(XF86DRISAREARec));
+
+   GLcontext *shareCtx = 0;
+
+   c = (XMesaContext)Xmalloc(sizeof(struct xmesa_context));
+   if (!c) {
+      return 0;
+   }
+
+   imesa = (i810ContextPtr)Xmalloc(sizeof(i810Context));
+   if (!imesa) {
+      Xfree(c);
+      return 0;
+   }
+
+   c->driContextPriv = driContextPriv;
+   c->xm_visual = v;
+   c->xm_buffer = 0; /* Set by MakeCurrent */
+   c->display = v->display;
+   c->private = (void *)imesa;
+
+   if (share_list)
+      shareCtx=((i810ContextPtr)(share_list->private))->glCtx;
+
+   ctx = imesa->glCtx = gl_create_context(v->gl_visual, shareCtx, 
+					  (void*)imesa, GL_TRUE);
+
+   /* Dri stuff
+    */
+   imesa->display = v->display;
+   imesa->hHWContext = driContextPriv->hHWContext;
+   imesa->driFd = sPriv->fd;
+   imesa->driHwLock = &sPriv->pSAREA->lock;
+
+   imesa->i810Screen = i810Screen;
+   imesa->driScreen = sPriv;
+   imesa->sarea = saPriv;
+
+   imesa->glBuffer = gl_create_framebuffer(v->gl_visual);
+
+   imesa->needClip=1;
+
+   imesa->texHeap = mmInit( 0, i810Screen->textureSize );
+
+
+   /* Utah stuff
+    */
+   imesa->renderindex = -1;		/* impossible value */
+   imesa->new_state = ~0;
+   imesa->dirty = ~0;
+
+   make_empty_list(&imesa->TexObjList);
+   make_empty_list(&imesa->SwappedOut);
+   
+   imesa->TextureMode = ctx->Texture.Unit[0].EnvMode;
+   imesa->CurrentTexObj[0] = 0;
+   imesa->CurrentTexObj[1] = 0;
+   
+   i810DDExtensionsInit( ctx );
+
+   i810DDInitStateFuncs( ctx );
+   i810DDInitTextureFuncs( ctx );
+   i810DDInitSpanFuncs( ctx );
+   i810DDInitDepthFuncs( ctx );
+   i810DDInitDriverFuncs( ctx );
+
+   ctx->Driver.TriangleCaps = (DD_TRI_CULL|
+			       DD_TRI_LIGHT_TWOSIDE|
+			       DD_TRI_OFFSET);
+
+   /* Ask mesa to clip fog coordinates for us.
+    */
+   ctx->TriangleCaps |= DD_CLIP_FOG_COORD;
+
+   ctx->Shared->DefaultD[2][0].DriverData = 0;
+   ctx->Shared->DefaultD[2][1].DriverData = 0;
+
+   if (ctx->VB) 
+      i810DDRegisterVB( ctx->VB );
+
+   if (ctx->NrPipelineStages)
+      ctx->NrPipelineStages =
+	 i810DDRegisterPipelineStages(ctx->PipelineStage,
+				      ctx->PipelineStage,
+				      ctx->NrPipelineStages);
+
+   i810DDInitState( imesa );
+
+   return c;
+}
+
+void XMesaDestroyContext(XMesaContext c)
+{
+   i810ContextPtr imesa = (i810ContextPtr) c->private;
+
+   if (imesa) {
+      i810TextureObjectPtr next_t, t;
+
+      gl_destroy_context(imesa->glCtx);
+      gl_destroy_framebuffer(imesa->glBuffer);
+
+      foreach_s (t, next_t, &(imesa->TexObjList))
+	 i810DestroyTexObj(imesa, t);
+
+      foreach_s (t, next_t, &(imesa->SwappedOut))
+	 i810DestroyTexObj(imesa, t);
+
+      Xfree(imesa);
+
+      c->private = 0;
+   }
+}
+
+XMesaBuffer XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w,
+				    __DRIdrawablePrivate *driDrawPriv)
+{
+  return (XMesaBuffer)1;
+}
+
+XMesaBuffer XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p,
+				    XMesaColormap c, 
+				    __DRIdrawablePrivate *driDrawPriv)
+{
+  return (XMesaBuffer)1;
+}
+
+void XMesaDestroyBuffer(XMesaBuffer b)
+{
+}
+
+void XMesaSwapBuffers(XMesaBuffer bogus)
+{
+   i810ContextPtr imesa = i810Ctx; 
+
+   FLUSH_VB( imesa->glCtx, "swap buffers" );
+   i810SwapBuffers(imesa);
+}
+
+static void i810InitClipRects( i810ContextPtr imesa )
+{
+   switch (imesa->numClipRects) {
+   case 0:
+      imesa->ClipSetup[I810_CLIPREG_SC] = ( GFX_OP_SCISSOR |
+					    SC_UPDATE_SCISSOR );
+      imesa->ClipSetup[I810_CLIPREG_SCI1] = 0;
+      imesa->ClipSetup[I810_CLIPREG_SCI2] = 0;
+      imesa->needClip = 0;
+      imesa->dirty |= I810_EMIT_CLIPRECT;
+      break;
+   case 1:
+      imesa->needClip = 0;
+      i810EmitScissorValues( imesa, 0, 0 );
+      imesa->dirty |= I810_EMIT_CLIPRECT;
+      break;
+   default:
+      imesa->needClip=1;
+      break;
+   }
+}
+
+
+
+void i810XMesaSetFrontClipRects( i810ContextPtr imesa )
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+
+   imesa->numClipRects = dPriv->numClipRects;
+   imesa->pClipRects = dPriv->pClipRects;
+   imesa->drawX = dPriv->x;
+   imesa->drawY = dPriv->y;
+
+   imesa->drawOffset = imesa->i810Screen->fbOffset;
+   i810EmitDrawingRectangle( imesa );
+   i810InitClipRects( imesa );
+}
+
+
+void i810XMesaSetBackClipRects( i810ContextPtr imesa )
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   int i;
+
+   if (dPriv->numAuxClipRects == 0) 
+   {
+      if (I810_DEBUG & DEBUG_VERBOSE_DRI)
+	 fprintf(stderr, "FRONT_CLIPRECTS, %d rects\n", 
+		 dPriv->numClipRects);
+
+      imesa->numClipRects = dPriv->numClipRects;
+      imesa->pClipRects = dPriv->pClipRects;
+      imesa->drawX = dPriv->x;
+      imesa->drawY = dPriv->y;
+   } else {
+      if (I810_DEBUG & DEBUG_VERBOSE_DRI)
+	 fprintf(stderr, "AUX_RECTS, %d rects\n", 
+		 dPriv->numAuxClipRects);
+
+      imesa->numClipRects = dPriv->numAuxClipRects;
+      imesa->pClipRects = dPriv->pAuxClipRects;
+      imesa->drawX = dPriv->auxX;
+      imesa->drawY = dPriv->auxY;
+   }
+
+   imesa->drawOffset = imesa->i810Screen->backOffset;
+   i810EmitDrawingRectangle( imesa );
+   i810InitClipRects( imesa );
+
+   if (I810_DEBUG & DEBUG_VERBOSE_DRI)
+      for (i = 0 ; i < imesa->numClipRects ; i++) 
+	 fprintf(stderr, "cliprect %d: %d,%d - %d,%d\n",
+		 i,
+		 imesa->pClipRects[i].x1,
+		 imesa->pClipRects[i].y1,
+		 imesa->pClipRects[i].x2,
+		 imesa->pClipRects[i].y2);
+}
+
+
+static void i810XMesaWindowMoved( i810ContextPtr imesa ) 
+{
+   switch (imesa->glCtx->Color.DriverDrawBuffer) {
+   case GL_FRONT_LEFT:
+      i810XMesaSetFrontClipRects( imesa );
+      break;
+   case GL_BACK_LEFT:
+      i810XMesaSetBackClipRects( imesa );
+      break;
+   default:
+      fprintf(stderr, "fallback buffer\n");
+      break;
+   }
+
+}
+
+
+/* This looks buggy to me - the 'b' variable isn't used anywhere...
+ * Hmm - It seems that the drawable is already hooked in to
+ * driDrawablePriv.  
+ */
+GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b)
+{
+
+   if (c->private==(void *)i810Ctx) return GL_TRUE;
+
+   if (c) {
+      __DRIdrawablePrivate *dPriv = c->driContextPriv->driDrawablePriv;
+
+      i810Ctx = (i810ContextPtr)c->private;
+
+      gl_make_current(i810Ctx->glCtx, i810Ctx->glBuffer);
+
+      i810Ctx->driDrawable = dPriv;
+      i810Ctx->dirty = ~0;
+   
+      i810XMesaWindowMoved( i810Ctx );
+
+      if (!i810Ctx->glCtx->Viewport.Width)
+	 gl_Viewport(i810Ctx->glCtx, 0, 0, dPriv->w, dPriv->h);
+
+   } else {
+      gl_make_current(0,0);
+      i810Ctx = NULL;
+   }
+   return GL_TRUE;
+}
+
+
+void i810XMesaUpdateState( i810ContextPtr imesa ) 
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   __DRIscreenPrivate *sPriv = imesa->driScreen;
+   I810SAREAPriv *sarea = imesa->sarea;
+   int me = imesa->hHWContext;
+   int stamp = dPriv->lastStamp; 
+
+
+   /* If the window moved, may need to set a new cliprect now.
+    *
+    * NOTE: This releases and regains the hw lock, so all state
+    * checking must be done *after* this call:
+    */
+   XMESA_VALIDATE_DRAWABLE_INFO(imesa->display, sPriv, dPriv);		
+
+   i810glx.LpRing.synced = 0;
+
+   /* If another client has touched the ringbuffer, need to update 
+    * where we think the pointers are:
+    */
+   if (sarea->ringOwner != me) {
+      i810glx.c_ringlost++;
+      imesa->dirty |= I810_REFRESH_RING;
+   }
+      
+   /* If we lost context, need to dump all registers to hardware.
+    * Note that we don't care about 2d contexts, even if they perform
+    * accelerated commands, so the DRI locking in the X server is even
+    * more broken than usual.
+    */
+   if (sarea->ctxOwner != me) {
+      i810glx.c_ctxlost++;
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->dirty |= I810_EMIT_CLIPRECT;
+      imesa->dirty |= I810_UPLOAD_BUFFERS;
+   }
+
+   /* Shared texture managment - if another client has played with
+    * texture space, figure out which if any of our textures have been
+    * ejected, and update our global LRU.
+    */
+   if (sarea->texAge != imesa->texAge) {
+      int sz = 1 << (imesa->i810Screen->logTextureGranularity);
+      int idx, nr = 0;
+
+      /* Have to go right round from the back to ensure stuff ends up
+       * LRU in our local list...
+       */
+      for (idx = sarea->texList[I810_NR_TEX_REGIONS].prev ; 
+	   idx != I810_NR_TEX_REGIONS && nr < I810_NR_TEX_REGIONS ; 
+	   idx = sarea->texList[idx].prev, nr++)
+      {
+	 if (sarea->texList[idx].age > imesa->texAge)
+	    i810TexturesGone(imesa, idx * sz, sz, sarea->texList[idx].in_use);
+      }
+
+      if (nr == I810_NR_TEX_REGIONS) {
+	 i810TexturesGone(imesa, 0, imesa->i810Screen->textureSize, 0);
+	 i810ResetGlobalLRU( imesa );
+      }
+
+      imesa->texAge = sarea->texAge;
+      imesa->dirty |= I810_UPLOAD_TEX0IMAGE | I810_UPLOAD_TEX1IMAGE;
+   }
+
+   
+   if (dPriv->lastStamp != stamp)
+      i810XMesaWindowMoved( imesa );
+
+   sarea->ctxOwner=me;
+   sarea->ringOwner=me;
+
+
+   _I810RefreshLpRing(imesa, 0);  
+
+   if (imesa->dirty) 
+       i810EmitHwStateLocked( imesa );  
+
+}
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810clear.c b/xc/lib/GL/mesa/src/drv/i810/i810clear.c
new file mode 100644
index 000000000..5ba264059
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810clear.c
@@ -0,0 +1,193 @@
+
+
+#include "types.h"
+#include "vbrender.h"
+#include "i810log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810dd.h"
+#include "i810clear.h"
+#include "i810state.h"
+#include "i810tris.h"
+
+
+
+/* Clear the depthbuffer.  Always uses the auxillary cliprects and
+ * origin from 'dPriv'.
+ */
+static void i810_clear_depthbuffer( GLcontext *ctx, 
+				    GLboolean all,
+				    GLint cx, GLint cy, 
+				    GLint cwidth, GLint cheight ) 
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLuint zval = (GLuint) (ctx->Depth.Clear * DEPTH_SCALE);
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+
+/*     int _nc = dPriv->numAuxClipRects; */
+/*     XF86DRIClipRectPtr box = dPriv->pAuxClipRects; */
+
+   int _nc = imesa->numClipRects;
+   XF86DRIClipRectPtr box = imesa->pClipRects;
+
+   cy = dPriv->h-cy-cheight;
+   cx += dPriv->auxX;
+   cy += dPriv->auxY;
+         
+   while (_nc--) {	 
+      GLint x = box[_nc].x1;
+      GLint y = box[_nc].y1;
+      GLint width = box[_nc].x2 - x;
+      GLint height = box[_nc].y2 - y;
+
+      if (!all) {
+	 if (x < cx) width -= cx - x, x = cx; 
+	 if (y < cy) height -= cy - y, y = cy;
+	 if (x + width > cx + cwidth) width = cx + cwidth - x;
+	 if (y + height > cy + cheight) height = cy + cheight - y;
+	 if (width <= 0) continue;
+	 if (height <= 0) continue;
+      }
+
+      if (I810_DEBUG&DEBUG_VERBOSE_2D)
+	 fprintf(stderr, "clear depth rect %d,%d %dx%d\n", 
+		 (int) x, (int) y, (int) width, (int) height);
+
+      {
+	 int start = (i810Screen->depthOffset + 
+		      y * i810Screen->auxPitch + 
+		      x * 2);
+	    
+	 BEGIN_BATCH(imesa, 6);
+   
+	 OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 );
+	 OUT_BATCH( BR13_SOLID_PATTERN | 
+		    (0xF0 << 16) |
+		    i810Screen->auxPitch );
+	 OUT_BATCH( (height << 16) | (width * 2));
+	 OUT_BATCH( start );
+	 OUT_BATCH( zval );
+	 OUT_BATCH( 0 );
+
+	 ADVANCE_BATCH();   
+      }
+   }
+}
+
+
+/* Clear the current drawbuffer.  Checks 'imesa' to determine which set of
+ * cliprects and origin to use.
+ */
+static void i810_clear_colorbuffer( GLcontext *ctx, 
+				    GLboolean all,
+				    GLint cx, GLint cy, 
+				    GLint cwidth, GLint cheight ) 
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLushort c = imesa->ClearColor;
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+
+   int _nc = imesa->numClipRects;
+   XF86DRIClipRectPtr box = imesa->pClipRects;
+
+   cy = dPriv->h-cy-cheight;
+   cx += imesa->drawX;
+   cy += imesa->drawY;
+         
+   while (_nc--) {	 
+      GLint x = box[_nc].x1;
+      GLint y = box[_nc].y1;
+      GLint width = box[_nc].x2 - x;
+      GLint height = box[_nc].y2 - y;
+
+      if (!all) {
+	 if (x < cx) width -= cx - x, x = cx; 
+	 if (y < cy) height -= cy - y, y = cy;
+	 if (x + width > cx + cwidth) width = cx + cwidth - x;
+	 if (y + height > cy + cheight) height = cy + cheight - y;
+	 if (width <= 0) continue;
+	 if (height <= 0) continue;
+      }
+
+      if (I810_DEBUG&DEBUG_VERBOSE_2D)
+	 fprintf(stderr, "clear color rect %d,%d %dx%d\n", 
+		 (int) x, (int) y, (int) width, (int) height);
+
+
+      {
+	 int start = (imesa->drawOffset +  
+		      y * i810Screen->auxPitch + 
+		      x * i810Screen->cpp);
+	    
+	 BEGIN_BATCH( imesa, 6 );
+	    
+	 OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 );
+	 OUT_BATCH( BR13_SOLID_PATTERN | 
+		    (0xF0 << 16) |
+		    i810Screen->auxPitch );
+	 OUT_BATCH( (height << 16) | (width * i810Screen->cpp));
+	 OUT_BATCH( start );
+	 OUT_BATCH( c );
+	 OUT_BATCH( 0 );
+
+	 ADVANCE_BATCH();
+      }
+   }
+}
+
+
+
+
+/*
+ * i810Clear
+ *
+ * Clear the color and/or depth buffers.  If 'all' is GL_TRUE, clear
+ * whole buffer, otherwise clear the region defined by the remaining
+ * parameters.  
+ */
+GLbitfield i810Clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+		      GLint cx, GLint cy, GLint cwidth, GLint cheight ) 
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+
+   if (I810_DEBUG&DEBUG_VERBOSE_API)
+      fprintf(stderr, "i810Clear( %d, %d, %d, %d, %d )\n",
+	      (int)mask, (int)cx, (int)cy, (int)cwidth, (int)cheight );
+	
+   LOCK_HARDWARE(imesa);
+
+   {
+      BEGIN_BATCH( imesa, 2 );   
+      OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH );
+      OUT_BATCH( 0 );
+      ADVANCE_BATCH();      
+   }
+
+   if (mask & GL_COLOR_BUFFER_BIT) {
+      i810_clear_colorbuffer( ctx, all, cx, cy, cwidth, cheight );
+      mask &= ~GL_COLOR_BUFFER_BIT;
+   }
+
+   if ( (mask & GL_DEPTH_BUFFER_BIT) && ctx->Depth.Mask ) {
+      i810_clear_depthbuffer( ctx, all, cx, cy, cwidth, cheight );
+      mask &= ~GL_DEPTH_BUFFER_BIT;
+   }      
+
+   {
+      BEGIN_BATCH( imesa, 2 );   
+      OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH );
+      OUT_BATCH( 0 );
+      ADVANCE_BATCH();      
+   }
+
+   UNLOCK_HARDWARE( imesa );
+   return mask;
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810clear.h b/xc/lib/GL/mesa/src/drv/i810/i810clear.h
new file mode 100644
index 000000000..aedbf84d9
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810clear.h
@@ -0,0 +1,7 @@
+#ifndef _I810_CLEAR_H
+#define _I810_CLEAR_H
+
+extern GLbitfield i810Clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+			    GLint x, GLint y, GLint width, GLint height );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810context.h b/xc/lib/GL/mesa/src/drv/i810/i810context.h
new file mode 100644
index 000000000..9f316f6fd
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810context.h
@@ -0,0 +1,190 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810CONTEXT_INC
+#define I810CONTEXT_INC
+
+typedef struct i810_context_t i810Context;
+typedef struct i810_context_t *i810ContextPtr;
+
+#include <X11/Xlibint.h>
+#include "dri_tmm.h"
+#include "dri_mesaint.h"
+#include "dri_mesa.h"
+#include "xmesaP.h"
+
+#include "types.h"
+#include "i810_init.h"
+#include "i810_sarea.h"
+
+#include "i810tex.h"
+#include "i810vb.h"
+
+
+
+#define I810_FALLBACK_TEXTURE   0x1
+#define I810_FALLBACK_BUFFER    0x2
+
+
+
+/* for i810ctx.new_state - manage GL->driver state changes
+ */
+#define I810_NEW_TEXTURE 0x1
+
+/* for i810ctx.dirty - manage driver->hw state changes, including
+ * lost contexts.
+ */
+#define I810_REQUIRE_QUIESCENT 0x1
+#define I810_UPLOAD_TEX0IMAGE  0x2
+#define I810_UPLOAD_TEX1IMAGE  0x4
+#define I810_UPLOAD_CTX        0x8
+#define I810_UPLOAD_BUFFERS    0x10
+#define I810_REFRESH_RING      0x20
+#define I810_EMIT_CLIPRECT     0x40
+
+
+typedef void (*i810_interp_func)( GLfloat t, 
+				  GLfloat *result,
+				  const GLfloat *in,
+				  const GLfloat *out );
+				 
+
+
+struct i810_context_t {
+   GLint refcount;
+
+   GLcontext *glCtx;
+
+   i810TextureObjectPtr CurrentTexObj[2];
+
+   struct i810_texture_object_t TexObjList;
+   struct i810_texture_object_t SwappedOut; 
+
+   int TextureMode;
+
+   /* Hardware state
+    */
+   GLuint Setup[I810_CTX_SETUP_SIZE];
+   GLuint BufferSetup[I810_DEST_SETUP_SIZE];
+   GLuint ClipSetup[I810_CLIP_SETUP_SIZE];
+   
+
+   /* Support for CVA and the fast paths.
+    */
+   GLuint setupdone;
+   GLuint setupindex;
+   GLuint renderindex;
+   GLuint using_fast_path;
+   i810_interp_func interp;
+
+   /* Shortcircuit some state changes.
+    */
+   points_func PointsFunc;
+   line_func LineFunc;
+   triangle_func TriangleFunc;
+   quad_func QuadFunc;
+
+   /* Manage our own state */
+   GLuint new_state; 
+
+   /* Manage hardware state */
+   GLuint dirty;
+   memHeap_t *texHeap;
+
+   /* One of the few bits of hardware state that can't be calculated
+    * completely on the fly:
+    */
+   GLuint LcsCullMode;
+
+   /* Funny mesa mirrors
+    */
+   GLushort MonoColor;
+   GLushort ClearColor;
+
+   /* DRI stuff
+    */
+   GLframebuffer *glBuffer;
+   
+   GLuint Fallback;
+   GLuint needClip;
+
+   /* These refer to the current draw (front vs. back) buffer:
+    */
+   int drawOffset;		/* draw buffer address in agp space */
+   int drawX;			/* origin of drawable in draw buffer */
+   int drawY;
+   GLuint numClipRects;		/* cliprects for that buffer */
+   XF86DRIClipRectPtr pClipRects;
+
+
+   int lastSwap;
+   int texAge;
+
+   XF86DRIClipRectRec draw_rect;
+
+   drmContext hHWContext;
+   drmLock *driHwLock;
+   int driFd;
+   Display *display;
+
+   __DRIdrawablePrivate *driDrawable;
+   __DRIscreenPrivate *driScreen;
+   i810ScreenPrivate *i810Screen; 
+   I810SAREAPriv *sarea;
+};
+
+
+/* To remove all debugging, make sure I810_DEBUG is defined as a
+ * preprocessor symbol, and equal to zero.  
+ */
+#define I810_DEBUG 0   
+#ifndef I810_DEBUG
+/*  #warning "Debugging enabled - expect reduced performance" */
+extern int I810_DEBUG;
+#endif
+
+#define DEBUG_VERBOSE_2D     0x1
+#define DEBUG_VERBOSE_RING   0x8
+#define DEBUG_VERBOSE_OUTREG 0x10
+#define DEBUG_ALWAYS_SYNC    0x40
+#define DEBUG_VERBOSE_MSG    0x80
+#define DEBUG_NO_OUTRING     0x100
+#define DEBUG_NO_OUTREG      0x200
+#define DEBUG_VERBOSE_API    0x400
+#define DEBUG_VALIDATE_RING  0x800
+#define DEBUG_VERBOSE_LRU    0x1000
+#define DEBUG_VERBOSE_DRI    0x2000
+
+
+
+extern GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out,
+					   const struct gl_pipeline_stage *in,
+					   GLuint nr );
+
+extern GLboolean i810DDBuildPrecalcPipeline( GLcontext *ctx );
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dd.c b/xc/lib/GL/mesa/src/drv/i810/i810dd.c
new file mode 100644
index 000000000..17436bf0d
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810dd.c
@@ -0,0 +1,146 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 "types.h"
+#include "vbrender.h"
+
+#include <stdio.h>
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810clear.h"
+#include "i810dd.h"
+#include "i810depth.h"
+#include "i810log.h"
+#include "i810state.h"
+#include "i810span.h"
+#include "i810tex.h"
+#include "i810tris.h"
+#include "i810vb.h"
+#include "i810pipeline.h"
+#include "extensions.h"
+#include "vb.h"
+#include "dd.h"
+
+
+extern int xf86VTSema;
+
+
+/***************************************
+ * Mesa's Driver Functions
+ ***************************************/
+
+
+static const GLubyte *i810DDGetString( GLcontext *ctx, GLenum name )
+{
+   switch (name) {
+   case GL_VENDOR:
+      return "Keith Whitwell, Precision Insight Inc.";
+   case GL_RENDERER:
+      return "DRI-I810";
+   default:
+      return 0;
+   }
+}
+
+static GLint i810GetParameteri(const GLcontext *ctx, GLint param)
+{
+   switch (param) {
+   case DD_HAVE_HARDWARE_FOG:  
+      return 1;
+   default:
+      return 0; 
+   }
+}
+
+
+
+static void i810BufferSize(GLcontext *ctx, GLuint *width, GLuint *height)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);  
+   *width = imesa->driDrawable->w;
+   *height = imesa->driDrawable->h;
+}
+
+
+
+
+void i810DDExtensionsInit( GLcontext *ctx )
+{
+   /* paletted_textures currently doesn't work.
+    */
+   gl_extensions_disable( ctx, "GL_EXT_shared_texture_palette" );
+   gl_extensions_disable( ctx, "GL_EXT_paletted_texture" );
+
+   /* we don't support point parameters in hardware yet */
+   gl_extensions_disable( ctx, "GL_EXT_point_parameters" );
+
+   /* The imaging subset of 1.2 isn't supported by any mesa driver.
+    */
+   gl_extensions_disable( ctx, "ARB_imaging" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_minmax" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_logic_op" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_subtract" );
+   gl_extensions_disable( ctx, "GL_INGR_blend_func_separate" );
+
+
+   if (0) gl_extensions_disable( ctx, "GL_ARB_multitexture" );
+
+
+   /* We do support tex_env_add, however
+    */
+   gl_extensions_enable( ctx, "GL_EXT_texture_env_add" );
+}
+
+
+static void i810DDFlush( GLcontext *ctx )
+{
+   i810DmaFlush( I810_CONTEXT(ctx) );
+}
+
+static void i810DDFinish( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   LOCK_HARDWARE( imesa );
+   i810DmaFinish( imesa );
+   UNLOCK_HARDWARE( imesa );
+}
+
+
+void i810DDInitDriverFuncs( GLcontext *ctx )
+{
+   ctx->Driver.GetBufferSize = i810BufferSize;
+   ctx->Driver.GetString = i810DDGetString;
+   ctx->Driver.GetParameteri = i810GetParameteri;
+   ctx->Driver.RegisterVB = i810DDRegisterVB;
+   ctx->Driver.UnregisterVB = i810DDUnregisterVB;
+   ctx->Driver.Clear = i810Clear;
+
+
+   ctx->Driver.Flush          = i810DDFlush;
+   ctx->Driver.Finish         = i810DDFinish;
+
+   ctx->Driver.BuildPrecalcPipeline = i810DDBuildPrecalcPipeline;
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dd.h b/xc/lib/GL/mesa/src/drv/i810/i810dd.h
new file mode 100644
index 000000000..86a8618d0
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810dd.h
@@ -0,0 +1,33 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810DD_INC
+#define I810DD_INC
+
+#include "context.h"
+
+void i810DDExtensionsInit( GLcontext *ctx );
+void i810DDInitDriverFuncs( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810depth.c b/xc/lib/GL/mesa/src/drv/i810/i810depth.c
new file mode 100644
index 000000000..d1aa12711
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810depth.c
@@ -0,0 +1,645 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   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, 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.
+ */
+
+/*
+ * This file has been modified by Wittawat Yamwong for GLX module.
+ */
+
+/*
+ * Depth buffer functions
+ */
+
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include <stdlib.h>
+#include <string.h>
+#include "context.h"
+#include "i810depth.h"
+#include "types.h"
+#include "mm.h"
+#include "i810lib.h"
+#endif
+
+
+
+/*
+ * Return the address of the Z-buffer value for window coordinate (x,y):
+ */
+#define Z_SETUP								\
+   i810ContextPtr imesa = I810_CONTEXT(ctx);				\
+   __DRIscreenPrivate *sPriv = imesa->driScreen;			\
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;			\
+   GLdepth *zbstart = (GLdepth *)(sPriv->pFB + i810Screen->depthOffset);\
+   GLint zbpitch = i810Screen->auxPitch
+
+#define Z_ADDRESS( X, Y )  \
+  (zbstart + zbpitch * (Y) + (X))
+
+
+/**********************************************************************/
+/*****                   Depth Testing Functions                  *****/
+/**********************************************************************/
+
+
+/*
+ * Depth test horizontal spans of fragments.  These functions are called
+ * via ctx->Driver.depth_test_span only.
+ *
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in span in window coords
+ *         z - array [n] of integer depth values
+ * In/Out:  mask - array [n] of flags (1=draw pixel, 0=don't draw) 
+ * Return:  number of pixels which passed depth test
+ */
+
+
+/*
+ * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
+ */
+static GLuint i810_depth_test_span_generic( GLcontext* ctx,
+					    GLuint n, GLint x, GLint y,
+					    const GLdepth z[],
+					    GLubyte mask[] )
+{
+   Z_SETUP;
+   GLdepth *zptr = Z_ADDRESS( x, y );
+   GLubyte *m = mask;
+   GLuint i;
+   GLuint passed = 0;
+
+   LOCK_HARDWARE(imesa);
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     /* fail */
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] <= *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] >= *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] > *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] != *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] == *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m =0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m =0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  *zptr = z[i];
+		  passed++;
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	    passed = n;
+	 }
+	 break;
+      case GL_NEVER:
+	 for (i=0;i<n;i++) {
+	    mask[i] = 0;
+	 }
+	 break;
+      default:
+   }   
+
+   UNLOCK_HARDWARE(imesa);
+
+   return passed;
+}
+
+
+
+
+
+/*
+ * Depth test an array of randomly positioned fragments.
+ */
+
+/*
+ * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
+ */
+static void i810_depth_test_pixels_generic( GLcontext* ctx,
+					    GLuint n, 
+					    const GLint x[], 
+					    const GLint y[],
+					    const GLdepth z[], 
+					    GLubyte mask[] )
+{
+   Z_SETUP;
+   register GLdepth *zptr;
+   register GLuint i;
+
+   LOCK_HARDWARE(imesa);
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  *zptr = z[i];
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	 }
+	 break;
+      case GL_NEVER:
+	 /* depth test never passes */
+	 for (i=0;i<n;i++) {
+	    mask[i] = 0;
+	 }
+	 break;
+      default:
+   } 
+   
+   UNLOCK_HARDWARE(imesa);
+}
+
+
+
+
+
+
+/**********************************************************************/
+/*****                      Read Depth Buffer                     *****/
+/**********************************************************************/
+
+
+/*
+ * Return a span of depth values from the depth buffer as floats in [0,1].
+ * This function is only called through Driver.read_depth_span_float()
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  depth - the array of depth values
+ */
+static void i810_read_depth_span_float( GLcontext* ctx,
+					GLuint n, GLint x, GLint y, 
+					GLfloat depth[] )
+{
+   Z_SETUP;
+   GLdepth *zptr;
+   GLfloat scale;
+   GLuint i;
+
+   LOCK_HARDWARE(imesa);
+
+   scale = 1.0F / DEPTH_SCALE;
+
+   if (ctx->Buffer->Depth) {
+      zptr = Z_ADDRESS( x, y );
+      for (i=0;i<n;i++) {
+	 depth[i] = (GLfloat) zptr[i] * scale;
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+	 depth[i] = 0.0F;
+      }
+   }
+
+   UNLOCK_HARDWARE(imesa);
+}
+
+
+/*
+ * Return a span of depth values from the depth buffer as integers in
+ * [0,MAX_DEPTH].
+ * This function is only called through Driver.read_depth_span_int()
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  depth - the array of depth values
+ */
+static void i810_read_depth_span_int( GLcontext* ctx,
+				      GLuint n, GLint x, GLint y, 
+				      GLdepth depth[] )
+{
+   Z_SETUP;
+
+   LOCK_HARDWARE(imesa);
+      
+   if (ctx->Buffer->Depth) {
+      GLdepth *zptr = Z_ADDRESS( x, y );
+      MEMCPY( depth, zptr, n * sizeof(GLdepth) );
+   }
+   else {
+      GLuint i;
+      for (i=0;i<n;i++) {
+	 depth[i] = 0;
+      }
+   }
+
+   UNLOCK_HARDWARE(imesa);
+}
+
+static void i810_alloc_depth_buffer( GLcontext *ctx )
+{
+}
+
+
+void i810DDInitDepthFuncs( GLcontext *ctx )
+{
+   ctx->Driver.AllocDepthBuffer   = i810_alloc_depth_buffer;
+   ctx->Driver.ReadDepthSpanFloat = i810_read_depth_span_float;
+   ctx->Driver.ReadDepthSpanInt = i810_read_depth_span_int;
+   ctx->Driver.DepthTestSpan = i810_depth_test_span_generic;
+   ctx->Driver.DepthTestPixels = i810_depth_test_pixels_generic;
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810depth.h b/xc/lib/GL/mesa/src/drv/i810/i810depth.h
new file mode 100644
index 000000000..f5543b552
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810depth.h
@@ -0,0 +1,37 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   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, 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.
+ */
+
+/*
+ * This file has been modified by Wittawat Yamwong for GLX module.
+ */
+
+
+#ifndef I810DEPTH_INC
+#define I810DEPTH_INC
+
+#include "types.h"
+
+extern void i810DDInitDepthFuncs( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dma.c b/xc/lib/GL/mesa/src/drv/i810/i810dma.c
new file mode 100644
index 000000000..a2f0bb3fd
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810dma.c
@@ -0,0 +1,105 @@
+/* -*- mode: C; c-basic-offset:8 -*- */
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
+
+#include "mm.h"
+#include "i810dd.h"
+#include "i810lib.h"
+#include "i810state.h"
+#include "i810dma.h"
+
+
+
+
+
+#if 0
+static void mga_vertex_dma_ioctl(mgaContextPtr mmesa)
+{
+   int retcode;
+   int size = MGA_DMA_BUF_SZ;
+   drmDMAReq dma;
+   drmBufPtr buf = mmesa->dma_buffer;
+
+   dma.context = mmesa->hHWContext;
+   dma.send_count = 1;
+   dma.send_list = &buf->idx;
+   dma.send_sizes = &size;
+   dma.flags = DRM_DMA_WAIT;
+   dma.request_count = 0;
+   dma.request_size = 0;
+   dma.request_list = 0;
+   dma.request_sizes = 0;
+
+   if ((retcode = drmDMA(mmesa->driFd, &dma))) {
+      printf("send iload retcode = %d\n", retcode);
+      exit(1);
+   }
+}
+
+
+
+void i810FlushVerticesLocked( i810ContextPtr imesa )
+{
+	
+}
+
+
+void i810FlushVertices( i810ContextPtr imesa ) {
+	LOCK_HARDWARE( imesa );
+	i810FlushVerticesLocked( imesa );
+	UNLOCK_HARDWARE( imesa );
+}
+
+#endif
+
+
+/*
+ * i810DmaFinish
+ */
+void i810DmaFinish( i810ContextPtr imesa ) {
+#if I810_USE_BATCH
+#else
+	_I810Sync( imesa );
+#endif
+}
+
+
+
+void i810DmaFlush( i810ContextPtr imesa ) {
+#if I810_USE_BATCH
+#else
+#endif
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dma.h b/xc/lib/GL/mesa/src/drv/i810/i810dma.h
new file mode 100644
index 000000000..9d472719a
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810dma.h
@@ -0,0 +1,186 @@
+/*
+  GLX Hardware Device Driver for Intel i810
+  Copyright (C) 1999 Keith Whitwell <keithw@precisioninsight.com>
+  
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  any later version.
+  
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  
+ original by Jeff Hartmann <slicer@ionet.net>
+  6/16/99: rewrite by John Carmack <johnc@idsoftware.com>
+  Oct 99: port to i180 by Keith Whitwell <keithw@precisioninsight.com>
+*/
+
+#ifndef I810DMA_H
+#define I810DMA_H
+
+#include "i810lib.h"
+#include "mm.h"
+
+/* a flush command will guarantee that all data added to the dma buffer
+is on its way to the card, and will eventually complete with no more
+intervention.
+*/
+void i810DmaFlush( i810ContextPtr imesa );
+
+/* the overflow function is called when a block can't be allocated
+in the current dma buffer.  It flushes the current buffer and
+records some information */
+void i810DmaOverflow(int newDwords);
+
+/* a finish command will guarantee that all dma commands have actually
+been consumed by the card.  Note that there may still be a couple primitives
+that have not yet been executed out of the internal FIFO, so this does not
+guarantee that the drawing engine is idle. */
+void i810DmaFinish( i810ContextPtr imesa );
+
+
+
+typedef struct {
+   unsigned long Start;
+   unsigned long End;
+   unsigned long Size;
+} I810MemRange;
+
+
+
+typedef struct i810_batch_buffer {
+   I810MemRange mem;
+   char *virtual_start;
+   int head;
+   int space;
+   int additional_space;
+   int texture_age;
+} i810BatchBuffer;
+
+
+
+#define I810_USE_BATCH 0
+#if I810_USE_BATCH
+
+#define BEGIN_BATCH( imesa, n )						\
+   unsigned int outbatch;						\
+   volatile char *virt;							\
+   if (I810_DEBUG & DEBUG_VERBOSE_RING)					\
+      fprintf(stderr,							\
+      "BEGIN_BATCH(%d) in %s\n"						\
+      "(spc left %d/%ld, head %x vstart %p start %lx)\n",		\
+      n, __FUNCTION__, i810glx.dma_buffer->space,			\
+      i810glx.dma_buffer->mem.Size - i810glx.dma_buffer->head,		\
+      i810glx.dma_buffer->head,						\
+      i810glx.dma_buffer->virtual_start,				\
+      i810glx.dma_buffer->mem.Start );					\
+   if (i810glx.dma_buffer->space < n*4)					\
+       i810DmaOverflow(n);						\
+   outbatch = i810glx.dma_buffer->head;					\
+   virt = i810glx.dma_buffer->virtual_start;			
+
+
+#define OUT_BATCH(val) {					\
+   *(volatile unsigned int *)(virt + outbatch) = val;		\
+   if (I810_DEBUG & DEBUG_VERBOSE_RING)				\
+      fprintf(stderr, "OUT_BATCH %x: %x\n", (int)(outbatch/4), (int)(val));	\
+   outbatch += 4;						\
+}
+   
+
+#define ADVANCE_BATCH() {						\
+   if (I810_DEBUG & DEBUG_VERBOSE_RING)					\
+      fprintf(stderr, "ADVANCE_BATCH(%f) in %s\n",			\
+                  (outbatch - i810glx.dma_buffer->head) / 4.0,		\
+                  __FUNCTION__);					\
+   i810glx.dma_buffer->space -= outbatch - i810glx.dma_buffer->head;	\
+   i810glx.dma_buffer->head = outbatch;					\
+}
+
+#define FINISH_PRIM()
+
+#else
+
+
+/* As an alternate path to dma, we can export the registers (and hence
+ * ringbuffer) to the client.  For security we should alloc these
+ * things in agp memory which isn't exported to the client.  But then
+ * again, the client could blit over such things if it wanted to hang
+ * the system.
+ *
+ * Malicious clients aren't really delt with by the DRI.
+ */
+
+
+extern void _I810RefreshLpRing( i810ContextPtr imesa, int update );
+extern int _I810WaitLpRing( i810ContextPtr imesa, int n, int timeout_usec );
+extern int _I810Sync( i810ContextPtr imesa );
+
+
+#define OUT_RING(n) {					\
+   if (I810_DEBUG & DEBUG_VERBOSE_RING)			\
+      fprintf(stderr, "OUT_RING %x: %x\n", outring, (int)(n));	\
+   if (!(I810_DEBUG & DEBUG_NO_OUTRING)) {		\
+      *(volatile unsigned int *)(virt + outring) = n;	\
+      outring += 4;					\
+      outring &= ringmask;				\
+   }							\
+}
+
+#define ADVANCE_LP_RING() {			\
+    i810glx.LpRing.tail = outring;		\
+    OUTREG(LP_RING + RING_TAIL, outring);	\
+}
+
+#define BEGIN_LP_RING(imesa, n)						\
+   unsigned int outring, ringmask;					\
+   volatile char *virt;							\
+   if ((I810_DEBUG&DEBUG_ALWAYS_SYNC) && n>2) _I810Sync( imesa );	\
+   if (i810glx.LpRing.space < n*4) _I810WaitLpRing( imesa, n*4, 0);	\
+   i810glx.LpRing.space -= n*4;						\
+   if (I810_DEBUG & DEBUG_VERBOSE_RING) 				\
+      fprintf(stderr, "BEGIN_LP_RING %d in %s\n", n, __FUNCTION__);	\
+   if (I810_DEBUG & DEBUG_VALIDATE_RING) { 				\
+      CARD32 tail = INREG(LP_RING+RING_TAIL);				\
+      if (tail != i810glx.LpRing.tail) {				\
+	 fprintf(stderr, "tail %x pI810->LpRing.tail %x\n",		\
+		    (int) tail, (int) i810glx.LpRing.tail);				\
+         exit(1);							\
+      }									\
+   }									\
+   i810glx.LpRing.synced = 0;						\
+   outring = i810glx.LpRing.tail;					\
+   ringmask = i810glx.LpRing.tail_mask;					\
+   virt = i810glx.LpRing.virtual_start;			
+
+
+#define EXTRAAA \
+
+#define INREG(addr)         *(volatile CARD32 *)(i810glx.MMIOBase + (addr))
+#define INREG16(addr)       *(volatile CARD16 *)(i810glx.MMIOBase + (addr))
+#define INREG8(addr)        *(volatile CARD8  *)(i810glx.MMIOBase + (addr))
+
+#define OUTREG(addr, val) do {					\
+   if (I810_DEBUG&DEBUG_VERBOSE_OUTREG)				\
+      fprintf(stderr, "OUTREG(%x, %x)\n", addr, val);		\
+   if (!(I810_DEBUG&DEBUG_NO_OUTREG))				\
+      *(volatile CARD32 *)(i810glx.MMIOBase + (addr)) = (val);	\
+} while (0)
+
+
+#define BEGIN_BATCH(imesa, n) BEGIN_LP_RING(imesa, n)
+#define ADVANCE_BATCH() ADVANCE_LP_RING()
+#define OUT_BATCH(val) OUT_RING(val)
+#define FINISH_PRIM() OUTREG(LP_RING + RING_TAIL, i810glx.LpRing.tail)
+
+#endif
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c b/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c
new file mode 100644
index 000000000..9223060e7
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c
@@ -0,0 +1,530 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdio.h>
+
+#include "types.h"
+#include "enums.h"
+#include "cva.h"
+#include "vertices.h"
+
+/*  #include "mmath.h" */
+
+#include "i810context.h"
+#include "i810pipeline.h"
+#include "i810tris.h"
+#include "i810state.h"
+#include "i810vb.h"
+
+
+extern void i810DDResizeVB( struct vertex_buffer *VB, GLuint size );
+
+extern void gl_fast_copy_vb( struct vertex_buffer *VB );
+  
+struct i810_fast_tab {
+   void (*build_vertices)( struct vertex_buffer *VB, GLuint do_cliptest );
+   void (*interp)( GLfloat t, GLfloat *O, const GLfloat *I, const GLfloat *J );
+};
+
+
+
+
+#define POINT(x) i810_draw_point(imesa, &ivert[x].v, psize)
+#define LINE(x,y) i810_draw_line(imesa, &ivert[x].v, &ivert[y].v, lwidth)
+#define TRI(x,y,z) i810_draw_triangle(imesa, &ivert[x].v, &ivert[y].v, &ivert[z].v)
+
+
+
+
+/* Direct, and no clipping required.  I haven't written the clip funcs
+ * yet, so this is only useful for the fast path.
+ */
+#define RENDER_POINTS( start, count )		\
+do {						\
+   GLuint e;					\
+   for(e=start;e<=count;e++)			\
+     POINT(elt[e]);				\
+} while (0)
+
+#define RENDER_LINE( i1, i )			\
+do {						\
+   GLuint e1 = elt[i1], e = elt[i];		\
+   LINE( e1, e );				\
+} while (0)
+
+
+#define RENDER_TRI( i2, i1, i, pv, parity)		\
+do {							\
+{  GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  if (parity) {GLuint tmp = e2; e2 = e1; e1 = tmp;}	\
+  TRI(e2, e1, e);					\
+}} while (0)
+
+
+#define RENDER_QUAD( i3, i2, i1, i, pv)				\
+do {								\
+  GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  TRI(e3, e2, e);						\
+  TRI(e2, e1, e);						\
+} while (0)
+
+#define LOCAL_VARS					\
+   i810VertexPtr ivert = I810_DRIVER_DATA(VB)->verts;	\
+   const GLuint *elt = VB->EltPtr->data;		\
+   GLcontext *ctx = VB->ctx;				\
+   i810ContextPtr imesa = I810_CONTEXT(ctx);	\
+   const GLfloat lwidth = ctx->Line.Width;		\
+   const GLfloat psize = ctx->Point.Size;		\
+   (void) lwidth; (void)psize; (void) ivert;
+
+
+#define TAG(x) x##_i810_smooth_indirect
+#include "render_tmp.h"
+
+
+
+static void i810_render_elements_direct( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLenum prim = ctx->CVA.elt_mode;
+   GLuint nr = VB->EltPtr->count;
+   render_func func = render_tab_i810_smooth_indirect[prim];
+   GLuint p = 0;
+   
+   if (imesa->new_state)
+      i810DDUpdateHwState( ctx );
+
+   BEGIN_CLIP_LOOP(imesa) 
+      {
+	 do {
+	    func( VB, 0, nr, 0 );
+	 } while (ctx->Driver.MultipassFunc &&
+		  ctx->Driver.MultipassFunc( VB, ++p ));
+      }
+   END_CLIP_LOOP(imesa);
+}
+
+
+
+#define NEGATIVE(f)          (f < 0)
+#define DIFFERENT_SIGNS(a,b) ((a*b) < 0)
+#define LINTERP( T, A, B )   ( (A) + (T) * ( (B) - (A) ) )
+
+
+#define INTERP_RGBA(t, out, a, b) {			\
+   int i;						\
+   for (i = 0; i < 4; i++) {				\
+      GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a[i]);	\
+      GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b[i]);	\
+      GLfloat fo = LINTERP(t, fa, fb);			\
+      FLOAT_COLOR_TO_UBYTE_COLOR(out[i], fo);		\
+   }							\
+}
+
+
+#define CLIP(SGN,V,PLANE)					\
+if (mask & PLANE) {						\
+   GLuint *indata = inlist[in];					\
+   GLuint *outdata = inlist[in ^= 1];				\
+   GLuint nr = n;						\
+   GLfloat *J = verts[indata[nr-1]].f;			\
+   GLfloat dpJ = (SGN J[V]) + J[3];				\
+								\
+   inlist[0] = vlist1;						\
+   for (i = n = 0 ; i < nr ; i++) {				\
+      GLuint elt_i = indata[i];					\
+      GLfloat *I = verts[elt_i].f;				\
+      GLfloat dpI = (SGN I[V]) + I[3];				\
+								\
+      if (DIFFERENT_SIGNS(dpI, dpJ)) {				\
+								\
+	 GLfloat *O = verts[next_vert].f;			\
+	 GLfloat t, *in, *out;					\
+								\
+	 if (NEGATIVE(dpI)) {					\
+	     t = dpI / (dpI - dpJ);				\
+	     in = I;						\
+	     out = J;						\
+	 }							\
+         else							\
+	 {							\
+	    t = dpJ / (dpJ - dpI);				\
+	    in = J;						\
+	    out = I;						\
+	 }							\
+								\
+	 interp(t, O, in, out);					\
+								\
+	 clipmask[next_vert] = 0;				\
+	 outdata[n++] = next_vert++;				\
+      }								\
+								\
+      clipmask[elt_i] |= PLANE;		/* don't set up */	\
+								\
+      if (!NEGATIVE(dpI)) {					\
+	 outdata[n++] = elt_i;					\
+	 clipmask[elt_i] &= ~PLANE;	/* set up after all */	\
+      }								\
+								\
+      J = I;							\
+      dpJ = dpI;						\
+   }								\
+								\
+   if (n < 3) return;						\
+}
+
+#define LINE_CLIP(x,y,z,w,PLANE)		\
+if (mask & PLANE) {				\
+   GLfloat dpI = DOT4V(I,x,y,z,w);		\
+   GLfloat dpJ = DOT4V(J,x,y,z,w);		\
+						\
+   if (DIFFERENT_SIGNS(dpI, dpJ)) {		\
+      GLfloat *O = verts[next_vert].f;	\
+      GLfloat t = dpI / (dpI - dpJ);		\
+						\
+      interp(t, O, I, J);			\
+						\
+      clipmask[next_vert] = 0;			\
+						\
+      if (NEGATIVE(dpI)) {			\
+  	 clipmask[elts[0]] |= PLANE;		\
+	 I = O; elts[0] = next_vert++;		\
+      } else {					\
+  	 clipmask[elts[1]] |= PLANE;		\
+	 J = O;	elts[1] = next_vert++;		\
+      }						\
+   }						\
+   else if (NEGATIVE(dpI))			\
+      return;					\
+}
+
+
+static __inline void i810_tri_clip( GLuint **p_elts,
+				    i810Vertex *verts,
+				    GLubyte *clipmask,
+				    GLuint *p_next_vert,
+				    GLubyte mask,
+				    i810_interp_func interp )
+{
+   GLuint *elts = *p_elts;
+   GLuint next_vert = *p_next_vert;
+   GLuint vlist1[VB_MAX_CLIPPED_VERTS];
+   GLuint vlist2[VB_MAX_CLIPPED_VERTS];
+   GLuint *inlist[2];
+   GLuint *out;
+   GLuint in = 0;
+   GLuint n = 3;
+   GLuint i;
+
+   inlist[0] = elts;
+   inlist[1] = vlist2;
+
+   CLIP(-,0,CLIP_RIGHT_BIT);
+   CLIP(+,0,CLIP_LEFT_BIT);
+   CLIP(-,1,CLIP_TOP_BIT);
+   CLIP(+,1,CLIP_BOTTOM_BIT);
+   CLIP(-,2,CLIP_FAR_BIT);
+   CLIP(+,2,CLIP_NEAR_BIT);
+
+   /* Convert the planar polygon to a list of triangles.
+    */
+   out = inlist[in];
+   
+   for (i = 2 ; i < n ; i++) {
+      elts[0] = out[0];
+      elts[1] = out[i-1];
+      elts[2] = out[i];
+      elts += 3;
+   }
+
+   *p_next_vert = next_vert;
+   *p_elts = elts;
+}
+
+
+static __inline void i810_line_clip( GLuint **p_elts,
+				    i810Vertex *verts,
+				    GLubyte *clipmask,
+				    GLuint *p_next_vert,
+				    GLubyte mask,
+				    i810_interp_func interp )
+{
+   GLuint *elts = *p_elts;
+   GLfloat *I = verts[elts[0]].f;
+   GLfloat *J = verts[elts[1]].f;
+   GLuint next_vert = *p_next_vert;
+
+   LINE_CLIP(1,0,0,-1,CLIP_LEFT_BIT);
+   LINE_CLIP(-1,0,0,1,CLIP_RIGHT_BIT);
+   LINE_CLIP(0,1,0,-1,CLIP_TOP_BIT);
+   LINE_CLIP(0,-1,0,1,CLIP_BOTTOM_BIT);
+   LINE_CLIP(0,0,1,-1,CLIP_FAR_BIT);
+   LINE_CLIP(0,0,-1,1,CLIP_NEAR_BIT);
+
+   *p_next_vert = next_vert;
+   *p_elts += 2;
+}
+
+
+
+#define CLIP_POINT( e )				\
+   if (mask[e])					\
+      *out++ = e 
+
+#define CLIP_LINE( e1, e0 )						\
+do {									\
+   GLubyte ormask = mask[e0] | mask[e1];				\
+   out[0] = e1;								\
+   out[1] = e0;								\
+   out+=2;								\
+   if (ormask) {							\
+      out-=2;								\
+      if (!(mask[e0] & mask[e1])) {					\
+	 i810_line_clip( &out, verts, mask, &next_vert, ormask, interp); \
+      }									\
+   }									\
+} while (0)
+
+#define CLIP_TRIANGLE( e2, e1, e0 )					\
+do {									\
+   GLubyte ormask;							\
+   out[0] = e2;								\
+   out[1] = e1;								\
+   out[2] = e0;								\
+   out += 3;								\
+   ormask = mask[e2] | mask[e1] | mask[e0];				\
+   if (ormask) {							\
+      out -= 3;								\
+      if ( !(mask[e2] & mask[e1] & mask[e0])) {				\
+	 i810_tri_clip( &out, verts, mask, &next_vert, ormask, interp ); \
+      }									\
+   }									\
+} while (0)
+
+
+
+
+
+
+/* Build a table of functions to clip each primitive type.  These
+ * produce a list of elements in the appropriate 'reduced' primitive,
+ * ie (points, lines, triangles) containing all the clipped and
+ * unclipped primitives from the original list.
+ */
+#define LOCAL_VARS						\
+   i810ContextPtr imesa = I810_CONTEXT( VB->ctx );                \
+   GLuint *elt = VB->EltPtr->data;				\
+   i810Vertex *verts = I810_DRIVER_DATA(VB)->verts;		\
+   GLuint next_vert = I810_DRIVER_DATA(VB)->last_vert;		\
+   GLuint *out = I810_DRIVER_DATA(VB)->clipped_elements.data;	\
+   GLubyte *mask = VB->ClipMask;				\
+   i810_interp_func interp = imesa->interp;                      \
+   (void) interp; (void) verts;
+
+#define POSTFIX							\
+   I810_DRIVER_DATA(VB)->clipped_elements.count =		\
+          out - I810_DRIVER_DATA(VB)->clipped_elements.data;	\
+   I810_DRIVER_DATA(VB)->last_vert = next_vert;		
+
+
+#define INIT(x)
+
+#define RENDER_POINTS(start, count)			\
+do {							\
+   GLuint i;						\
+   for (i = start ; i < count ; i++ )			\
+      CLIP_POINT( elt[i] );				\
+} while (0)
+
+#define RENDER_LINE(i1, i0)      			\
+   CLIP_LINE(elt[i1], elt[i0])
+
+#define RENDER_TRI(i2, i1, i0, pv, parity)		\
+do {							\
+   GLuint e2 = elt[i2], e1 = elt[i1], e0 = elt[i0];	\
+   if (parity) e2 = elt[i1], e1 = elt[i2];		\
+   CLIP_TRIANGLE( e2, e1, e0 );				\
+} while (0)
+
+#define RENDER_QUAD(i3, i2, i1, i0, pv )		\
+  CLIP_TRIANGLE(elt[i3], elt[i2], elt[i0]);     	\
+  CLIP_TRIANGLE(elt[i2], elt[i1], elt[i0])
+
+#define TAG(x) i810_clip_##x##_elt
+#include "render_tmp.h"
+
+
+
+static void i810_project_vertices( struct vertex_buffer *VB )
+{
+   i810VertexBufferPtr i810VB = I810_DRIVER_DATA(VB);
+   GLcontext *ctx = VB->ctx;
+   GLmatrix *mat = &ctx->Viewport.WindowMap;
+   GLfloat m[16];
+
+   m[MAT_SX] =   mat->m[MAT_SX];
+   m[MAT_TX] =   mat->m[MAT_TX] - .5;
+   m[MAT_SY] = (- mat->m[MAT_SY]);
+   m[MAT_TY] = (- mat->m[MAT_TY]) + I810_CONTEXT(ctx)->driDrawable->h - .5;
+   m[MAT_SZ] =   mat->m[MAT_SZ] * (1.0 / 0x10000);
+   m[MAT_TZ] =   mat->m[MAT_TZ] * (1.0 / 0x10000);
+
+   gl_project_v16( i810VB->verts[VB->CopyStart].f,
+		   i810VB->verts[i810VB->last_vert].f,
+		   m,
+		   16 * 4 );
+}
+
+static void i810_project_clipped_vertices( struct vertex_buffer *VB )
+{
+   i810VertexBufferPtr i810VB = I810_DRIVER_DATA(VB);
+   GLcontext *ctx = VB->ctx;
+   GLmatrix *mat = &ctx->Viewport.WindowMap;
+   GLfloat m[16];
+
+   m[MAT_SX] =   mat->m[MAT_SX];
+   m[MAT_TX] =   mat->m[MAT_TX] - .5;
+   m[MAT_SY] = (- mat->m[MAT_SY]);
+   m[MAT_TY] = (- mat->m[MAT_TY]) + I810_CONTEXT(ctx)->driDrawable->h - .5;
+   m[MAT_SZ] =   mat->m[MAT_SZ] * (1.0 / 0x10000);
+   m[MAT_TZ] =   mat->m[MAT_TZ] * (1.0 / 0x10000);
+
+   gl_project_clipped_v16( i810VB->verts[VB->CopyStart].f,
+			   i810VB->verts[i810VB->last_vert].f,
+			   m,
+			   16 * 4,
+			   VB->ClipMask + VB->CopyStart );
+}
+
+
+/* Pack rgba and/or texture into the remaining half of a 32 byte vertex.
+ */
+#define CLIP_UBYTE_COLOR  4
+#define CLIP_UBYTE_B 0   
+#define CLIP_UBYTE_G 1  
+#define CLIP_UBYTE_R 2
+#define CLIP_UBYTE_A 3   
+#define CLIP_S0 6
+#define CLIP_T0 7
+#define CLIP_S1 8
+#define CLIP_T1 9
+
+#define TYPE (0)
+#define TAG(x) x
+#include "i810fasttmp.h"
+
+#define TYPE (I810_RGBA_BIT)
+#define TAG(x) x##_RGBA
+#include "i810fasttmp.h"
+
+#define TYPE (I810_TEX0_BIT)
+#define TAG(x) x##_TEX0
+#include "i810fasttmp.h"
+
+#define TYPE (I810_RGBA_BIT|I810_TEX0_BIT)
+#define TAG(x) x##_RGBA_TEX0
+#include "i810fasttmp.h"
+
+#define TYPE (I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT)
+#define TAG(x) x##_RGBA_TEX0_TEX1
+#include "i810fasttmp.h"
+
+/* This one *could* get away with sneaking TEX1 into the color and
+ * specular slots, thus fitting inside a cache line.  Would be even
+ * better to switch to a smaller vertex.
+ */
+#define TYPE (I810_TEX0_BIT|I810_TEX1_BIT)
+#define TAG(x) x##_TEX0_TEX1
+#include "i810fasttmp.h"
+
+
+/* Very sparsely popluated array - fix the indices.
+ */
+static struct i810_fast_tab i810FastTab[0x80];
+
+void i810DDFastPathInit( void )
+{
+   i810_clip_render_init_elt();
+   render_init_i810_smooth_indirect();
+
+   i810_init_fastpath( &i810FastTab[0] );
+   i810_init_fastpath_RGBA( &i810FastTab[I810_RGBA_BIT] );
+   i810_init_fastpath_TEX0( &i810FastTab[I810_TEX0_BIT] );
+   i810_init_fastpath_RGBA_TEX0( &i810FastTab[I810_RGBA_BIT|I810_TEX0_BIT] );
+   i810_init_fastpath_TEX0_TEX1( &i810FastTab[I810_TEX0_BIT|I810_TEX1_BIT] );
+   i810_init_fastpath_RGBA_TEX0_TEX1( &i810FastTab[I810_RGBA_BIT|I810_TEX0_BIT|
+						  I810_TEX1_BIT] );
+}
+
+#define VALID_SETUP (I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT)
+
+
+void i810DDFastPath( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   GLenum prim = ctx->CVA.elt_mode;
+   i810ContextPtr imesa = I810_CONTEXT( ctx ); 
+   struct i810_fast_tab *tab = &i810FastTab[imesa->setupindex & VALID_SETUP];
+   GLuint do_cliptest = 1;
+
+   gl_prepare_arrays_cva( VB );	                 /* still need this */
+
+   /* Reserve enough space for the pathological case.
+    */
+   if (VB->EltPtr->count * 12 > I810_DRIVER_DATA(VB)->size) {
+      i810DDResizeVB( VB, VB->EltPtr->count * 12 );
+      do_cliptest = 1;
+   }
+
+   tab->build_vertices( VB, do_cliptest );       /* object->clip space */
+
+   if (imesa->new_state)
+      i810DDUpdateHwState( ctx );
+
+   if (VB->ClipOrMask) {
+      if (!VB->ClipAndMask) {
+	 render_func *clip = i810_clip_render_tab_elt;
+      
+	 imesa->interp = tab->interp;
+      
+	 clip[prim]( VB, 0, VB->EltPtr->count, 0 ); /* build new elts */
+
+	 ctx->CVA.elt_mode = gl_reduce_prim[prim];
+	 VB->EltPtr = &(I810_DRIVER_DATA(VB)->clipped_elements);
+
+	 i810_project_clipped_vertices( VB );    /* clip->device space */
+	 i810_render_elements_direct( VB );        /* render using new list */
+      }
+   } else {
+      i810_project_vertices( VB );               /* clip->device space  */
+      i810_render_elements_direct( VB );           /* render using orig list */
+   }
+
+   /* This indicates that there is no cached data to reuse.  
+    */
+   VB->pipeline->data_valid = 0;
+   VB->pipeline->new_state = 0;
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810fasttmp.h b/xc/lib/GL/mesa/src/drv/i810/i810fasttmp.h
new file mode 100644
index 000000000..115fe7b24
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810fasttmp.h
@@ -0,0 +1,143 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ */
+
+
+
+/* The first part of setup is applied to all vertices, clipped or
+ * unclipped.  This data w!ill be used for clipping, and then all
+ * vertices with a zero clipmask will be projected to device space.
+ *
+ * This could be split into several loops, but - it seems that the
+ * large stride of the fxVertices makes cache issues the big
+ * performance factor, and that multiple loops mean multiple cache
+ * misses....
+ */
+static void TAG(i810_setup_full)( struct vertex_buffer *VB, GLuint do_cliptest )
+{
+   GLcontext *ctx = VB->ctx;
+   const GLfloat * const m = ctx->ModelProjectMatrix.m;
+   GLuint start = VB->CopyStart;
+   GLuint count = VB->Count;
+   GLuint i;
+
+   gl_xform_points3_v16_general(I810_DRIVER_DATA(VB)->verts[start].f,
+				m, 
+				VB->ObjPtr->start,
+				VB->ObjPtr->stride,
+				count - start);
+
+   if (do_cliptest)
+   {
+      VB->ClipAndMask = ~0; 
+      VB->ClipOrMask = 0;
+      gl_cliptest_points4_v16(I810_DRIVER_DATA(VB)->verts[start].f,
+			      I810_DRIVER_DATA(VB)->verts[count].f,
+			      &(VB->ClipOrMask),
+			      &(VB->ClipAndMask),
+			      VB->ClipMask + start);
+   }
+
+   /* These branches are all resolved at compile time.  Hopefully all
+    * the pointers are valid addresses even when not enabled.
+    */
+   if (TYPE) {
+      GLubyte *color = VB->ColorPtr->start;
+      GLfloat *tex0_data = VB->TexCoordPtr[0]->start;
+      GLfloat *tex1_data = VB->TexCoordPtr[1]->start;
+
+      GLuint color_stride = VB->ColorPtr->stride;
+      GLuint tex0_stride = VB->TexCoordPtr[0]->stride;
+      GLuint tex1_stride = VB->TexCoordPtr[1]->stride;
+
+      GLfloat *f = I810_DRIVER_DATA(VB)->verts[start].f;
+
+      for (i = start ; i < count ; i++, f += 16) {
+	 if (TYPE & I810_RGBA_BIT) {
+	    GLubyte *b = (GLubyte *)&f[CLIP_UBYTE_COLOR];
+	    GLubyte *col = color; color += color_stride;
+	    b[CLIP_UBYTE_R] = col[0];
+	    b[CLIP_UBYTE_G] = col[1];
+	    b[CLIP_UBYTE_B] = col[2];
+	    b[CLIP_UBYTE_A] = col[3];
+	 }
+	 if (TYPE & I810_TEX0_BIT) {
+	    f[CLIP_S0] = tex0_data[0];
+	    f[CLIP_T0] = tex0_data[1];
+	    STRIDE_F(tex0_data, tex0_stride);
+	 }
+	 if (TYPE & I810_TEX1_BIT) {
+	    f[CLIP_S1] = tex1_data[0];
+	    f[CLIP_T1] = tex1_data[1];
+	    STRIDE_F(tex1_data, tex1_stride);
+	 }
+      }
+   }
+
+   I810_DRIVER_DATA(VB)->clipped_elements.count = start;
+   I810_DRIVER_DATA(VB)->last_vert = count;
+}
+
+
+/* Changed to just put the interp func instead of the whole clip
+ * routine into the header.  Less code and better chance of doing some
+ * of this stuff in assembly.
+ */
+static void TAG(i810_interp_vert)( GLfloat t, 
+				  GLfloat *O,
+				  const GLfloat *I,
+				  const GLfloat *J )
+{
+   O[0] = LINTERP(t, I[0], J[0]);
+   O[1] = LINTERP(t, I[1], J[1]);
+   O[2] = LINTERP(t, I[2], J[2]);
+   O[3] = LINTERP(t, I[3], J[3]);
+
+   if (TYPE & I810_RGBA_BIT) {
+      INTERP_RGBA(t,
+		  ((GLubyte *)&(O[4])),
+		  ((GLubyte *)&(I[4])),
+		  ((GLubyte *)&(J[4])));
+   }
+
+   if (TYPE & I810_TEX0_BIT) {
+      O[6] = LINTERP(t, I[6], J[6]);
+      O[7] = LINTERP(t, I[7], J[7]);
+   }
+
+   if (TYPE & I810_TEX1_BIT) {
+      O[8] = LINTERP(t, I[8], J[8]);
+      O[9] = LINTERP(t, I[9], J[9]);
+   }
+}
+
+
+static void TAG(i810_init_fastpath)( struct i810_fast_tab *tab )
+{
+   tab->interp = TAG(i810_interp_vert);
+   tab->build_vertices = TAG(i810_setup_full);
+}
+
+#undef TYPE
+#undef TAG
+#undef SIZE
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810lib.h b/xc/lib/GL/mesa/src/drv/i810/i810lib.h
new file mode 100644
index 000000000..ad80674f0
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810lib.h
@@ -0,0 +1,130 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810LIB_INC
+#define I810LIB_INC
+
+#include <stdio.h>
+
+#include "i810context.h"
+#include "mm.h"
+#include "i810log.h"
+
+
+struct i810_mem_range {
+   unsigned long Start;
+   unsigned long End;
+   unsigned long Size;
+};
+
+struct i810_batch_buffer;
+
+struct i810_ring_buffer {
+   int tail_mask;
+   struct i810_mem_range mem;
+   char *virtual_start;
+   int head;
+   int tail;
+   int space;
+   int synced;
+};
+
+typedef struct {
+   /* logging stuff */
+   GLuint logLevel;
+   FILE *logFile;
+
+   /* bookkeeping for texture swaps */
+   GLuint dma_buffer_age;
+   GLuint current_texture_age;
+        
+   /* options */
+   GLuint nullprims;		/* skip all primitive generation */
+   GLuint boxes;		/* draw performance boxes */
+   GLuint noFallback;		/* don't fall back to software */
+   GLuint skipDma;		/* don't send anything to hardware */
+
+   /* performance counters */	
+   GLuint c_setupPointers;
+   GLuint c_triangles;
+   GLuint c_points;
+   GLuint c_lines;
+   GLuint c_drawWaits;
+   GLuint c_textureSwaps;
+   GLuint c_dmaFlush;
+   GLuint c_overflows;
+
+   GLuint c_ringlost;
+   GLuint c_texlost;
+   GLuint c_ctxlost;
+	
+   GLuint hardwareWentIdle;	/* cleared each swapbuffers, set if a
+				   waitfordmacompletion ever exited
+				   without having to wait */
+
+   unsigned char *texVirtual;
+
+   
+   struct i810_batch_buffer *dma_buffer;
+   struct i810_ring_buffer LpRing;
+   unsigned char *MMIOBase;
+
+} i810Glx_t;
+
+extern i810Glx_t	i810glx;
+
+
+#define I810PACKCOLOR1555(r,g,b,a) \
+  ((((r) & 0xf8) << 7) | (((g) & 0xf8) << 2) | (((b) & 0xf8) >> 3) | \
+    ((a) ? 0x8000 : 0))
+
+#define I810PACKCOLOR565(r,g,b) \
+  ((((r) & 0xf8) << 8) | (((g) & 0xfc) << 3) | (((b) & 0xf8) >> 3))
+
+#define I810PACKCOLOR4444(r,g,b,a) \
+  ((((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | ((g) & 0xf0) | ((b) >> 4))
+
+
+#include "i810_3d_reg.h"
+
+static __inline__ GLuint i810PackColor(GLuint format, 
+				       GLubyte r, GLubyte g, 
+				       GLubyte b, GLubyte a)
+{
+  switch (format) {
+  case DV_PF_555:
+    return I810PACKCOLOR1555(r,g,b,a);
+  case DV_PF_565:
+    return I810PACKCOLOR565(r,g,b);
+  default:
+     fprintf(stderr, "unknown format %d\n", (int)format);
+    return 0;
+  }
+}
+
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810log.h b/xc/lib/GL/mesa/src/drv/i810/i810log.h
new file mode 100644
index 000000000..707cd618f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810log.h
@@ -0,0 +1,47 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+ 
+/* Usage:
+ * - use i810Error for error messages. Always write to X error and log file.
+ * - use i810Msg for debugging. Can be disabled by undefining I810_LOG_ENABLED.
+ */
+ 
+#ifndef I810LOG_INC
+#define I810LOG_INC
+#include "hwlog.h"
+
+/* Mapping between old function names and new common code: */
+/* (Feel free to replace all i810Msg with hwMsg etc. in all *.c
+ * files, I was to lazy to do this...) */
+#define i810OpenLog(f) 	hwOpenLog(f,"[i810] ")
+#define i810CloseLog 	hwCloseLog
+#define i810IsLogReady 	hwIsLogReady
+#define i810SetLogLevel  hwSetLogLevel
+#define i810GetLogLevel  hwGetLogLevel
+#define i810Msg		hwMsg
+#define i810Error	hwError
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c
new file mode 100644
index 000000000..fb2d368fe
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c
@@ -0,0 +1,112 @@
+/*  #include "i810pipeline.h" */
+
+#include <stdio.h>
+#include "i810vb.h"
+#include "i810dd.h"
+#include "i810lib.h"
+#include "i810tris.h"
+#include "i810pipeline.h"
+
+#include "fog.h"
+
+static struct gl_pipeline_stage i810_fast_stage = {
+   "I810 fast path",
+   (PIPE_OP_VERT_XFORM|PIPE_OP_RAST_SETUP_0|
+    PIPE_OP_RAST_SETUP_1|PIPE_OP_RENDER),
+   PIPE_PRECALC,
+   0, 0, 0, 0, 0, 0, 0, 0, 0,	
+   i810DDFastPath
+};
+
+
+#define ILLEGAL_ENABLES (TEXTURE0_3D|		\
+			 TEXTURE1_3D|		\
+			 ENABLE_TEXMAT0 |	\
+			 ENABLE_TEXMAT1 |	\
+			 ENABLE_TEXGEN0 |	\
+			 ENABLE_TEXGEN1 |	\
+			 ENABLE_USERCLIP |	\
+			 ENABLE_LIGHT |		\
+			 ENABLE_FOG)
+			
+
+/* The driver gets first shot at building the pipeline - make some
+ * quick tests to see if we can use the fast path.
+ */
+GLboolean i810DDBuildPrecalcPipeline( GLcontext *ctx )
+{   
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   struct gl_pipeline *pipe = &ctx->CVA.pre;
+   
+   if (imesa->renderindex == 0 && 
+       (ctx->Enabled & ILLEGAL_ENABLES) == 0 &&
+       (ctx->Array.Flags & (VERT_OBJ_234|
+			    VERT_TEX0_4|
+			    VERT_TEX1_4|
+			    VERT_ELT)) == (VERT_OBJ_23|VERT_ELT))
+   {
+      pipe->stages[0] = &i810_fast_stage;
+      pipe->stages[1] = 0;
+      pipe->new_inputs = ctx->RenderFlags & VERT_DATA;
+      pipe->ops = pipe->stages[0]->ops;
+      imesa->using_fast_path = 1;
+      return 1;
+   } 
+
+   if (imesa->using_fast_path) 
+   {
+      imesa->using_fast_path = 0;
+      ctx->CVA.VB->ClipOrMask = 0;
+      ctx->CVA.VB->ClipAndMask = CLIP_ALL_BITS;
+      ctx->Array.NewArrayState |= ctx->Array.Summary;
+      return 0;
+   }
+   
+   return 0;
+}
+
+
+
+GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out,
+				    const struct gl_pipeline_stage *in,
+				    GLuint nr )
+{
+   GLuint i, o;
+
+   for (i = o = 0 ; i < nr ; i++) {
+      switch (in[i].ops) {
+
+      case PIPE_OP_RAST_SETUP_0:
+	 out[o] = in[i];
+	 out[o].cva_state_change = NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS;
+	 out[o].state_change = ~0;
+	 out[o].check = i810DDCheckPartialRasterSetup;
+	 out[o].run = i810DDPartialRasterSetup;
+	 o++;
+	 break;
+
+      case PIPE_OP_RAST_SETUP_0|PIPE_OP_RAST_SETUP_1:
+	 out[o] = in[i];
+	 out[o].run = i810DDDoRasterSetup;
+	 o++;
+	 break;
+
+	 /* Completely replace Mesa's fog processing to generate fog
+	  * coordinates instead of messing with colors.
+	  */
+      case PIPE_OP_FOG:
+	 out[o] = gl_fog_coord_stage;
+	 o++;
+	 break;
+
+
+      default:
+	 out[o++] = in[i];
+	 break;
+      }
+   }
+
+   return o;
+}
+
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h
new file mode 100644
index 000000000..87b95455d
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h
@@ -0,0 +1,14 @@
+#ifndef _I810_PIPELINE_H
+#define _I810_PIPELINE_H
+
+extern GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out,
+					   const struct gl_pipeline_stage *in,
+					   GLuint nr );
+
+extern GLboolean i810DDBuildPrecalcPipeline( GLcontext *ctx ); 
+
+extern void i810DDFastPath( struct vertex_buffer *VB );
+extern void i810DDFastPathInit( void );
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810ring.c b/xc/lib/GL/mesa/src/drv/i810/i810ring.c
new file mode 100644
index 000000000..2e5909e9f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810ring.c
@@ -0,0 +1,162 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
+
+#include "mm.h"
+#include "i810dd.h"
+#include "i810lib.h"
+#include "i810state.h"
+
+
+#include "i810dma.h"
+
+static void 
+I810PrintErrorState( void )
+{
+   fprintf(stderr,  "pgetbl_ctl: 0x%x pgetbl_err: 0x%x\n", 
+	   INREG(PGETBL_CTL),
+	   INREG(PGE_ERR));
+
+   fprintf(stderr,  "ipeir: %x iphdr: %x\n", 
+	   INREG(IPEIR),
+	   INREG(IPEHR));
+
+   fprintf(stderr,  "LP ring tail: %x head: %x len: %x start %x\n",
+	   INREG(LP_RING + RING_TAIL),
+	   INREG(LP_RING + RING_HEAD) & HEAD_ADDR,
+	   INREG(LP_RING + RING_LEN),
+	   INREG(LP_RING + RING_START));
+
+   fprintf(stderr,  "eir: %x esr: %x emr: %x\n",
+	   INREG16(EIR),
+	   INREG16(ESR),
+	   INREG16(EMR));
+
+   fprintf(stderr,  "instdone: %x instpm: %x\n",
+	   INREG16(INST_DONE),
+	   INREG8(INST_PM));
+
+   fprintf(stderr,  "memmode: %x instps: %x\n",
+	   INREG(MEMMODE),
+	   INREG(INST_PS));
+
+   fprintf(stderr,  "hwstam: %x ier: %x imr: %x iir: %x\n",
+	   INREG16(HWSTAM),
+	   INREG16(IER),
+	   INREG16(IMR),
+	   INREG16(IIR));
+}
+
+
+
+
+static int
+I810USec( void ) 
+{
+   struct timeval tv;
+   struct timezone tz;	
+   gettimeofday( &tv, &tz );
+   return (tv.tv_sec & 2047) * 1000000 + tv.tv_usec;
+}
+
+
+
+void
+_I810RefreshLpRing( i810ContextPtr imesa, int update )
+{
+	struct i810_ring_buffer *ring = &(i810glx.LpRing);
+	
+	ring->head = INREG(LP_RING + RING_HEAD) & HEAD_ADDR;
+	ring->tail = INREG(LP_RING + RING_TAIL);
+	ring->space = ring->head - (ring->tail+8);
+
+	if (ring->space < 0) {
+		ring->space += ring->mem.Size;
+		if (update)
+			imesa->sarea->lastWrap = ++imesa->sarea->ringAge;
+	}
+}	
+
+int
+_I810WaitLpRing( i810ContextPtr imesa, int n, int timeout_usec )
+{
+	struct i810_ring_buffer *ring = &(i810glx.LpRing);
+	int iters = 0;
+	int startTime = 0;
+	int curTime = 0;
+   
+	if (timeout_usec == 0)
+		timeout_usec = 15000000;
+
+	if (I810_DEBUG & DEBUG_VERBOSE_API)
+		fprintf(stderr, "I810WaitLpRing %d\n", n);
+
+	while (ring->space < n) 
+	{
+		int i;
+
+		ring->head = INREG(LP_RING + RING_HEAD) & HEAD_ADDR;
+		ring->space = ring->head - (ring->tail+8);
+
+		if (ring->space < 0) {
+			imesa->sarea->lastWrap = ++imesa->sarea->ringAge;
+			ring->space += ring->mem.Size;
+		}
+      
+		iters++;
+		curTime = I810USec();
+		if ( startTime == 0 || curTime < startTime /*wrap case*/) {
+			startTime = curTime;
+		} else if ( curTime - startTime > timeout_usec ) { 
+			I810PrintErrorState();
+			fprintf(stderr, "space: %d wanted %d\n", 
+				ring->space, n );
+			UNLOCK_HARDWARE(imesa);
+			exit(1);
+		}
+
+		for (i = 0 ; i < 2000 ; i++)
+			;
+	}
+
+	return iters;
+}
+
+int
+_I810Sync( i810ContextPtr imesa ) 
+{
+	int rv;
+
+	if (I810_DEBUG & DEBUG_VERBOSE_API)
+		fprintf(stderr, "I810Sync\n");
+   
+	/* Send a flush instruction and then wait till the ring is empty.
+	 * This is stronger than waiting for the blitter to finish as it also
+	 * flushes the internal graphics caches.
+	 */
+	{
+		BEGIN_LP_RING( imesa, 2 );   
+		OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH );
+		OUT_RING( 0 );		/* pad to quadword */
+		ADVANCE_LP_RING();
+	}
+
+
+	i810glx.LpRing.synced = 1;	/* ?? */
+
+	rv =  _I810WaitLpRing( imesa, i810glx.LpRing.mem.Size - 8, 0 );	
+	imesa->sarea->lastSync = ++imesa->sarea->ringAge;
+
+	return rv;
+}
+
+
+
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810span.c b/xc/lib/GL/mesa/src/drv/i810/i810span.c
new file mode 100644
index 000000000..5ea27fd84
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810span.c
@@ -0,0 +1,133 @@
+#include "types.h"
+#include "i810dd.h"
+#include "i810lib.h"
+#include "i810dma.h"
+#include "i810log.h"
+#include "i810span.h"
+
+
+#define DBG 0
+
+
+#define LOCAL_VARS					\
+   i810ContextPtr imesa = I810_CONTEXT(ctx);		\
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;	\
+   __DRIscreenPrivate *sPriv = imesa->driScreen;	\
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;	\
+   GLuint pitch = i810Screen->auxPitch;			\
+   GLuint height = dPriv->h;				\
+   char *buf = (char *)(sPriv->pFB + 			\
+			imesa->drawOffset +	\
+			dPriv->x * 2 + 			\
+			dPriv->y * pitch)
+
+#define INIT_MONO_PIXEL(p) \
+   GLushort p = I810_CONTEXT( ctx )->MonoColor;
+
+#define CLIPPIXEL(_x,_y) (_x >= minx && _x <= maxx && \
+			  _y >= miny && _y <= maxy)
+
+
+#define CLIPSPAN(_x,_y,_n,_x1,_n1,_i)				\
+	 if (_y < miny || _y >= maxy) _n1 = 0, _x1 = x;		\
+         else {							\
+            _n1 = _n;						\
+	    _x1 = _x;						\
+	    if (_x1 < minx) _i += (minx - _x1), _x1 = minx;	\
+	    if (_x1 + _n1 > maxx) n1 -= (_x1 + n1 - maxx);	\
+         }
+
+#define HW_CLIPLOOP()						\
+  do {								\
+    __DRIdrawablePrivate *dPriv = imesa->driDrawable;		\
+    int _nc = dPriv->numClipRects;				\
+    LOCK_HARDWARE(imesa);						\
+    if (!i810glx.LpRing.synced) _I810Sync( imesa );			\
+    while (_nc--) {						\
+       int minx = dPriv->pClipRects[_nc].x1 - dPriv->x;		\
+       int miny = dPriv->pClipRects[_nc].y1 - dPriv->y; 	\
+       int maxx = dPriv->pClipRects[_nc].x2 - dPriv->x;		\
+       int maxy = dPriv->pClipRects[_nc].y2 - dPriv->y;
+
+
+#define HW_ENDCLIPLOOP()			\
+    }						\
+    UNLOCK_HARDWARE(imesa);			\
+  } while (0)
+
+
+
+
+#define Y_FLIP(_y) (height - _y)
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = ( (((int)r & 0xf8) << 8) |	\
+		                             (((int)g & 0xfc) << 3) |	\
+		                             (((int)b & 0xf8) >> 3))
+#define WRITE_PIXEL( _x, _y, p )  \
+   *(GLushort *)(buf + _x*2 + _y*pitch) = p
+
+#define READ_RGBA( rgba, _x, _y )			\
+do {							\
+   GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch);	\
+   rgba[0] = (p >> 8) & 0xf8;				\
+   rgba[1] = (p >> 3) & 0xfc;				\
+   rgba[2] = (p << 3) & 0xf8;				\
+   rgba[3] = 0;			/* or 255? */		\
+} while(0)
+
+#define TAG(x) i810##x##_565
+#include "spantmp.h"
+
+
+
+
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = (((r & 0xf8) << 7) |	\
+		                            ((g & 0xf8) << 3) |		\
+                         		    ((b & 0xf8) >> 3))
+
+#define WRITE_PIXEL( _x, _y, p )  \
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = p
+
+#define READ_RGBA( rgba, _x, _y )			\
+do {							\
+   GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch);	\
+   rgba[0] = (p >> 7) & 0xf8;				\
+   rgba[1] = (p >> 3) & 0xf8;				\
+   rgba[2] = (p << 3) & 0xf8;				\
+   rgba[3] = 0;			/* or 255? */		\
+} while(0)
+
+#define TAG(x) i810##x##_555
+#include "spantmp.h"
+
+
+void i810DDInitSpanFuncs( GLcontext *ctx )
+{
+   if (1) {
+      ctx->Driver.WriteRGBASpan = i810WriteRGBASpan_565;
+      ctx->Driver.WriteRGBSpan = i810WriteRGBSpan_565;
+      ctx->Driver.WriteMonoRGBASpan = i810WriteMonoRGBASpan_565;
+      ctx->Driver.WriteRGBAPixels = i810WriteRGBAPixels_565;
+      ctx->Driver.WriteMonoRGBAPixels = i810WriteMonoRGBAPixels_565; 
+      ctx->Driver.ReadRGBASpan = i810ReadRGBASpan_565;
+      ctx->Driver.ReadRGBAPixels = i810ReadRGBAPixels_565;
+   } else {
+      ctx->Driver.WriteRGBASpan = i810WriteRGBASpan_555;
+      ctx->Driver.WriteRGBSpan = i810WriteRGBSpan_555;
+      ctx->Driver.WriteMonoRGBASpan = i810WriteMonoRGBASpan_555;
+      ctx->Driver.WriteRGBAPixels = i810WriteRGBAPixels_555;
+      ctx->Driver.WriteMonoRGBAPixels = i810WriteMonoRGBAPixels_555;
+      ctx->Driver.ReadRGBASpan = i810ReadRGBASpan_555;
+      ctx->Driver.ReadRGBAPixels = i810ReadRGBAPixels_555;
+   }
+
+   ctx->Driver.WriteCI8Span        =NULL;
+   ctx->Driver.WriteCI32Span       =NULL;
+   ctx->Driver.WriteMonoCISpan     =NULL;
+   ctx->Driver.WriteCI32Pixels     =NULL;
+   ctx->Driver.WriteMonoCIPixels   =NULL;
+   ctx->Driver.ReadCI32Span        =NULL;
+   ctx->Driver.ReadCI32Pixels      =NULL;
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810span.h b/xc/lib/GL/mesa/src/drv/i810/i810span.h
new file mode 100644
index 000000000..17a52085b
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810span.h
@@ -0,0 +1,6 @@
+#ifndef _I810_SPAN_H
+#define _I810_SPAN_H
+
+extern void i810DDInitSpanFuncs( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810state.c b/xc/lib/GL/mesa/src/drv/i810/i810state.c
new file mode 100644
index 000000000..bc3391e42
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810state.c
@@ -0,0 +1,933 @@
+
+#include <stdio.h>
+
+#include "types.h"
+#include "enums.h"
+#include "pb.h"
+#include "dd.h"
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810dd.h"
+#include "i810context.h"
+#include "i810state.h"
+#include "i810depth.h"
+#include "i810tex.h"
+#include "i810log.h"
+#include "i810vb.h"
+#include "i810tris.h"
+
+
+
+static void i810DDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   CARD32 a = (ZA_UPDATE_ALPHAFUNC|ZA_UPDATE_ALPHAREF);
+
+   switch (ctx->Color.AlphaFunc) {
+   case GL_NEVER:    a |= ZA_ALPHA_NEVER;    break;
+   case GL_LESS:     a |= ZA_ALPHA_LESS;     break;
+   case GL_GEQUAL:   a |= ZA_ALPHA_GEQUAL;   break;
+   case GL_LEQUAL:   a |= ZA_ALPHA_LEQUAL;   break;
+   case GL_GREATER:  a |= ZA_ALPHA_GREATER;  break;
+   case GL_NOTEQUAL: a |= ZA_ALPHA_NOTEQUAL; break;
+   case GL_EQUAL:    a |= ZA_ALPHA_EQUAL;    break;
+   case GL_ALWAYS:   a |= ZA_ALPHA_ALWAYS;   break;
+   default: return;
+   }
+
+   a |= ctx->Color.AlphaRef << ZA_ALPHAREF_SHIFT;
+
+   imesa->dirty |= I810_UPLOAD_CTX;
+   imesa->Setup[I810_CTXREG_ZA] &= ~(ZA_ALPHA_MASK|ZA_ALPHAREF_MASK);
+   imesa->Setup[I810_CTXREG_ZA] |= a;
+}
+
+/* This shouldn't get called, as the extension is disabled.  However,
+ * there are internal Mesa calls, and rogue use of the api which must be
+ * caught.
+ */
+static void i810DDBlendEquation(GLcontext *ctx, GLenum mode) 
+{
+   if (mode != GL_FUNC_ADD_EXT) {
+      ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
+      i810Error("Unsupported blend equation");
+      exit(1);
+   }
+}
+
+static void i810DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   GLuint a;
+
+   a = SDM_UPDATE_SRC_BLEND | SDM_UPDATE_DST_BLEND;
+
+   switch (ctx->Color.BlendSrcRGB) {
+   case GL_ZERO:                a |= SDM_SRC_ZERO; break;
+   case GL_SRC_ALPHA:           a |= SDM_SRC_SRC_ALPHA; break;
+   case GL_ONE:                 a |= SDM_SRC_ONE; break;
+   case GL_DST_COLOR:           a |= SDM_SRC_DST_COLOR; break;
+   case GL_ONE_MINUS_DST_COLOR: a |= SDM_SRC_INV_DST_COLOR; break;
+   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_SRC_INV_SRC_ALPHA; break;
+   case GL_DST_ALPHA:           a |= SDM_SRC_ONE; break;
+   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_SRC_ZERO; break;
+   case GL_SRC_ALPHA_SATURATE:      
+      a |= SDM_SRC_SRC_ALPHA;	/* use GFXRENDERSTATE_COLOR_FACTOR ??? */
+      break;
+   default: 
+      i810Error("unknown blend source func");
+      exit(1);
+      return;
+   }
+
+   switch (ctx->Color.BlendDstRGB) {
+   case GL_SRC_ALPHA:           a |= SDM_DST_SRC_ALPHA; break;
+   case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_DST_INV_SRC_ALPHA; break;
+   case GL_ZERO:                a |= SDM_DST_ZERO; break;
+   case GL_ONE:                 a |= SDM_DST_ONE; break;
+   case GL_SRC_COLOR:           a |= SDM_DST_SRC_COLOR; break;
+   case GL_ONE_MINUS_SRC_COLOR: a |= SDM_DST_INV_SRC_COLOR; break;
+   case GL_DST_ALPHA:           a |= SDM_DST_ONE; break;
+   case GL_ONE_MINUS_DST_ALPHA: a |= SDM_DST_ZERO; break;
+   default: 
+      i810Error( "unknown blend dst func");
+      exit(1);
+      return;      
+   }  
+
+   imesa->dirty |= I810_UPLOAD_CTX;
+   imesa->Setup[I810_CTXREG_SDM] &= ~(SDM_SRC_MASK|SDM_DST_MASK);
+   imesa->Setup[I810_CTXREG_SDM] |= a;
+}
+
+
+/* Shouldn't be called as the extension is disabled.
+ */
+static void i810DDBlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB, 
+				     GLenum dfactorRGB, GLenum sfactorA,
+				     GLenum dfactorA )
+{
+   if (dfactorRGB != dfactorA || sfactorRGB != sfactorA) {
+      gl_error( ctx, GL_INVALID_OPERATION, "glBlendEquation (disabled)");
+   }
+
+   i810DDBlendFunc( ctx, sfactorRGB, dfactorRGB );
+}
+
+
+
+static void i810DDDepthFunc(GLcontext *ctx, GLenum func)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   int zmode;
+
+   switch(func)  { 
+   case GL_NEVER: zmode = LCS_Z_NEVER; break;
+   case GL_ALWAYS: zmode = LCS_Z_ALWAYS; break;
+   case GL_LESS: zmode = LCS_Z_LESS; break; 
+   case GL_LEQUAL: zmode = LCS_Z_LEQUAL; break;
+   case GL_EQUAL: zmode = LCS_Z_EQUAL; break;
+   case GL_GREATER: zmode = LCS_Z_GREATER; break;
+   case GL_GEQUAL: zmode = LCS_Z_GEQUAL; break;
+   case GL_NOTEQUAL: zmode = LCS_Z_NOTEQUAL; break;
+   default: return;
+   }
+
+   imesa->Setup[I810_CTXREG_LCS] &= ~LCS_Z_MASK;
+   imesa->Setup[I810_CTXREG_LCS] |= LCS_UPDATE_ZMODE | zmode;
+   imesa->dirty |= I810_UPLOAD_CTX;
+}
+
+static void i810DDDepthMask(GLcontext *ctx, GLboolean flag)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   imesa->dirty |= I810_UPLOAD_CTX;
+   imesa->Setup[I810_CTXREG_B2] &= ~B2_ZB_WRITE_ENABLE;
+   imesa->Setup[I810_CTXREG_B2] |= B2_UPDATE_ZB_WRITE_ENABLE;
+
+   if (flag)
+     imesa->Setup[I810_CTXREG_B2] |= B2_ZB_WRITE_ENABLE;
+}
+
+
+
+
+
+
+
+
+
+
+/* =============================================================
+ * Hardware clipping
+ */
+
+
+static void i810DDScissor( GLcontext *ctx, GLint x, GLint y, 
+			  GLsizei w, GLsizei h )
+{ 
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   int x1,x2,y1,y2;
+
+   x1 = ctx->Scissor.X;
+   x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
+   y1 = dPriv->h - ctx->Scissor.Y - ctx->Scissor.Height;
+   y2 = dPriv->h - ctx->Scissor.Y - 1;
+  
+   if (x1 < 0) x1 = 0;
+   if (y1 < 0) y1 = 0;
+   if (x2 >= dPriv->w) x2 = dPriv->w-1;
+   if (y2 >= dPriv->h) y2 = dPriv->h-1;
+
+   if (x1 > x2 || y1 > y2) {
+      x1 = 0; x2 = 0;
+      y2 = 0; y1 = 1;
+   }
+
+   /* Need to push this into drawing rectangle.
+    */
+#if 0
+   imesa->Setup[I810_CTXREG_SCI0] = GFX_OP_SCISSOR_INFO;
+   imesa->Setup[I810_CTXREG_SCI1] = (y1<<16)|x1;
+   imesa->Setup[I810_CTXREG_SCI2] = (y2<<16)|x2;
+
+
+   /* Need to intersect with cliprects???
+    */
+   imesa->dirty |= I810_UPLOAD_CTX;
+#endif
+
+}
+
+
+static void i810DDDither(GLcontext *ctx, GLboolean enable)
+{
+}
+
+
+static GLboolean i810DDSetBuffer(GLcontext *ctx, GLenum mode )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+
+   fprintf(stderr, "i810DDSetBuffer %s\n", gl_lookup_enum_by_nr( mode ));
+
+   imesa->Fallback &= ~I810_FALLBACK_BUFFER;
+
+   if (mode == GL_FRONT_LEFT) 
+   {
+      imesa->drawOffset = imesa->i810Screen->fbOffset;
+      imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->fbOffset | 
+					      imesa->i810Screen->auxPitchBits);
+      imesa->dirty |= I810_UPLOAD_BUFFERS;
+      i810XMesaSetFrontClipRects( imesa );
+      return GL_TRUE;
+   } 
+   else if (mode == GL_BACK_LEFT) 
+   {
+      imesa->drawOffset = imesa->i810Screen->backOffset;
+      imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->backOffset | 
+					      imesa->i810Screen->auxPitchBits);
+      imesa->dirty |= I810_UPLOAD_BUFFERS;
+      i810XMesaSetBackClipRects( imesa );
+      return GL_TRUE;
+   }
+
+   imesa->Fallback |= I810_FALLBACK_BUFFER;
+   return GL_FALSE;
+}
+
+
+
+static void i810DDSetColor(GLcontext *ctx, 
+			   GLubyte r, GLubyte g,
+			   GLubyte b, GLubyte a )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   imesa->MonoColor = i810PackColor( imesa->i810Screen->fbFormat,
+				      r, g, b, a );
+}
+
+
+static void i810DDClearColor(GLcontext *ctx, 
+			     GLubyte r, GLubyte g,
+			     GLubyte b, GLubyte a )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   imesa->ClearColor = i810PackColor( imesa->i810Screen->fbFormat,
+				      r, g, b, a );
+}
+
+
+/* =============================================================
+ * Culling - the i810 isn't quite as clean here as the rest of
+ *           its interfaces, but it's not bad.
+ */
+static void i810DDCullFaceFrontFace(GLcontext *ctx, GLenum unused)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   GLuint mode = LCS_CULL_BOTH;
+   
+   if (ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) {
+      mode = LCS_CULL_CW;
+      if (ctx->Polygon.CullFaceMode == GL_FRONT)
+	 mode ^= (LCS_CULL_CW ^ LCS_CULL_CCW);
+      if (ctx->Polygon.FrontFace != GL_CCW)
+	 mode ^= (LCS_CULL_CW ^ LCS_CULL_CCW);
+   }
+
+   imesa->LcsCullMode = mode;
+
+   if (ctx->Polygon.CullFlag && ctx->PB->primitive == GL_POLYGON)
+   {
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK;
+      imesa->Setup[I810_CTXREG_LCS] |= (LCS_UPDATE_CULL_MODE | mode);
+   }
+}
+
+
+static void i810DDReducedPrimitiveChange( GLcontext *ctx, GLenum prim )
+{
+   if (ctx->Polygon.CullFlag) {
+      i810ContextPtr imesa = I810_CONTEXT(ctx);
+      GLuint mode = imesa->LcsCullMode;
+
+      if (ctx->PB->primitive != GL_POLYGON)
+	 mode = LCS_CULL_DISABLE;
+
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK;
+      imesa->Setup[I810_CTXREG_LCS] |= (LCS_UPDATE_CULL_MODE | mode);
+
+      LOCK_HARDWARE(imesa);
+      i810EmitHwStateLocked( imesa );	
+      UNLOCK_HARDWARE(imesa);
+   }
+}
+
+
+
+/* =============================================================
+ * Color masks
+ */
+
+/* Mesa calls this from the wrong place.
+ *
+ * Its a fallback...
+ */
+static GLboolean i810DDColorMask(GLcontext *ctx, 
+				 GLboolean r, GLboolean g, 
+				 GLboolean b, GLboolean a )
+{
+   return 1;
+}
+
+/* Seperate specular not fully implemented in hardware...  Needs
+ * some interaction with material state?  Just punt to software
+ * in all cases?
+ */
+static void i810DDLightModelfv(GLcontext *ctx, GLenum pname, 
+			      const GLfloat *param)
+{
+   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
+      I810_CONTEXT(ctx)->new_state |= I810_NEW_TEXTURE;
+   }
+}
+
+
+
+/* =============================================================
+ * Fog
+ */
+
+static void i810DDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   if (pname == GL_FOG_COLOR) {
+      GLuint color = (((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) |
+		      ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) |
+		      ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0));
+
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_FOG] = ((GFX_OP_FOG_COLOR | color) &
+				      ~FOG_RESERVED_MASK);
+   }
+}
+
+
+/* =============================================================
+ */
+
+static void i810DDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   switch(cap) {
+   case GL_ALPHA_TEST:
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_B1] &= ~B1_ALPHA_TEST_ENABLE;
+      imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_ALPHA_TEST_ENABLE;
+      if (state)
+	 imesa->Setup[I810_CTXREG_B1] |= B1_ALPHA_TEST_ENABLE;
+      break;
+   case GL_BLEND:
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_B1] &= ~B1_BLEND_ENABLE;
+      imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_BLEND_ENABLE;
+      if (state)
+	 imesa->Setup[I810_CTXREG_B1] |= B1_BLEND_ENABLE;
+      break;
+   case GL_DEPTH_TEST:
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_B1] &= ~B1_Z_TEST_ENABLE;
+      imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_Z_TEST_ENABLE;
+      if (state)
+	 imesa->Setup[I810_CTXREG_B1] |= B1_Z_TEST_ENABLE;
+      break;
+   case GL_SCISSOR_TEST:
+#if 0
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_SC] &= ~SC_ENABLE_MASK;
+      imesa->Setup[I810_CTXREG_SC] |= SC_UPDATE_SCISSOR;
+      if (state)
+	 imesa->Setup[I810_CTXREG_SC] |= SC_ENABLE;
+#endif
+      break;
+   case GL_FOG:
+      imesa->dirty |= I810_UPLOAD_CTX;
+      imesa->Setup[I810_CTXREG_B1] &= ~B1_FOG_ENABLE;
+      imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_FOG_ENABLE;
+      if (state)
+	 imesa->Setup[I810_CTXREG_B1] |= B1_FOG_ENABLE;
+      break;
+   case GL_CULL_FACE:
+      if (ctx->PB->primitive == GL_POLYGON) {
+	 imesa->dirty |= I810_UPLOAD_CTX;
+	 imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK;
+	 imesa->Setup[I810_CTXREG_LCS] |= LCS_UPDATE_CULL_MODE;
+	 if (state)
+	    imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsCullMode;
+	 else
+	    imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE;
+      }
+      break;
+   case GL_TEXTURE_2D:      
+      imesa->new_state |= I810_NEW_TEXTURE;
+      imesa->dirty |= I810_UPLOAD_CTX;
+      if (ctx->Texture.CurrentUnit == 0) {
+	 imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL0_ENABLE;
+	 imesa->Setup[I810_CTXREG_MT] |= MT_UPDATE_TEXEL0_STATE;
+	 if (state)
+	    imesa->Setup[I810_CTXREG_MT] |= MT_TEXEL0_ENABLE;
+      } else {
+	 imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL1_ENABLE;
+	 imesa->Setup[I810_CTXREG_MT] |= MT_UPDATE_TEXEL1_STATE;
+	 if (state)
+	    imesa->Setup[I810_CTXREG_MT] |= MT_TEXEL1_ENABLE;
+      }
+      break;
+   default:
+      ; 
+   }    
+}
+
+
+
+/* =============================================================
+ */
+
+/* Delightfully few possibilities:
+ */
+void i810DDPrintState( const char *msg, GLuint state )
+{
+   fprintf(stderr, "%s (0x%x): %s\n",
+	   msg,
+	   (unsigned int) state,
+	   (state & I810_NEW_TEXTURE) ? "texture, " : "");
+}
+
+void i810DDUpdateHwState( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+
+   if (imesa->new_state & I810_NEW_TEXTURE)
+      i810UpdateTextureState( ctx );
+
+   imesa->new_state = 0;
+
+   if (imesa->dirty) {
+      LOCK_HARDWARE(imesa);
+      i810EmitHwStateLocked( imesa );	
+      UNLOCK_HARDWARE(imesa);
+   }
+}
+
+
+
+/*
+ * i810DmaExecute
+ * Add a block of data to the dma buffer
+ *
+ * -- In ring buffer mode, must be called with lock held, and translates to 
+ *    OUT_RING rather than outbatch
+ *
+ * -- In dma mode, probably won't be used because state updates will have
+ *    to be done via the kernel for security...
+ */
+static void i810DmaExecute( i810ContextPtr imesa,
+			    GLuint *code, int dwords, const char *where ) 
+{	
+   if (I810_DEBUG & DEBUG_VERBOSE_RING)
+      fprintf(stderr, "i810DmaExecute (%s)\n", where);
+
+   if (dwords & 1) {
+      i810Error( "Misaligned buffer in i810DmaExecute\n" );
+      exit(1);
+   }
+
+   {
+      int i;
+      BEGIN_BATCH( imesa, dwords);
+
+      for ( i = 0 ; i < dwords ; i++ ) {
+	 if (0) fprintf(stderr, "%d: %x\n", i, code[i]);
+	 OUT_BATCH( code[i] );
+      }
+
+      ADVANCE_BATCH();
+   }
+}
+
+
+
+void i810EmitScissorValues( i810ContextPtr imesa, int nr, int emit )
+{
+   int x1 = imesa->pClipRects[nr].x1 - imesa->drawX;
+   int y1 = imesa->pClipRects[nr].y1 - imesa->drawY;
+   int x2 = imesa->pClipRects[nr].x2 - imesa->drawX;
+   int y2 = imesa->pClipRects[nr].y2 - imesa->drawY;
+
+   if (I810_DEBUG&DEBUG_VERBOSE_DRI)
+      fprintf(stderr, "i810EmitScissorValues %d,%d - %d,%d\n",
+	      x1,y1,x2,y2);
+
+   imesa->ClipSetup[I810_CLIPREG_SCI1] = (x1 | (y1 << 16));
+   imesa->ClipSetup[I810_CLIPREG_SCI2] = (x2 | (y2 << 16));
+   imesa->ClipSetup[I810_CLIPREG_SC] = ( GFX_OP_SCISSOR |
+					 SC_UPDATE_SCISSOR |
+					 SC_ENABLE );
+
+   if (emit)
+      i810DmaExecute( imesa, 
+		      imesa->ClipSetup, I810_CLIP_SETUP_SIZE, "cliprect" );
+}
+
+void i810EmitDrawingRectangle( i810ContextPtr imesa )
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+
+   int x0 = imesa->drawX;
+   int y0 = imesa->drawY;
+   int x1 = x0 + dPriv->w;
+   int y1 = y0 + dPriv->h;
+
+
+   /* Coordinate origin of the window - may be offscreen.
+    */
+   imesa->BufferSetup[I810_DESTREG_DR4] = ((y0<<16) | 
+					   (((unsigned)x0)&0xFFFF));
+
+  
+   /* Clip to screen.
+    */
+   if (x0 < 0) x0 = 0;
+   if (y0 < 0) y0 = 0;
+   if (x1 > i810Screen->width-1) x1 = i810Screen->width-1;
+   if (y1 > i810Screen->height-1) y1 = i810Screen->height-1;
+
+
+   /* Onscreen drawing rectangle.
+    *
+    * TODO: clip again to GL scissor values.
+    */
+   imesa->BufferSetup[I810_DESTREG_DR2] = ((y0<<16) | x0);
+   imesa->BufferSetup[I810_DESTREG_DR3] = ((y1<<16) | x1);
+   imesa->dirty |= I810_UPLOAD_BUFFERS;
+}
+
+
+static void i810DDPrintDirty( const char *msg, GLuint state )
+{
+   fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s%s\n",	   
+	   msg,
+	   (unsigned int) state,
+	   (state & I810_REFRESH_RING)      ? "read-lp-ring, " : "",
+	   (state & I810_REQUIRE_QUIESCENT) ? "req-quiescent, " : "",
+	   (state & I810_UPLOAD_TEX0IMAGE)  ? "upload-tex0, " : "",
+	   (state & I810_UPLOAD_TEX1IMAGE)  ? "upload-tex1, " : "",
+	   (state & I810_UPLOAD_CTX)        ? "upload-ctx, " : "",
+	   (state & I810_UPLOAD_BUFFERS)    ? "upload-bufs, " : "",
+	   (state & I810_EMIT_CLIPRECT)     ? "emit-single-cliprect, " : ""
+	   );
+}
+
+
+/* Spew the state onto the ringbuffer and/or texture memory.
+ */
+void i810EmitHwStateLocked( i810ContextPtr imesa )
+{
+   if (I810_DEBUG & DEBUG_VERBOSE_API)
+      i810DDPrintDirty( "i810EmitHwStateLocked", imesa->dirty );
+
+   if (imesa->dirty & I810_REQUIRE_QUIESCENT) {
+      i810glx.c_drawWaits += _I810Sync( imesa );
+   }
+
+   /* TODO: Refine mechanism to be equivalent to UploadSubImage
+    */
+   if ((imesa->dirty & I810_UPLOAD_TEX0IMAGE) && imesa->CurrentTexObj[0])
+      i810UploadTexImages(imesa, imesa->CurrentTexObj[0]);
+   
+   if ((imesa->dirty & I810_UPLOAD_TEX1IMAGE) && imesa->CurrentTexObj[1])
+      i810UploadTexImages(imesa, imesa->CurrentTexObj[1]);
+  
+   if ((imesa->dirty & I810_UPLOAD_CTX)) {
+      i810DmaExecute( imesa, imesa->Setup, I810_CTX_SETUP_SIZE, "context" );
+
+      if (imesa->CurrentTexObj[0])
+	 i810DmaExecute( imesa, imesa->CurrentTexObj[0]->Setup,
+			 I810_TEX_SETUP_SIZE, "tex-0");
+
+      if (imesa->CurrentTexObj[1]) 
+	 i810DmaExecute( imesa, imesa->CurrentTexObj[1]->Setup,
+			 I810_TEX_SETUP_SIZE, "tex-1");
+   }
+
+   if (imesa->dirty & I810_UPLOAD_BUFFERS) 
+      i810DmaExecute( imesa, imesa->BufferSetup, 
+		      I810_DEST_SETUP_SIZE, "buffers" );
+   
+   if (imesa->dirty & I810_EMIT_CLIPRECT)
+      i810DmaExecute( imesa, imesa->ClipSetup, 
+		      I810_CLIP_SETUP_SIZE, "cliprect" );
+
+   imesa->dirty = 0;
+}
+
+
+void i810DDInitState( i810ContextPtr imesa )
+{
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+
+   memset(imesa->Setup, 0, sizeof(imesa->Setup));
+
+   imesa->Setup[I810_CTXREG_VF] = (GFX_OP_VERTEX_FMT |
+				   VF_TEXCOORD_COUNT_2 |
+				   VF_SPEC_FOG_ENABLE |
+				   VF_RGBA_ENABLE |
+				   VF_XYZW);
+
+   imesa->Setup[I810_CTXREG_MT] = (GFX_OP_MAP_TEXELS |
+				   MT_UPDATE_TEXEL1_STATE |
+				   MT_TEXEL1_COORD1 |
+				   MT_TEXEL1_MAP1 |
+				   MT_TEXEL1_DISABLE |
+				   MT_UPDATE_TEXEL0_STATE |
+				   MT_TEXEL0_COORD0 |
+				   MT_TEXEL0_MAP0 |
+				   MT_TEXEL0_DISABLE);
+
+   imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+				     MC_STAGE_0 |
+				     MC_UPDATE_DEST |
+				     MC_DEST_CURRENT |
+				     MC_UPDATE_ARG1 |
+				     MC_ARG1_ITERATED_COLOR | 
+				     MC_ARG1_DONT_REPLICATE_ALPHA |
+				     MC_ARG1_DONT_INVERT |
+				     MC_UPDATE_ARG2 |
+				     MC_ARG2_ONE |
+				     MC_ARG2_DONT_REPLICATE_ALPHA |
+				     MC_ARG2_DONT_INVERT |
+				     MC_UPDATE_OP |
+				     MC_OP_ARG1 );
+				     
+   imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+				     MC_STAGE_1 |
+				     MC_UPDATE_DEST |
+				     MC_DEST_CURRENT |
+				     MC_UPDATE_ARG1 |
+				     MC_ARG1_ONE | 
+				     MC_ARG1_DONT_REPLICATE_ALPHA |
+				     MC_ARG1_DONT_INVERT |
+				     MC_UPDATE_ARG2 |
+				     MC_ARG2_ONE |
+				     MC_ARG2_DONT_REPLICATE_ALPHA |
+				     MC_ARG2_DONT_INVERT |
+				     MC_UPDATE_OP |
+				     MC_OP_DISABLE );
+				     
+
+   imesa->Setup[I810_CTXREG_MC2] = ( GFX_OP_MAP_COLOR_STAGES |
+				     MC_STAGE_2 |
+				     MC_UPDATE_DEST |
+				     MC_DEST_CURRENT |
+				     MC_UPDATE_ARG1 |
+				     MC_ARG1_CURRENT_COLOR | 
+				     MC_ARG1_REPLICATE_ALPHA |
+				     MC_ARG1_DONT_INVERT |
+				     MC_UPDATE_ARG2 |
+				     MC_ARG2_ONE |
+				     MC_ARG2_DONT_REPLICATE_ALPHA |
+				     MC_ARG2_DONT_INVERT |
+				     MC_UPDATE_OP |
+				     MC_OP_DISABLE );
+				     
+
+   imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+				     MA_STAGE_0 |
+				     MA_UPDATE_ARG1 |
+				     MA_ARG1_CURRENT_ALPHA |
+				     MA_ARG1_DONT_INVERT |
+				     MA_UPDATE_ARG2 |
+				     MA_ARG2_CURRENT_ALPHA |
+				     MA_ARG2_DONT_INVERT |
+				     MA_UPDATE_OP |
+				     MA_OP_ARG1 );
+
+
+   imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+				     MA_STAGE_1 |
+				     MA_UPDATE_ARG1 |
+				     MA_ARG1_CURRENT_ALPHA |
+				     MA_ARG1_DONT_INVERT |
+				     MA_UPDATE_ARG2 |
+				     MA_ARG2_CURRENT_ALPHA |
+				     MA_ARG2_DONT_INVERT |
+				     MA_UPDATE_OP |
+				     MA_OP_ARG1 );
+
+
+   imesa->Setup[I810_CTXREG_MA2] = ( GFX_OP_MAP_ALPHA_STAGES |
+				     MA_STAGE_2 |
+				     MA_UPDATE_ARG1 |
+				     MA_ARG1_CURRENT_ALPHA |
+				     MA_ARG1_DONT_INVERT |
+				     MA_UPDATE_ARG2 |
+				     MA_ARG2_CURRENT_ALPHA |
+				     MA_ARG2_DONT_INVERT |
+				     MA_UPDATE_OP |
+				     MA_OP_ARG1 );
+
+
+   imesa->Setup[I810_CTXREG_SDM] = ( GFX_OP_SRC_DEST_MONO |
+				     SDM_UPDATE_MONO_ENABLE |
+				     0 |
+				     SDM_UPDATE_SRC_BLEND | 
+				     SDM_SRC_ONE |
+				     SDM_UPDATE_DST_BLEND |
+				     SDM_DST_ZERO );
+
+   /* Use for colormask:
+    */
+   imesa->Setup[I810_CTXREG_CF0] = GFX_OP_COLOR_FACTOR;
+   imesa->Setup[I810_CTXREG_CF1] = 0xffffffff;
+
+   imesa->Setup[I810_CTXREG_ZA] = (GFX_OP_ZBIAS_ALPHAFUNC |
+				   ZA_UPDATE_ALPHAFUNC |
+				   ZA_ALPHA_ALWAYS |
+				   ZA_UPDATE_ZBIAS |
+				   0 |
+				   ZA_UPDATE_ALPHAREF |
+				   0x0);
+
+   imesa->Setup[I810_CTXREG_FOG] = (GFX_OP_FOG_COLOR | 
+				    (0xffffff & ~FOG_RESERVED_MASK));
+
+   /* Choose a pipe
+    */
+   imesa->Setup[I810_CTXREG_B1] = ( GFX_OP_BOOL_1 |
+				    B1_UPDATE_SPEC_SETUP_ENABLE |
+				    0 |
+				    B1_UPDATE_ALPHA_SETUP_ENABLE |
+				    B1_ALPHA_SETUP_ENABLE |
+				    B1_UPDATE_CI_KEY_ENABLE |
+				    0 |
+				    B1_UPDATE_CHROMAKEY_ENABLE |
+				    0 |
+				    B1_UPDATE_Z_BIAS_ENABLE |
+				    0 |
+				    B1_UPDATE_SPEC_ENABLE |
+				    0 |
+				    B1_UPDATE_FOG_ENABLE |
+				    0 |
+				    B1_UPDATE_ALPHA_TEST_ENABLE |
+				    0 |
+				    B1_UPDATE_BLEND_ENABLE |
+				    0 |
+				    B1_UPDATE_Z_TEST_ENABLE |
+				    0 );
+
+   imesa->Setup[I810_CTXREG_B2] = ( GFX_OP_BOOL_2 |
+				    B2_UPDATE_MAP_CACHE_ENABLE |
+				    B2_MAP_CACHE_ENABLE |
+				    B2_UPDATE_ALPHA_DITHER_ENABLE |
+				    0 |
+				    B2_UPDATE_FOG_DITHER_ENABLE |
+				    0 |
+				    B2_UPDATE_SPEC_DITHER_ENABLE |
+				    0 |
+				    B2_UPDATE_RGB_DITHER_ENABLE |
+				    B2_RGB_DITHER_ENABLE |
+				    B2_UPDATE_FB_WRITE_ENABLE |
+				    B2_FB_WRITE_ENABLE |
+				    B2_UPDATE_ZB_WRITE_ENABLE |
+				    B2_ZB_WRITE_ENABLE );
+
+   imesa->Setup[I810_CTXREG_LCS] = ( GFX_OP_LINEWIDTH_CULL_SHADE_MODE |
+				     LCS_UPDATE_ZMODE |
+				     LCS_Z_LESS |
+				     LCS_UPDATE_LINEWIDTH |
+				     (0x2<<LCS_LINEWIDTH_SHIFT) |
+				     LCS_UPDATE_ALPHA_INTERP |
+				     LCS_ALPHA_INTERP |
+				     LCS_UPDATE_FOG_INTERP |
+				     0 |
+				     LCS_UPDATE_SPEC_INTERP |
+				     0 |
+				     LCS_UPDATE_RGB_INTERP |
+				     LCS_RGB_INTERP |
+				     LCS_UPDATE_CULL_MODE |
+				     LCS_CULL_DISABLE);
+
+   imesa->LcsCullMode = LCS_CULL_CW;
+   
+   imesa->Setup[I810_CTXREG_PV] = ( GFX_OP_PV_RULE |
+				    PV_UPDATE_PIXRULE |
+				    PV_PIXRULE_ENABLE |
+				    PV_UPDATE_LINELIST |
+				    PV_LINELIST_PV0 |
+				    PV_UPDATE_TRIFAN |
+				    PV_TRIFAN_PV0 |
+				    PV_UPDATE_TRISTRIP |
+				    PV_TRISTRIP_PV0 );
+
+
+   imesa->Setup[I810_CTXREG_ST0] = GFX_OP_STIPPLE;
+   imesa->Setup[I810_CTXREG_ST1] = 0;
+
+
+
+   imesa->Setup[I810_CTXREG_AA] = ( GFX_OP_ANTIALIAS |
+				    AA_UPDATE_EDGEFLAG |
+				    0 |
+				    AA_UPDATE_POLYWIDTH |
+				    AA_POLYWIDTH_05 |
+				    AA_UPDATE_LINEWIDTH |
+				    AA_LINEWIDTH_05 |
+				    AA_UPDATE_BB_EXPANSION |
+				    0 |
+				    AA_UPDATE_AA_ENABLE |
+				    0 );
+
+
+
+   memset(imesa->ClipSetup, 0, sizeof(imesa->ClipSetup));
+   imesa->ClipSetup[I810_CLIPREG_SCI0] = GFX_OP_SCISSOR_INFO; 
+   imesa->ClipSetup[I810_CLIPREG_SCI1] = 0;
+   imesa->ClipSetup[I810_CLIPREG_SCI2] = 0;
+   imesa->ClipSetup[I810_CLIPREG_SC] = ( GFX_OP_SCISSOR | 
+					 SC_UPDATE_SCISSOR |
+					 0 );
+
+   /* This stuff is all invarient as long as we are using
+    * shared back and depth buffers.  
+    */
+   memset(imesa->BufferSetup, 0, sizeof(imesa->BufferSetup));
+   imesa->drawOffset = i810Screen->backOffset;
+   imesa->BufferSetup[I810_DESTREG_DI0] = CMD_OP_DESTBUFFER_INFO;
+
+   if (imesa->glCtx->Color.DriverDrawBuffer == GL_BACK_LEFT)
+      imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->backOffset | 
+					      i810Screen->auxPitchBits);
+   else
+      imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->fbOffset | 
+					      i810Screen->auxPitchBits);
+
+
+   imesa->BufferSetup[I810_DESTREG_DV0] = GFX_OP_DESTBUFFER_VARS;
+   imesa->BufferSetup[I810_DESTREG_DV1] = (DV_HORG_BIAS_OGL |
+					   DV_VORG_BIAS_OGL |
+					   i810Screen->fbFormat);
+   imesa->BufferSetup[I810_DESTREG_ZB0] = CMD_OP_Z_BUFFER_INFO;
+   imesa->BufferSetup[I810_DESTREG_ZB1] = (i810Screen->depthOffset | 
+					   i810Screen->auxPitchBits);
+
+   imesa->BufferSetup[I810_DESTREG_DR0] = GFX_OP_DRAWRECT_INFO;
+   imesa->BufferSetup[I810_DESTREG_DR1] = DR1_RECT_CLIP_ENABLE;
+}
+
+
+#define INTERESTED (~(NEW_MODELVIEW|NEW_PROJECTION|\
+                      NEW_TEXTURE_MATRIX|\
+                      NEW_USER_CLIP|NEW_CLIENT_STATE|\
+                      NEW_TEXTURE_ENABLE))
+
+void i810DDUpdateState( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+
+   if (ctx->NewState & INTERESTED) {
+      i810DDChooseRenderState(ctx);  
+      i810ChooseRasterSetupFunc(ctx);
+   }
+   
+   /* TODO: stop mesa from clobbering these.
+    */
+   ctx->Driver.PointsFunc=imesa->PointsFunc;
+   ctx->Driver.LineFunc=imesa->LineFunc;
+   ctx->Driver.TriangleFunc=imesa->TriangleFunc;
+   ctx->Driver.QuadFunc=imesa->QuadFunc;
+}
+
+
+void i810DDInitStateFuncs(GLcontext *ctx)
+{
+   ctx->Driver.UpdateState = i810DDUpdateState;
+   ctx->Driver.Enable = i810DDEnable;
+   ctx->Driver.LightModelfv = i810DDLightModelfv;
+   ctx->Driver.AlphaFunc = i810DDAlphaFunc;
+   ctx->Driver.BlendEquation = i810DDBlendEquation;
+   ctx->Driver.BlendFunc = i810DDBlendFunc;
+   ctx->Driver.BlendFuncSeparate = i810DDBlendFuncSeparate;
+   ctx->Driver.DepthFunc = i810DDDepthFunc;
+   ctx->Driver.DepthMask = i810DDDepthMask;
+   ctx->Driver.Fogfv = i810DDFogfv;
+   ctx->Driver.Scissor = i810DDScissor;
+   ctx->Driver.CullFace = i810DDCullFaceFrontFace;
+   ctx->Driver.FrontFace = i810DDCullFaceFrontFace;
+   ctx->Driver.ColorMask = i810DDColorMask;
+   ctx->Driver.ReducedPrimitiveChange = i810DDReducedPrimitiveChange;
+   ctx->Driver.RenderStart = i810DDUpdateHwState; 
+   ctx->Driver.RenderFinish = 0; 
+
+   ctx->Driver.SetBuffer = i810DDSetBuffer;
+   ctx->Driver.Color = i810DDSetColor;
+   ctx->Driver.ClearColor = i810DDClearColor;
+   ctx->Driver.Dither = i810DDDither;
+
+   ctx->Driver.Index = 0;
+   ctx->Driver.ClearIndex = 0;
+   ctx->Driver.IndexMask = 0;
+
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810state.h b/xc/lib/GL/mesa/src/drv/i810/i810state.h
new file mode 100644
index 000000000..d0551631e
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810state.h
@@ -0,0 +1,13 @@
+#ifndef _I810_STATE_H
+#define _I810_STATE_H
+
+
+extern void i810DDUpdateHwState( GLcontext *ctx );
+extern void i810DDUpdateState( GLcontext *ctx );
+extern void i810DDInitState( i810ContextPtr imesa );
+extern void i810DDInitStateFuncs( GLcontext *ctx );
+
+extern void i810DDPrintState( const char *msg, GLuint state );
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810swap.c b/xc/lib/GL/mesa/src/drv/i810/i810swap.c
new file mode 100644
index 000000000..9220ef9f4
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810swap.c
@@ -0,0 +1,259 @@
+
+
+#include "types.h"
+#include "vbrender.h"
+#include "i810log.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810dd.h"
+#include "i810dma.h"
+#include "i810state.h"
+#include "i810swap.h"
+#include "i810dma.h"
+
+/*
+ * i810BackToFront
+ *
+ * Blit the visible rectangles from the back buffer to the screen.
+ * Respects the frontbuffer cliprects, and applies the offset
+ * necessary if the backbuffer is positioned elsewhere in the screen.
+ */
+static int i810BackToFront( i810ContextPtr imesa ) 
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+
+
+   /* Use the frontbuffer cliprects:
+    */
+   XF86DRIClipRectPtr pbox = dPriv->pClipRects;
+   int nbox = dPriv->numClipRects;
+
+   if( nbox ) 
+   {
+      int i;
+      int pitch = i810Screen->auxPitch;
+
+      int dx = dPriv->auxX - dPriv->x;
+      int dy = dPriv->auxY - dPriv->y;
+      int ofs = ( i810Screen->backOffset + 
+		  dy * i810Screen->auxPitch +
+		  dx * i810Screen->cpp);
+
+      unsigned int BR13 = ((i810Screen->fbStride) |
+			   (0xCC << 16));
+
+
+      for (i=0; i < nbox; i++, pbox++) {
+	 int w = pbox->x2 - pbox->x1;
+	 int h = pbox->y2 - pbox->y1;
+
+	 int start = ofs + pbox->x1*i810Screen->cpp + pbox->y1*pitch;
+	 int dst = pbox->x1*i810Screen->cpp + pbox->y1*i810Screen->fbStride;
+	 
+	 if (I810_DEBUG&DEBUG_VERBOSE_2D) 
+	    fprintf(stderr, "i810BackToFront %d,%d-%dx%d\n",
+		    pbox->x1,pbox->y1,w,h);
+
+	 {
+	    BEGIN_BATCH( imesa, 6 );
+	    OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_SRC_COPY_BLT | 0x4 );
+	    OUT_BATCH( BR13 );	/* dest pitch, rop */
+
+	    OUT_BATCH( (h << 16) | (w * i810Screen->cpp));
+	    OUT_BATCH( dst );
+
+	    OUT_BATCH( pitch );	/* src pitch */
+	    OUT_BATCH( start );
+	    ADVANCE_BATCH();
+	 }
+      }
+   }
+  
+   return Success;   
+}
+
+
+/*
+ * ClearBox
+ *
+ * Add hardware commands to draw a filled box for the debugging
+ * display.  These are drawn into the current drawbuffer, so should
+ * work with both front and backbuffer rendering.  (However, it
+ * is only ever called on swapbuffer - ie backbuffer rendering).
+ */
+static void ClearBox( i810ContextPtr imesa,
+		      int cx, int cy, int cw, int ch, 
+		      int r, int g, int b ) 
+{
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+   i810ScreenPrivate *i810Screen = imesa->i810Screen;
+
+   int _nc = imesa->numClipRects;
+      
+   while (_nc--) {
+      int x1 = cx + dPriv->x;
+      int y1 = cy + dPriv->y;
+      int x2 = x1 + cw;
+      int y2 = y1 + ch;
+
+      if (imesa->needClip) {
+	 int rx1 = imesa->pClipRects[_nc].x1;
+	 int ry1 = imesa->pClipRects[_nc].y1;
+	 int rx2 = imesa->pClipRects[_nc].x2;
+	 int ry2 = imesa->pClipRects[_nc].y2;
+
+
+	 if (x2 < rx1) continue;
+	 if (y2 < ry1) continue;
+	 if (x1 > rx2) continue;
+	 if (y1 > ry2) continue;
+	 if (x1 < rx1) x1 = rx1;
+	 if (y1 < ry1) y1 = ry1;
+	 if (x2 > rx2) x2 = rx2;
+	 if (y2 > ry2) y2 = ry2;
+      }
+
+
+      {
+	 int start = (imesa->drawOffset + 
+		      y1 * i810Screen->auxPitch + 
+		      x1 * i810Screen->cpp);
+
+	 BEGIN_BATCH( imesa, 6 );
+   
+	 OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 );
+	 OUT_BATCH( BR13_SOLID_PATTERN | 
+		    (0xF0 << 16) |
+		    i810Screen->auxPitch );
+	 OUT_BATCH( ((y2-y1) << 16) | ((x2-x1) * i810Screen->cpp));
+	 OUT_BATCH( start );
+	 OUT_BATCH( i810PackColor( i810Screen->fbFormat, r, g, b, 0 ) );
+	 OUT_BATCH( 0 );
+
+	 if (I810_DEBUG&DEBUG_VERBOSE_2D) 
+	    fprintf(stderr, "box %d,%x %d,%d col %x (%d,%d,%d)\n", 
+		    (int)x1,(int)y1, (int)x2,(int)y2,
+		    (int)i810PackColor( i810Screen->fbFormat, r, g, b, 0 ), 
+		    (int)r, (int)g, (int)b);
+	 
+	 ADVANCE_BATCH();
+      }
+   }
+}
+
+
+/*
+ * performanceBoxes
+ * Draw some small boxesin the corner of the buffer
+ * based on some performance information
+ */
+static void i810PerformanceBoxes( i810ContextPtr imesa ) {
+	
+
+   /* draw a box to show we are active, so if it is't seen it means
+      that it is completely software based.  Purple is traditional for
+      direct rendering */
+   ClearBox( imesa, 4, 4, 8, 8, 255, 0, 255 );
+	
+   /* draw a red box if we had to wait for drawing to complete 
+      (software render or texture swap) */
+   if ( i810glx.c_drawWaits ) {
+      ClearBox( imesa, 16, 4, 8, 8, 255, 0, 0 );
+      i810glx.c_drawWaits = 0;
+   }
+	
+   /* draw a blue box if the 3d context was lost
+    */
+   if ( i810glx.c_ctxlost ) {
+      ClearBox( imesa, 28, 4, 8, 8, 0, 0, 255 );
+      i810glx.c_ctxlost = 0;
+   }
+	
+   /* draw an orange box if texture state was stomped */
+   if ( i810glx.c_texlost ) {
+      ClearBox( imesa, 40, 4, 8, 8, 255, 128, 0 );
+      i810glx.c_texlost = 0;
+   }
+
+   /* draw a yellow box if textures were swapped */
+   if ( i810glx.c_textureSwaps ) {
+      ClearBox( imesa, 56, 4, 8, 8, 255, 255, 0 );
+      i810glx.c_textureSwaps = 0;
+   }
+		
+   /* draw a green box if we had to wait for dma to complete (full utilization) 
+      on the previous frame */
+   if ( !i810glx.hardwareWentIdle ) {
+      ClearBox( imesa, 72, 4, 8, 8, 0, 255, 0 );
+   }
+   i810glx.hardwareWentIdle = 0;
+	
+#if 0
+   /* show buffer utilization */
+   if ( i810glx.c_dmaFlush > 1 ) {
+      /* draw a solid bar if we flushed more than one buffer */
+      ClearBox( imesa, 4, 16, 252, 4, 255, 32, 32 );
+   } else {
+      /* draw bars to represent the utilization of primary and
+         secondary buffers */
+      ClearBox( imesa, 4, 16, 252, 4, 32, 32, 32 );
+      t = i810glx.dma_buffer->mem.Size;
+      w = 252 * i810glx.dma_buffer->head / t;
+      if ( w < 1 ) {
+	 w = 1;
+      }
+      ClearBox( imesa, 4, 16, w, 4, 196, 128, 128 );
+   }
+#endif
+
+   i810glx.c_dmaFlush = 0;
+}
+
+
+static void i810SendDmaFlush( i810ContextPtr imesa )
+{
+   BEGIN_BATCH( imesa, 2 );
+   OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH );
+   OUT_BATCH( 0 );
+   ADVANCE_BATCH();
+}
+
+void i810SwapBuffers( i810ContextPtr imesa )
+{
+   if (I810_DEBUG & DEBUG_VERBOSE_API)
+      fprintf(stderr, "i810SwapBuffers()\n");
+
+   LOCK_HARDWARE( imesa );
+   i810SendDmaFlush( imesa );
+   if ( i810glx.boxes )  
+      i810PerformanceBoxes( imesa );
+   i810BackToFront( imesa );
+
+   /* Check if we are emitting thousands of tiny frames, and if so
+    * throttle them.  Would be better to simply go to sleep until
+    * our stuff had cleared, rather than polling.  A dma solution
+    * should provide for this.
+    */   
+   if (imesa->lastSwap >= imesa->sarea->lastWrap &&
+       imesa->lastSwap >= imesa->sarea->lastSync) {
+
+      if (I810_DEBUG & DEBUG_VERBOSE_API)
+	 fprintf(stderr, ".");
+
+      _I810Sync( imesa );
+   }
+
+   imesa->lastSwap = imesa->sarea->lastSync;
+   if (imesa->sarea->lastWrap > imesa->lastSwap) 
+      imesa->lastSwap = imesa->sarea->lastWrap;
+      
+   
+   UNLOCK_HARDWARE( imesa );
+
+/*     XSync(imesa->display, 0); */
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810swap.h b/xc/lib/GL/mesa/src/drv/i810/i810swap.h
new file mode 100644
index 000000000..1657a717d
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810swap.h
@@ -0,0 +1,6 @@
+#ifndef I810_SWAP_H
+#define I810_SWAP_H
+
+extern void i810SwapBuffers( i810ContextPtr imesa );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tex.c b/xc/lib/GL/mesa/src/drv/i810/i810tex.c
new file mode 100644
index 000000000..039c0af59
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810tex.c
@@ -0,0 +1,1247 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdlib.h>
+#include <stdio.h>
+
+#include <GL/gl.h>
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810tex.h"
+#include "i810log.h"
+#include "simple_list.h"
+#include "enums.h"
+
+static void i810SetTexWrapping(i810TextureObjectPtr tex, GLenum s, GLenum t)
+{
+   unsigned int val = tex->Setup[I810_TEXREG_MCS];
+
+   val &= ~(MCS_U_STATE_MASK|MCS_V_STATE_MASK);
+   val |= (MCS_U_WRAP|MCS_V_WRAP);
+   
+   if (s != GL_REPEAT) 
+      val ^= (MCS_U_WRAP^MCS_U_CLAMP);
+
+   if (t != GL_REPEAT) 
+      val ^= (MCS_V_WRAP^MCS_V_CLAMP);
+
+   tex->Setup[I810_TEXREG_MCS] = val;
+}
+
+static void i810SetTexFilter(i810TextureObjectPtr t, GLenum minf, GLenum magf)
+{
+   GLuint LastLevel;
+
+   switch (minf) {
+   case GL_NEAREST:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_NEAREST | MF_MIP_NONE);
+      break;
+   case GL_LINEAR:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_LINEAR | MF_MIP_NONE);
+      break;
+   case GL_NEAREST_MIPMAP_NEAREST:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_NEAREST | MF_MIP_NEAREST);
+      break;
+   case GL_LINEAR_MIPMAP_NEAREST:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_LINEAR | MF_MIP_NEAREST);
+      break;
+   case GL_NEAREST_MIPMAP_LINEAR:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_NEAREST | MF_MIP_DITHER );
+      break;
+   case GL_LINEAR_MIPMAP_LINEAR:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MIN_MASK | MF_MIP_MASK,
+		     MF_MIN_LINEAR  | MF_MIP_DITHER );
+      break;
+   default:
+      i810Error("i810SetTexFilter(): not supported min. filter %d\n",(int)minf);
+      break;
+   }
+
+   switch (magf) {
+   case GL_NEAREST:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MAG_MASK,MF_MAG_NEAREST);
+      break;
+   case GL_LINEAR:
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MF],
+		     MF_MAG_MASK,MF_MAG_LINEAR);
+      break;
+   default:
+      i810Error("i810SetTexFilter(): not supported mag. filter %d\n",(int)magf);
+      break;
+   }
+  
+
+   if (t->globj->MinFilter != GL_NEAREST && 
+       t->globj->MinFilter != GL_LINEAR) {
+      LastLevel = t->max_level;
+   } else {
+      LastLevel = t->min_level;
+   }
+
+   I810_SET_FIELD(t->Setup[I810_TEXREG_MLL],
+		  MLL_MAX_MIP_MASK,
+		  (t->min_level << (MLL_MAX_MIP_SHIFT+4)));
+
+   I810_SET_FIELD(t->Setup[I810_TEXREG_MLL],
+		  MLL_MIN_MIP_MASK,
+		  (LastLevel << MLL_MIN_MIP_SHIFT));
+
+   /* See OpenGL 1.2 specification */
+   if (magf == GL_LINEAR && (minf == GL_NEAREST_MIPMAP_NEAREST || 
+			     minf == GL_NEAREST_MIPMAP_LINEAR))
+   {
+      /* c = 0.5 */
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MLC],
+		     MLC_LOD_BIAS_MASK,
+		     0x10);
+   } else {
+      /* c = 0 */
+      I810_SET_FIELD(t->Setup[I810_TEXREG_MLC],
+		     MLC_LOD_BIAS_MASK,
+		     0x0);
+   }
+}
+
+
+/* Need a fallback ?
+ */
+static void i810SetTexBorderColor(i810TextureObjectPtr t, GLubyte color[4])
+{
+/*    t->Setup[I810_TEXREG_TEXBORDERCOL] =  */
+/*      I810PACKCOLOR8888(color[0],color[1],color[2],color[3]); */
+}
+
+
+
+static void ReplicateMesaTexState(i810TextureObjectPtr t,
+                                  struct gl_texture_object *mesatex)
+{
+   i810SetTexWrapping(t,mesatex->WrapS,mesatex->WrapT);
+   i810SetTexFilter(t,mesatex->MinFilter,mesatex->MagFilter);
+   i810SetTexBorderColor(t,mesatex->BorderColor);
+}
+
+static i810TextureObjectPtr i810CreateTexObj(i810ContextPtr imesa,
+					     struct gl_texture_object *tObj)
+{
+   i810TextureObjectPtr t;
+   GLuint height, width, pitch, i, textureFormat, log_pitch;
+   struct gl_texture_image *image;
+
+   image = tObj->Image[ 0 ];
+   if ( !image ) {
+      fprintf(stderr, "no image at level zero - not creating texobj\n");
+      return 0;
+   }
+   
+   t = (i810TextureObjectPtr) calloc(1,sizeof(*t));
+   if (!t)
+      return 0;
+
+   switch( image->Format ) {
+   case GL_RGB:
+   case GL_LUMINANCE:
+   case GL_ALPHA:
+      t->texelBytes = 2;
+      textureFormat = MI1_FMT_16BPP | MI1_PF_16BPP_RGB565;
+      break;
+   case GL_LUMINANCE_ALPHA:
+   case GL_INTENSITY:
+   case GL_RGBA:
+      t->texelBytes = 2;
+      textureFormat = MI1_FMT_16BPP | MI1_PF_16BPP_ARGB4444;
+      break;
+   case GL_COLOR_INDEX:
+      textureFormat = MI1_FMT_8CI | MI1_PF_8CI_ARGB4444;
+      t->texelBytes = 1;
+      break;
+   default:
+      i810Error( "i810CreateTexObj: bad image->Format\n" );
+      free( t );      
+      return 0;	
+   }
+
+
+   /* Figure out the size now (and count the levels).  Upload won't be done
+    * until later.
+    */ 
+   width = image->Width * t->texelBytes;
+   for (pitch = 32, log_pitch=2 ; pitch < width ; pitch *= 2 )
+      log_pitch++;
+   
+   t->dirty_images = 0;
+   
+   for ( height = i = 0 ; i < I810_TEX_MAXLEVELS && tObj->Image[i] ; i++ ) {
+      t->image[i].image = tObj->Image[i];
+      t->image[i].offset = height * pitch;
+      t->image[i].internalFormat = image->Format;
+      t->dirty_images |= (1<<i);
+      height += t->image[i].image->Height;
+   }
+
+   t->Pitch = pitch;
+   t->totalSize = height*pitch;
+   t->max_level = i-1;
+   t->min_level = 0;
+   t->globj = tObj;
+   t->age = 0;
+
+   t->Setup[I810_TEXREG_MI0] = GFX_OP_MAP_INFO;
+
+   t->Setup[I810_TEXREG_MI1] = (MI1_MAP_0 |
+				textureFormat |
+				log_pitch);			 
+
+   t->Setup[I810_TEXREG_MI2] = (MI2_DIMENSIONS_ARE_LOG2 |
+				(image->HeightLog2 << 16) |
+				(image->WidthLog2));
+
+   t->Setup[I810_TEXREG_MI3] = 0;
+  
+   t->Setup[I810_TEXREG_MLC] = (GFX_OP_MAP_LOD_CTL | 
+				MLC_MAP_0 |
+				MLC_DITHER_WEIGHT_FULL |
+				MLC_UPDATE_LOD_BIAS |
+				0x0);
+
+   t->Setup[I810_TEXREG_MLL] = (GFX_OP_MAP_LOD_LIMITS |
+				MLL_MAP_0  |
+				MLL_UPDATE_MAX_MIP | 
+				(t->min_level << MLL_MAX_MIP_SHIFT) |
+				MLL_UPDATE_MIN_MIP |
+				t->max_level);
+
+   /* I think this is context state, really.
+    */
+   t->Setup[I810_TEXREG_MCS] = (GFX_OP_MAP_COORD_SETS |
+				MCS_COORD_0 |
+				MCS_UPDATE_NORMALIZED |
+				MCS_NORMALIZED_COORDS |
+				MCS_UPDATE_V_STATE |
+				MCS_V_WRAP |
+				MCS_UPDATE_U_STATE |
+				MCS_U_WRAP);
+
+   t->Setup[I810_TEXREG_MF] = (GFX_OP_MAP_FILTER |
+			       MF_MAP_0 |
+			       MF_UPDATE_ANISOTROPIC |
+			       0 |
+			       MF_UPDATE_MIP_FILTER |
+			       MF_MIP_NEAREST |
+			       MF_UPDATE_MAG_FILTER |
+			       MF_MAG_NEAREST |
+			       MF_UPDATE_MIN_FILTER |
+			       MF_MIN_NEAREST);
+
+   t->current_unit = 0;
+
+   ReplicateMesaTexState(t,tObj);
+   tObj->DriverData = t;
+   imesa->dirty |= I810_UPLOAD_CTX;
+   make_empty_list( t );
+   return t;
+}
+
+void i810DestroyTexObj(i810ContextPtr imesa, i810TextureObjectPtr t)
+{
+   int i;
+   if (!t) return;
+
+   /* This is sad - need to sync *in case* we upload a texture
+    * to this newly free memory...
+    */
+   if (t->MemBlock) {
+      imesa->dirty |= I810_REQUIRE_QUIESCENT;
+      mmFreeMem(t->MemBlock);
+      t->MemBlock = 0;      
+   }
+
+   if (t->globj)
+      t->globj->DriverData = 0;
+
+   for ( i = 0 ; i < 2 ; i++ ) 
+      if ( imesa->CurrentTexObj[i] == t ) 
+	 imesa->CurrentTexObj[i] = 0;
+
+   remove_from_list(t);
+   free(t);
+}
+
+
+static void i810SwapOutTexObj(i810ContextPtr imesa, i810TextureObjectPtr t)
+{
+   if (t->MemBlock) {
+      imesa->dirty |= I810_REQUIRE_QUIESCENT;
+      mmFreeMem(t->MemBlock);
+      t->MemBlock = 0;      
+   }
+
+   t->dirty_images = ~0;
+   move_to_tail(&(imesa->SwappedOut), t);
+}
+
+
+
+/* Upload an image from mesa's internal copy.
+ */
+static void i810UploadTexLevel( i810TextureObjectPtr t, int level )
+{
+   const struct gl_texture_image *image = t->image[level].image;
+   int i,j;
+
+   if (I810_DEBUG & DEBUG_VERBOSE_LRU)
+      fprintf(stderr, "i810UploadTexLevel %d, BufAddr %p offset %x\n",
+	      level, t->BufAddr, t->image[level].offset);
+
+   /* Need triangle (rather than pixel) fallbacks to simulate this using
+    * normal textured triangles.
+    *
+    * DO THIS IN DRIVER STATE MANAGMENT, not hardware state.
+    *
+   if (image->Border != 0) 
+      i810Error("Not supported texture border %d.\n", (int) image->Border);
+    */
+
+   switch (t->image[level].internalFormat) {
+   case GL_RGB:
+   {
+      GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset);
+      GLubyte  *src = (GLubyte *)image->Data;
+      i810Msg(10,"  CopyRGB: %p %p\n", dst, src);      
+
+      for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
+	 for (i = 0 ; i < image->Width ; i++) {
+	    dst[i] = I810PACKCOLOR565(src[0],src[1],src[2]);
+	    src += 3;
+	 }
+      }
+   }
+   break;
+      
+   case GL_RGBA:
+   {
+      GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset);
+      GLubyte  *src = (GLubyte *)image->Data;
+      i810Msg(10,"  CopyRGBA: %p %p\n", dst, src);      
+
+      for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
+	 for (i = 0 ; i < image->Width ; i++) {
+	    dst[i] = I810PACKCOLOR4444(src[0],src[1],src[2],src[3]);
+	    src += 4;
+	 }
+      }
+   }
+   break;
+      
+   case GL_LUMINANCE:
+   {
+      GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset);
+      GLubyte  *src = (GLubyte *)image->Data;
+      i810Msg(10,"  CopyL: %p %p\n", dst, src);      
+
+      for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
+	 for (i = 0 ; i < image->Width ; i++) {
+	    dst[i] = I810PACKCOLOR565(src[0],src[0],src[0]);
+	    src ++;
+	 }
+      }
+   }
+   break;
+
+   case GL_INTENSITY:
+   {
+      GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset);
+      GLubyte  *src = (GLubyte *)image->Data;
+      int i;
+      i810Msg(10,"  CopyI: %p %p\n", dst, src);      
+
+      for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
+	 for (i = 0 ; i < image->Width ; i++) {
+	    dst[i] = I810PACKCOLOR4444(src[0],src[0],src[0],src[0]);
+	    src ++;
+	 }
+      }
+   }
+   break;
+      
+   case GL_LUMINANCE_ALPHA:
+   {
+      GLushort *dst = (GLushort *)(t->BufAddr + t->image[level].offset);
+      GLubyte  *src = (GLubyte *)image->Data;
+      i810Msg(10,"  CopyLA: %p %p\n", dst, src);      
+
+      for (j = 0 ; j < image->Height ; j++, dst += (t->Pitch/2)) {
+	 for (i = 0 ; i < image->Width ; i++) {
+	    dst[i] = I810PACKCOLOR4444(src[0],src[0],src[0],src[1]);
+	    src += 2;
+	 }
+      }
+   }
+   break;
+
+   /* TODO: Translate color indices *now*:
+    */
+   case GL_COLOR_INDEX:
+      {
+	 GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[level].offset);
+	 GLubyte *src = (GLubyte *)image->Data;
+	 i810Msg(10,"  CopyIndex  %p %p\n", dst, src);      
+
+	 for (j = 0 ; j < image->Height ; j++, dst += t->Pitch) {
+	    for (i = 0 ; i < image->Width ; i++) {
+	       dst[i] = src[0];
+	       src += 1;
+	    }
+	 }
+      }
+   break;
+      
+   default:
+      i810Error("Not supported texture format %d\n",(int)image->Format);
+      exit(1);
+   }
+}
+
+
+
+void i810PrintLocalLRU( i810ContextPtr imesa ) 
+{
+   i810TextureObjectPtr t;
+   int sz = 1 << (imesa->i810Screen->logTextureGranularity);
+
+   foreach( t, &imesa->TexObjList ) {
+      if (!t->globj)
+	 fprintf(stderr, "Placeholder %d at %x sz %x\n", 
+		 t->MemBlock->ofs / sz,
+		 t->MemBlock->ofs,
+		 t->MemBlock->size);      
+   }
+}
+
+void i810PrintGlobalLRU( i810ContextPtr imesa )
+{
+   int i, j;
+   i810TexRegion *list = imesa->sarea->texList;
+
+   for (i = 0, j = I810_NR_TEX_REGIONS ; i < I810_NR_TEX_REGIONS ; i++) {
+      fprintf(stderr, "list[%d] age %d next %d prev %d\n",
+	      j, list[j].age, list[j].next, list[j].prev);
+      j = list[j].next;
+      if (j == I810_NR_TEX_REGIONS) break;
+   }
+   
+   if (j != I810_NR_TEX_REGIONS)
+      fprintf(stderr, "Loop detected in global LRU\n");
+}
+
+
+void i810ResetGlobalLRU( i810ContextPtr imesa )
+{
+   i810TexRegion *list = imesa->sarea->texList;
+   int sz = 1 << imesa->i810Screen->logTextureGranularity;
+   int i;
+
+   /* (Re)initialize the global circular LRU list.  The last element
+    * in the array (I810_NR_TEX_REGIONS) is the sentinal.  Keeping it
+    * at the end of the array allows it to be addressed rationally
+    * when looking up objects at a particular location in texture
+    * memory.  
+    */
+   for (i = 0 ; (i+1) * sz < imesa->i810Screen->textureSize ; i++) {
+      list[i].prev = i-1;
+      list[i].next = i+1;
+      list[i].age = 0;
+   }
+
+   i--;
+   list[0].prev = I810_NR_TEX_REGIONS;
+   list[i].prev = i-1;
+   list[i].next = I810_NR_TEX_REGIONS;
+   list[I810_NR_TEX_REGIONS].prev = i;
+   list[I810_NR_TEX_REGIONS].next = 0;
+   imesa->sarea->texAge = 0;
+}
+
+
+static void i810UpdateTexLRU( i810ContextPtr imesa, i810TextureObjectPtr t ) 
+{
+   int i;
+   int logsz = imesa->i810Screen->logTextureGranularity;
+   int start = t->MemBlock->ofs >> logsz;
+   int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz;
+   i810TexRegion *list = imesa->sarea->texList;
+   
+   imesa->texAge = ++imesa->sarea->texAge;
+
+   /* Update our local LRU
+    */
+   move_to_head( &(imesa->TexObjList), t );
+
+   /* Update the global LRU
+    */
+   for (i = start ; i <= end ; i++) {
+
+      list[i].in_use = 1;
+      list[i].age = imesa->texAge;
+
+      /* remove_from_list(i)
+       */
+      list[(unsigned)list[i].next].prev = list[i].prev;
+      list[(unsigned)list[i].prev].next = list[i].next;
+      
+      /* insert_at_head(list, i)
+       */
+      list[i].prev = I810_NR_TEX_REGIONS;
+      list[i].next = list[I810_NR_TEX_REGIONS].next;
+      list[(unsigned)list[I810_NR_TEX_REGIONS].next].prev = i;
+      list[I810_NR_TEX_REGIONS].next = i;
+   }
+}
+
+
+/* Called for every shared texture region which has increased in age
+ * since we last held the lock.
+ *
+ * Figures out which of our textures have been ejected by other clients,
+ * and pushes a placeholder texture onto the LRU list to represent 
+ * the other client's textures.  
+ */
+void i810TexturesGone( i810ContextPtr imesa,
+		       GLuint offset, 
+		       GLuint size,
+		       GLuint in_use ) 
+{
+   i810TextureObjectPtr t, tmp;
+   
+   foreach_s ( t, tmp, &imesa->TexObjList ) {
+
+      if (t->MemBlock->ofs >= offset + size ||
+	  t->MemBlock->ofs + t->MemBlock->size <= offset)
+	 continue;
+
+      /* It overlaps - kick it off.  Need to hold onto the currently bound
+       * objects, however.
+       */
+      if (t == imesa->CurrentTexObj[0] || t == imesa->CurrentTexObj[1]) 
+	 i810SwapOutTexObj( imesa, t );
+      else
+	 i810DestroyTexObj( imesa, t );
+   }
+
+   
+   if (in_use) {
+      t = (i810TextureObjectPtr) calloc(1,sizeof(*t));
+      if (!t) return;
+
+      t->MemBlock = mmAllocMem( imesa->texHeap, size, 0, offset);      
+      insert_at_head( &imesa->TexObjList, t );
+   }
+}
+
+
+
+
+
+/* This is called with the lock held.  May have to eject our own and/or
+ * other client's texture objects to make room for the upload.
+ */
+int i810UploadTexImages( i810ContextPtr imesa, i810TextureObjectPtr t )
+{
+   int i;
+   int ofs;
+   i810glx.c_textureSwaps++;
+
+   /* Do we need to eject LRU texture objects?
+    */
+   if (!t->MemBlock) {
+      while (1)
+      {
+	 t->MemBlock = mmAllocMem( imesa->texHeap, t->totalSize, 12, 0 ); 
+	 if (t->MemBlock)
+	    break;
+
+	 if (imesa->TexObjList.prev == &(imesa->TexObjList)) {
+	    fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize);
+	    mmDumpMemInfo( imesa->texHeap );
+	    return -1;
+	 }
+
+	 i810DestroyTexObj( imesa, imesa->TexObjList.prev );
+      }
+ 
+      ofs = t->MemBlock->ofs;
+      t->Setup[I810_TEXREG_MI3] = imesa->i810Screen->textureOffset + ofs;
+      t->BufAddr = i810glx.texVirtual + ofs;
+      imesa->dirty |= I810_UPLOAD_CTX;
+   }
+
+   /* Let the world know we've used this memory recently.
+    */
+   i810UpdateTexLRU( imesa, t );
+
+   if (t->dirty_images) {
+      if (I810_DEBUG & DEBUG_VERBOSE_LRU)
+	 fprintf(stderr, "*");
+
+      for (i = t->min_level ; i <= t->max_level ; i++)
+	 if (t->dirty_images & (1<<i)) 
+	    i810UploadTexLevel( t, i );
+   }
+
+
+   t->dirty_images = 0;
+   return 0;
+}
+
+static void i810TexSetUnit( i810TextureObjectPtr t, GLuint unit )
+{
+   if (t->current_unit == unit) return;
+
+   t->Setup[I810_TEXREG_MI1] ^= (MI1_MAP_0 ^ MI1_MAP_1);
+   t->Setup[I810_TEXREG_MLC] ^= (MLC_MAP_0 ^ MLC_MAP_1);
+   t->Setup[I810_TEXREG_MLL] ^= (MLL_MAP_0 ^ MLL_MAP_1);
+   t->Setup[I810_TEXREG_MCS] ^= (MCS_COORD_0 ^ MCS_COORD_1);
+   t->Setup[I810_TEXREG_MF]  ^= (MF_MAP_0 ^ MF_MAP_1);
+
+   t->current_unit = unit;
+}
+
+
+
+
+static void i810UpdateTex0State( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   struct gl_texture_object	*tObj;
+   i810TextureObjectPtr t;
+   int ma_modulate_op;
+
+
+   tObj = ctx->Texture.Unit[0].Current;
+
+   if ( tObj != ctx->Texture.Unit[0].CurrentD[2] ) 
+      tObj = 0;
+
+
+   imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+				     MC_STAGE_0 |
+				     MC_UPDATE_DEST |
+				     MC_DEST_CURRENT |
+				     MC_UPDATE_ARG1 |
+				     MC_ARG1_ITERATED_COLOR | 
+				     MC_UPDATE_ARG2 |
+				     MC_ARG2_ONE |
+				     MC_UPDATE_OP |
+				     MC_OP_ARG1 );
+
+   imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+				     MA_STAGE_0 |
+				     MA_UPDATE_ARG1 |
+				     MA_ARG1_ITERATED_ALPHA |
+				     MA_UPDATE_ARG2 |
+				     MA_ARG2_TEX0_ALPHA |
+				     MA_UPDATE_OP |
+				     MA_OP_ARG1 );
+    
+
+   if (!(ctx->Texture.Enabled & 0xf) || !tObj || !tObj->Complete) {
+      return;
+   }
+
+   t = tObj->DriverData;
+  
+   if (!t) {
+      t = i810CreateTexObj( imesa, tObj );
+      if (!t) return;
+   }
+
+   if (t->current_unit != 0)
+      i810TexSetUnit( t, 0 );
+    
+   if (t->dirty_images) 
+      imesa->dirty |= I810_UPLOAD_TEX0IMAGE;
+
+   imesa->CurrentTexObj[0] = t;
+  
+   switch (ctx->Texture.Unit[0].EnvMode) {
+      case GL_REPLACE:
+      imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_0 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX0_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_ONE |
+					MC_UPDATE_OP |
+					MC_OP_ARG1 );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 ma_modulate_op = MA_OP_ARG1;
+      } else {
+	 ma_modulate_op = MA_OP_ARG2;
+      }
+
+      imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_0 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_ITERATED_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX0_ALPHA |
+					MA_UPDATE_OP |
+					ma_modulate_op );
+      break;
+   case GL_MODULATE:
+      imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_0 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX0_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_ITERATED_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_MODULATE );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 ma_modulate_op = MA_OP_ARG1;
+      } else {
+	 ma_modulate_op = MA_OP_MODULATE;
+      }
+	
+      imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_0 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_ITERATED_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX0_ALPHA |
+					MA_UPDATE_OP |
+					MA_OP_MODULATE );
+      break;
+
+   case GL_ADD:
+      imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_0 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX0_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_ITERATED_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_ADD );
+
+      imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_0 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_ITERATED_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX0_ALPHA |
+					MA_UPDATE_OP |
+					MA_OP_ADD );
+      break;
+
+   case GL_DECAL:
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					   MC_STAGE_0 |
+					   MC_UPDATE_DEST |
+					   MC_DEST_CURRENT |
+					   MC_UPDATE_ARG1 |
+					   MC_ARG1_COLOR_FACTOR | 
+					   MC_UPDATE_ARG2 |
+					   MC_ARG2_TEX0_COLOR |
+					   MC_UPDATE_OP |
+					   MC_OP_ARG2 );
+
+      } else {
+	 imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					   MC_STAGE_0 |
+					   MC_UPDATE_DEST |
+					   MC_DEST_CURRENT |
+					   MC_UPDATE_ARG1 |
+					   MC_ARG1_COLOR_FACTOR | 
+					   MC_UPDATE_ARG2 |
+					   MC_ARG2_TEX0_COLOR |
+					   MC_UPDATE_OP |
+					   MC_OP_LIN_BLEND_TEX0_ALPHA );
+      }
+
+      imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_0 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_ALPHA_FACTOR |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_ALPHA_FACTOR |
+					MA_UPDATE_OP |
+					MA_OP_ARG1 );
+      break;
+   case GL_BLEND:
+      imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_0 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_COLOR_FACTOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_ITERATED_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_LIN_BLEND_TEX0_COLOR );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					   MA_STAGE_0 |
+					   MA_UPDATE_ARG1 |
+					   MA_ARG1_ALPHA_FACTOR |
+					   MA_UPDATE_ARG2 |
+					   MA_ARG2_ITERATED_ALPHA |
+					   MA_UPDATE_OP |
+					   MA_OP_ARG1 );
+      } else {
+	 imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
+					   MA_STAGE_0 |
+					   MA_UPDATE_ARG1 |
+					   MA_ARG1_ALPHA_FACTOR |
+					   MA_UPDATE_ARG2 |
+					   MA_ARG2_ITERATED_ALPHA |
+					   MA_UPDATE_OP |
+					   MA_OP_LIN_BLEND_TEX0_ALPHA );
+      }
+      break;
+
+   default:
+      fprintf(stderr, "unknown tex env mode");
+      exit(1);
+      break;			
+   }
+}
+
+
+
+static void i810UpdateTex1State( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   struct gl_texture_object	*tObj;
+   i810TextureObjectPtr t;
+   int ma_modulate_op;
+
+
+   tObj = ctx->Texture.Unit[1].Current;
+
+   if ( tObj != ctx->Texture.Unit[1].CurrentD[2] ) 
+      tObj = 0;
+
+
+   imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+				     MC_STAGE_1 |
+				     MC_UPDATE_DEST |
+				     MC_DEST_CURRENT |
+				     MC_UPDATE_ARG1 |
+				     MC_ARG1_ONE | 
+				     MC_ARG1_DONT_REPLICATE_ALPHA |
+				     MC_ARG1_DONT_INVERT |
+				     MC_UPDATE_ARG2 |
+				     MC_ARG2_ONE |
+				     MC_ARG2_DONT_REPLICATE_ALPHA |
+				     MC_ARG2_DONT_INVERT |
+				     MC_UPDATE_OP |
+				     MC_OP_DISABLE );
+
+   imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+				     MA_STAGE_1 |
+				     MA_UPDATE_ARG1 |
+				     MA_ARG1_CURRENT_ALPHA |
+				     MA_ARG1_DONT_INVERT |
+				     MA_UPDATE_ARG2 |
+				     MA_ARG2_CURRENT_ALPHA |
+				     MA_ARG2_DONT_INVERT |
+				     MA_UPDATE_OP |
+				     MA_OP_ARG1 );
+
+   if (!(ctx->Texture.Enabled & 0xf0) || !tObj || !tObj->Complete) {
+      return;
+   }
+
+   t = tObj->DriverData;
+  
+   if (!t) {
+      t = i810CreateTexObj( imesa, tObj );
+      if (!t) return;
+   }
+    
+   if (t->current_unit != 1)
+      i810TexSetUnit( t, 1 );
+
+   if (t->dirty_images) 
+      imesa->dirty |= I810_UPLOAD_TEX1IMAGE;
+
+   imesa->CurrentTexObj[1] = t;
+
+
+   switch (ctx->Texture.Unit[1].EnvMode) {
+   case GL_REPLACE:
+      imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_1 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX1_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_ONE |
+					MC_UPDATE_OP |
+					MC_OP_ARG1 );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 ma_modulate_op = MA_OP_ARG1;
+      } else {
+	 ma_modulate_op = MA_OP_ARG2;
+      }
+
+      imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_1 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_CURRENT_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX1_ALPHA |
+					MA_UPDATE_OP |
+					ma_modulate_op );
+      break;
+   case GL_MODULATE:
+      imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_1 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX1_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_CURRENT_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_MODULATE );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 ma_modulate_op = MA_OP_ARG1;
+      } else {
+	 ma_modulate_op = MA_OP_MODULATE;
+      }
+	
+      imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_1 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_CURRENT_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX1_ALPHA |
+					MA_UPDATE_OP |
+					ma_modulate_op );
+      break;
+
+   case GL_ADD:
+      imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_1 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_TEX1_COLOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_CURRENT_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_ADD );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 ma_modulate_op = MA_OP_ARG1;
+      } else {
+	 ma_modulate_op = MA_OP_ADD;
+      }
+	
+      imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_1 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_CURRENT_ALPHA |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_TEX1_ALPHA |
+					MA_UPDATE_OP |
+					ma_modulate_op );
+      break;
+
+
+   case GL_DECAL:
+      if (t->image[0].internalFormat == GL_RGB) {
+	 imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					   MC_STAGE_1 |
+					   MC_UPDATE_DEST |
+					   MC_DEST_CURRENT |
+					   MC_UPDATE_ARG1 |
+					   MC_ARG1_COLOR_FACTOR | 
+					   MC_UPDATE_ARG2 |
+					   MC_ARG2_TEX1_COLOR |
+					   MC_UPDATE_OP |
+					   MC_OP_ARG2 );
+
+      } else {
+	 imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					   MC_STAGE_1 |
+					   MC_UPDATE_DEST |
+					   MC_DEST_CURRENT |
+					   MC_UPDATE_ARG1 |
+					   MC_ARG1_COLOR_FACTOR | 
+					   MC_UPDATE_ARG2 |
+					   MC_ARG2_TEX1_COLOR |
+					   MC_UPDATE_OP |
+					   MC_OP_LIN_BLEND_TEX1_ALPHA );
+      }
+
+      imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					MA_STAGE_1 |
+					MA_UPDATE_ARG1 |
+					MA_ARG1_ALPHA_FACTOR |
+					MA_UPDATE_ARG2 |
+					MA_ARG2_ALPHA_FACTOR |
+					MA_UPDATE_OP |
+					MA_OP_ARG1 );
+      break;
+
+   case GL_BLEND:
+      imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES |
+					MC_STAGE_1 |
+					MC_UPDATE_DEST |
+					MC_DEST_CURRENT |
+					MC_UPDATE_ARG1 |
+					MC_ARG1_COLOR_FACTOR | 
+					MC_UPDATE_ARG2 |
+					MC_ARG2_CURRENT_COLOR |
+					MC_UPDATE_OP |
+					MC_OP_LIN_BLEND_TEX1_COLOR );
+
+      if (t->image[0].internalFormat == GL_RGB) {
+	 imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					   MA_STAGE_1 |
+					   MA_UPDATE_ARG1 |
+					   MA_ARG1_ALPHA_FACTOR |
+					   MA_UPDATE_ARG2 |
+					   MA_ARG2_CURRENT_ALPHA |
+					   MA_UPDATE_OP |
+					   MA_OP_ARG1 );
+      } else {
+	 imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
+					   MA_STAGE_1 |
+					   MA_UPDATE_ARG1 |
+					   MA_ARG1_ALPHA_FACTOR |
+					   MA_UPDATE_ARG2 |
+					   MA_ARG2_ITERATED_ALPHA |
+					   MA_UPDATE_OP |
+					   MA_OP_LIN_BLEND_TEX1_ALPHA );
+      }
+      break;
+
+   default:
+      fprintf(stderr, "unkown tex 1 env mode\n");
+      exit(1);
+      break;			
+   }
+}
+
+
+void i810UpdateTextureState( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   imesa->CurrentTexObj[0] = 0;
+   imesa->CurrentTexObj[1] = 0;
+   i810UpdateTex0State( ctx );
+   i810UpdateTex1State( ctx );
+   I810_CONTEXT( ctx )->dirty |= I810_UPLOAD_CTX;
+}
+
+
+
+/*****************************************
+ * DRIVER functions
+ *****************************************/
+
+static void i810TexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+
+   if (pname == GL_TEXTURE_ENV_MODE) {
+
+      imesa->new_state |= I810_NEW_TEXTURE;
+
+   } else if (pname == GL_TEXTURE_ENV_COLOR) {
+
+      struct gl_texture_unit *texUnit = 
+	 &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      GLubyte c[4];
+      GLuint col;
+
+      FLOAT_RGBA_TO_UBYTE_RGBA(texUnit->EnvColor, c);
+      col = (c[3]<<24) | (c[0]<<16) | (c[1]<<8) | (c[2]);
+    
+      if (imesa->Setup[I810_CTXREG_CF1] != col) {
+	 imesa->Setup[I810_CTXREG_CF1] = col;      
+	 imesa->dirty |= I810_UPLOAD_CTX;
+      }
+   } 
+}
+
+static void i810TexImage( GLcontext *ctx, 
+			  GLenum target,
+			  struct gl_texture_object *tObj, 
+			  GLint level,
+			  GLint internalFormat,
+			  const struct gl_texture_image *image )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   i810TextureObjectPtr t;
+
+   i810Msg(10,"i810TexImage(%d): level %d internalFormat %x\n", 
+	   tObj->Name, level, internalFormat);
+
+   if (target != GL_TEXTURE_2D)
+      return;
+
+   if (level >= I810_TEX_MAXLEVELS)
+      return;
+
+   t = (i810TextureObjectPtr) tObj->DriverData;
+   if (t) {
+      /* if this is the current object, it will force an update */
+      i810DestroyTexObj( imesa, t );
+      tObj->DriverData = 0;
+      imesa->new_state |= I810_NEW_TEXTURE;
+   }
+}
+
+static void i810TexSubImage( GLcontext *ctx, GLenum target,
+			     struct gl_texture_object *tObj, GLint level,
+			     GLint xoffset, GLint yoffset,
+			     GLsizei width, GLsizei height,
+			     GLint internalFormat,
+			     const struct gl_texture_image *image ) 
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   i810TextureObjectPtr t;
+   i810Msg(10,"i810TexSubImage():\n");
+   i810Msg(10,"  Size: %d,%d of %d,%d; Level %d\n",
+	   width, height, image->Width,image->Height,
+	   level);
+
+   if ( target != GL_TEXTURE_2D ) 
+      return;
+   
+   t = (i810TextureObjectPtr) tObj->DriverData;
+   if (t) {
+      i810DestroyTexObj( imesa, t );
+      tObj->DriverData = 0;
+      imesa->new_state |= I810_NEW_TEXTURE;
+      i810glx.c_textureSwaps++;
+   }
+}
+
+static void i810TexParameter( GLcontext *ctx, GLenum target,
+			      struct gl_texture_object *tObj,
+			      GLenum pname, const GLfloat *params )
+{
+   i810TextureObjectPtr t = (i810TextureObjectPtr) tObj->DriverData;
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+
+   if (!t || target != GL_TEXTURE_2D)
+      return;
+
+   switch (pname) {
+   case GL_TEXTURE_MIN_FILTER:
+   case GL_TEXTURE_MAG_FILTER:
+      i810SetTexFilter(t,tObj->MinFilter,tObj->MagFilter);
+      break;
+
+   case GL_TEXTURE_WRAP_S:
+   case GL_TEXTURE_WRAP_T:
+      i810SetTexWrapping(t,tObj->WrapS,tObj->WrapT);
+      break;
+  
+   case GL_TEXTURE_BORDER_COLOR:
+      i810SetTexBorderColor(t,tObj->BorderColor);
+      break;
+
+   default:
+      return;
+   }
+
+   imesa->new_state |= I810_NEW_TEXTURE;
+}
+
+static void i810BindTexture( GLcontext *ctx, GLenum target,
+			     struct gl_texture_object *tObj )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   imesa->CurrentTexObj[ctx->Texture.CurrentUnit] = 0;  
+   imesa->new_state |= I810_NEW_TEXTURE;
+}
+
+static void i810DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj )
+{
+   i810TextureObjectPtr t = (i810TextureObjectPtr)tObj->DriverData;
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+
+   if (t) {
+      i810DestroyTexObj(imesa,t);
+      tObj->DriverData=0;
+   }
+}
+
+
+static GLboolean i810IsTextureResident( GLcontext *ctx, 
+					struct gl_texture_object *t )
+{
+   i810TextureObjectPtr mt;
+
+/*     LOCK_HARDWARE; */
+   mt = (i810TextureObjectPtr)t->DriverData;
+/*     UNLOCK_HARDWARE; */
+
+   return mt && mt->MemBlock;
+}
+
+void i810DDInitTextureFuncs( GLcontext *ctx )
+{
+   ctx->Driver.TexEnv = i810TexEnv;
+   ctx->Driver.TexImage = i810TexImage;
+   ctx->Driver.TexSubImage = i810TexSubImage;
+   ctx->Driver.BindTexture = i810BindTexture;
+   ctx->Driver.DeleteTexture = i810DeleteTexture;
+   ctx->Driver.TexParameter = i810TexParameter;
+   ctx->Driver.UpdateTexturePalette = 0;
+   ctx->Driver.IsTextureResident = i810IsTextureResident;
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tex.h b/xc/lib/GL/mesa/src/drv/i810/i810tex.h
new file mode 100644
index 000000000..d2b153ad8
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810tex.h
@@ -0,0 +1,108 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810TEX_INC
+#define I810TEX_INC
+
+#include "types.h"
+#include "mmath.h"
+#include "mm.h"
+
+#include "i810context.h"
+#include "i810_3d_reg.h"
+
+#define VALID_I810_TEXTURE_OBJECT(tobj)  (tobj) 
+
+#define I810_TEX_MAXLEVELS 10
+
+
+
+/* For shared texture space managment, these texture objects may also
+ * be used as proxies for regions of texture memory containing other
+ * client's textures.  Such proxy textures (not to be confused with GL
+ * proxy textures) are subject to the same LRU aging we use for our
+ * own private textures, and thus we have a mechanism where we can
+ * fairly decide between kicking out our own textures and those of
+ * other clients.
+ *
+ * Non-local texture objects have a valid MemBlock to describe the
+ * region managed by the other client, and can be identified by
+ * 't->globj == 0' 
+ */
+struct i810_texture_object_t {
+   struct i810_texture_object_t *next, *prev;
+
+   GLuint age;   
+   struct gl_texture_object *globj;
+     
+   int Pitch;
+   int Height;
+   int texelBytes;
+   int totalSize;
+
+   PMemBlock MemBlock;   
+   char *BufAddr;
+
+   GLuint min_level;
+   GLuint max_level;
+   GLuint dirty_images;
+
+   struct { 
+      const struct gl_texture_image *image;
+      int offset;		/* into BufAddr */
+      int height;
+      int internalFormat;
+   } image[I810_TEX_MAXLEVELS];
+
+   /* Support for multitexture.
+    */
+   GLuint current_unit;   
+   GLuint Setup[I810_TEX_SETUP_SIZE];
+};		
+
+#define I810_NO_PALETTE        0x0
+#define I810_USE_PALETTE       0x1
+#define I810_UPDATE_PALETTE    0x2
+#define I810_FALLBACK_PALETTE  0x4
+
+typedef struct i810_texture_object_t *i810TextureObjectPtr;
+
+void i810UpdateTextureState( GLcontext *ctx );
+void i810DDInitTextureFuncs( GLcontext *ctx );
+
+void i810DestroyTexObj( i810ContextPtr imesa, i810TextureObjectPtr t);
+int i810UploadTexImages( i810ContextPtr imesa, i810TextureObjectPtr t );
+
+void i810ResetGlobalLRU( i810ContextPtr imesa );
+void i810TexturesGone( i810ContextPtr imesa, 
+		       GLuint start, GLuint end, 
+		       GLuint in_use ); 
+
+void i810PrintLocalLRU( i810ContextPtr imesa );
+void i810PrintGlobalLRU( i810ContextPtr imesa );
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tris.c b/xc/lib/GL/mesa/src/drv/i810/i810tris.c
new file mode 100644
index 000000000..08e012c66
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810tris.c
@@ -0,0 +1,317 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdio.h>
+#include <math.h>
+
+#include "vb.h"
+#include "pipeline.h"
+
+#include "mm.h"
+#include "i810lib.h"
+#include "i810tris.h"
+#include "i810vb.h"
+#include "i810log.h"
+
+
+static void i810_null_quad( GLcontext *ctx, GLuint v0,
+			    GLuint v1, GLuint v2, GLuint v3, GLuint pv )
+{
+}     
+
+static void i810_null_triangle( GLcontext *ctx, GLuint v0,
+				GLuint v1, GLuint v2, GLuint pv )
+{
+}     
+
+static void i810_null_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv ) 
+{
+}
+
+static void i810_null_points( GLcontext *ctx, GLuint first, GLuint last ) 
+{
+}
+
+
+#define I810_COLOR(to, from) {			\
+  (to)[0] = (from)[2];				\
+  (to)[1] = (from)[1];				\
+  (to)[2] = (from)[0];				\
+  (to)[3] = (from)[3];				\
+}
+
+
+
+static triangle_func tri_tab[0x20];   
+static quad_func     quad_tab[0x20];  
+static line_func     line_tab[0x20];  
+static points_func   points_tab[0x20];
+
+void i810PrintRenderState( const char *msg, GLuint state )
+{
+   fprintf(stderr, "%s: (%x) %s%s%s%s%s%s\n",
+	   msg, (int) state,
+	   (state & I810_FLAT_BIT)       ? "flat, "       : "",
+	   (state & I810_OFFSET_BIT)     ? "offset, "     : "",
+	   (state & I810_TWOSIDE_BIT)    ? "twoside, "    : "",
+	   (state & I810_ANTIALIAS_BIT)  ? "antialias, "  : "",
+	   (state & I810_NODRAW_BIT)     ? "no-draw, "    : "",
+	   (state & I810_FALLBACK_BIT)   ? "fallback"     : "");
+}
+
+#define IND (0)
+#define TAG(x) x
+#include "i810tritmp.h"
+
+#define IND (I810_FLAT_BIT)
+#define TAG(x) x##_flat
+#include "i810tritmp.h"
+
+#define IND (I810_OFFSET_BIT)
+#define TAG(x) x##_offset
+#include "i810tritmp.h"
+
+#define IND (I810_OFFSET_BIT|I810_FLAT_BIT)
+#define TAG(x) x##_offset_flat
+#include "i810tritmp.h"
+
+#define IND (I810_TWOSIDE_BIT)
+#define TAG(x) x##_twoside
+#include "i810tritmp.h"
+
+#define IND (I810_TWOSIDE_BIT|I810_FLAT_BIT)
+#define TAG(x) x##_twoside_flat
+#include "i810tritmp.h"
+
+#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT)
+#define TAG(x) x##_twoside_offset
+#include "i810tritmp.h"
+
+#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT|I810_FLAT_BIT)
+#define TAG(x) x##_twoside_offset_flat
+#include "i810tritmp.h"
+
+void i810DDTrifuncInit()
+{
+   int i;
+   init();
+   init_flat();
+   init_offset();
+   init_offset_flat();
+   init_twoside();
+   init_twoside_flat();
+   init_twoside_offset();
+   init_twoside_offset_flat();
+
+   /* Hmmm...
+    */
+   for (i = 0 ; i < 0x20 ; i++) {
+      if (i & ~I810_FLAT_BIT) {
+	 points_tab[i] = points_tab[i&I810_FLAT_BIT];
+	 line_tab[i] = line_tab[i&I810_FLAT_BIT];
+      }
+   }
+
+   for (i = 0 ; i < 0x20 ; i++) 
+      if ((i & (I810_NODRAW_BIT|I810_FALLBACK_BIT)) == I810_NODRAW_BIT ||
+	  i810glx.nullprims) 
+      {
+	 quad_tab[i] = i810_null_quad; 
+	 tri_tab[i] = i810_null_triangle; 
+	 line_tab[i] = i810_null_line;
+	 points_tab[i] = i810_null_points;
+      }
+
+   if (i810glx.noFallback) {
+      for (i = 0 ; i < 0x10 ; i++) {
+	 points_tab[i|I810_FALLBACK_BIT] = points_tab[i];
+	 line_tab[i|I810_FALLBACK_BIT] = line_tab[i];
+	 tri_tab[i|I810_FALLBACK_BIT] = tri_tab[i];
+	 quad_tab[i|I810_FALLBACK_BIT] = quad_tab[i];
+      }
+   }
+
+}
+
+
+/* Everything is done via single triangle instructiopns at the moment;
+ * this can change fairly easily.
+ */
+#if I810_USE_BATCH
+
+GLuint *i810AllocPrimitiveVerts( i810ContextPtr imesa, int dwords ) 
+{
+   GLuint orig_dwords = dwords;
+
+   dwords+=2;
+   dwords&=~1;
+
+   while (1) {
+      if (i810glx.dma_buffer->space < dwords * 4) 
+      {
+	 if (I810_DEBUG & DEBUG_VERBOSE_RING)
+	    fprintf(stderr, "i810AllocPrimitiveVerts: dma buffer overflow\n");
+	 i810DmaOverflow( dwords );
+      }
+      else
+      {
+	 GLuint start = i810glx.dma_buffer->head;
+	 i810glx.dma_buffer->head += dwords * 4;
+	 i810glx.dma_buffer->space -= dwords * 4;
+
+	 if ((orig_dwords & 1) == 0) {
+	    *(GLuint *)(i810glx.dma_buffer->virtual_start + start ) = 0;
+	    start += 4;
+	 }
+
+	 *(GLuint *)(i810glx.dma_buffer->virtual_start + start ) = 
+	    GFX_OP_PRIMITIVE | PR_TRIANGLES | (orig_dwords-1);
+
+	 return (GLuint *)(i810glx.dma_buffer->virtual_start + start + 4);
+      }
+   }
+}
+
+#else
+
+/* Hardware lock is held.
+ */
+GLuint *i810AllocPrimitiveVerts( i810ContextPtr imesa, int dwords ) 
+{
+   GLuint orig_dwords = dwords;
+   
+   dwords+=2;
+   dwords&=~1;
+
+   while (1)
+   {
+      BEGIN_LP_RING( imesa, dwords );
+
+      if (outring + dwords * 4 != ((outring + dwords * 4) & ringmask)) 
+      {
+	 int i;
+
+	 if (I810_DEBUG & DEBUG_VERBOSE_RING)
+	    fprintf(stderr, "\n\nwrap case in i810AllocPrimitiveVerts\n\n");
+	 
+	 for (i = 0 ; i < dwords ; i++)
+	    OUT_RING( 0 );
+	 ADVANCE_LP_RING();
+      }
+      else 
+      {
+	 i810glx.LpRing.tail = outring + dwords * 4;
+	 
+	 if ((orig_dwords & 1) == 0)
+	    OUT_RING(0);
+	 
+	 OUT_RING( GFX_OP_PRIMITIVE | PR_TRIANGLES | (orig_dwords-1) );
+	 return (GLuint *)(virt + outring);
+      }
+   }
+}
+
+#if 0
+void i810FinishPrim( void )
+{
+   char *virt = i810glx.LpRing.virtual_start;
+
+   for (i = i810glx.LpRing.head ; i != i810glx.LpRing.tail ; i += 4) 
+      fprintf(stderr, "prim %x (%f)", *(virt + i), *(float *)(virt + i));
+
+   OUTREG(LP_RING + RING_TAIL, i810glx.LpRing.tail);
+}
+#endif 
+#endif
+
+
+
+void i810DDChooseRenderState( GLcontext *ctx )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLuint flags = ctx->TriangleCaps;
+
+   ctx->IndirectTriangles &= ~DD_SW_RASTERIZE;
+
+   if (flags) {
+      GLuint ind = 0;
+      GLuint shared = 0;
+      GLuint setup = imesa->setupindex;
+      GLuint fallback = I810_FALLBACK_BIT; 
+
+      if (i810glx.noFallback) fallback = 0; 
+
+      if ((flags & DD_FLATSHADE) && (setup & I810_RGBA_BIT)) shared |= I810_FLAT_BIT;
+      if (flags & DD_MULTIDRAW)                    shared |= fallback;
+      if (flags & DD_SELECT)                       shared |= I810_FALLBACK_BIT;
+      if (flags & DD_FEEDBACK)                     shared |= I810_FALLBACK_BIT;
+
+      ind = shared;
+      if (flags & DD_POINT_SMOOTH)                 ind |= I810_ANTIALIAS_BIT;
+      if (flags & DD_POINT_ATTEN)                  ind |= fallback;
+
+      imesa->renderindex = ind;
+      imesa->PointsFunc = points_tab[ind]; 
+      if (ind & I810_FALLBACK_BIT)  
+	 ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE;
+
+      ind = shared;
+      if (flags & DD_LINE_SMOOTH)                   ind |= I810_ANTIALIAS_BIT;
+      if (flags & DD_LINE_STIPPLE)                  ind |= fallback;
+
+      imesa->renderindex |= ind;
+      imesa->LineFunc = line_tab[ind];
+      if (ind & I810_FALLBACK_BIT) 
+	 ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE;
+
+      ind = shared;
+      if (flags & DD_TRI_SMOOTH)                    ind |= I810_ANTIALIAS_BIT;
+      if (flags & DD_TRI_OFFSET)                    ind |= I810_OFFSET_BIT;
+      if (flags & DD_TRI_LIGHT_TWOSIDE)             ind |= I810_TWOSIDE_BIT;
+      if (flags & (DD_TRI_UNFILLED|DD_TRI_STIPPLE)) ind |= fallback;	
+
+      imesa->renderindex |= ind;
+      imesa->TriangleFunc = tri_tab[ind];
+      imesa->QuadFunc = quad_tab[ind];
+      if (ind & I810_FALLBACK_BIT)
+	 ctx->IndirectTriangles |= (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE);
+   } 
+   else if (imesa->renderindex)
+   {
+      imesa->renderindex  = 0;
+      imesa->PointsFunc   = points_tab[0]; 
+      imesa->LineFunc     = line_tab[0];
+      imesa->TriangleFunc = tri_tab[0];
+      imesa->QuadFunc     = quad_tab[0];
+   }
+
+   if (I810_DEBUG&DEBUG_VERBOSE_API) {
+      gl_print_tri_caps("tricaps", ctx->TriangleCaps);
+      i810PrintRenderState("i810: Render state", imesa->renderindex);
+   }
+}
+
+
+
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tris.h b/xc/lib/GL/mesa/src/drv/i810/i810tris.h
new file mode 100644
index 000000000..81cdb5159
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810tris.h
@@ -0,0 +1,158 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810TRIS_INC
+#define I810TRIS_INC
+
+#include "types.h"
+#include "i810dma.h"
+
+extern void i810PrintRenderState( const char *msg, GLuint state );
+extern void i810DDChooseRenderState(GLcontext *ctx);
+extern void i810DDTrifuncInit( void );
+
+extern GLuint *i810AllocPrimitiveVerts( i810ContextPtr imesa, int dwords );
+
+
+
+/* Todo: 
+ *    - multidraw, ...
+ *    - Antialiasing (?)
+ *    - line and polygon stipple
+ *    - select and feedback 
+ *    - stencil 
+ *    - point parameters
+ *    - 
+ */
+#define I810_ANTIALIAS_BIT   0       /* ignored for now, no fallback */
+#define I810_FLAT_BIT 	     0x1
+#define I810_OFFSET_BIT	     0x2	
+#define I810_TWOSIDE_BIT     0x4
+#define I810_NODRAW_BIT	     0x8
+#define I810_FALLBACK_BIT    0x10
+
+/* Not in use:
+ */
+#define I810_FEEDBACK_BIT    0x20
+#define I810_SELECT_BIT      0x40
+#define I810_POINT_PARAM_BIT 0x80	/* not needed? */
+
+
+
+static void __inline__ i810_draw_triangle( i810ContextPtr imesa,
+					   i810_vertex *v0, 
+					   i810_vertex *v1, 
+					   i810_vertex *v2 )
+{
+   i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( imesa, 30 );
+   wv[0] = *v0;
+   wv[1] = *v1;
+   wv[2] = *v2;
+   FINISH_PRIM();
+}
+
+
+
+
+/* These can go soon, but for the meantime we're using triangles for 
+ * everything.
+ */
+static __inline__ void i810_draw_point( i810ContextPtr imesa,
+					i810_vertex *tmp, float sz )
+{
+   i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( imesa, 6*10 );
+
+   wv[0] = *tmp;
+   wv[0].x = tmp->x - sz;
+   wv[0].y = tmp->y - sz;
+
+   wv[1] = *tmp;
+   wv[1].x = tmp->x + sz;
+   wv[1].y = tmp->y - sz;
+
+   wv[2] = *tmp;
+   wv[2].x = tmp->x + sz;
+   wv[2].y = tmp->y + sz;
+
+   wv[3] = *tmp;
+   wv[3].x = tmp->x + sz;
+   wv[3].y = tmp->y + sz;
+
+   wv[4] = *tmp;
+   wv[4].x = tmp->x - sz;
+   wv[4].y = tmp->y + sz;
+
+   wv[5] = *tmp;
+   wv[5].x = tmp->x - sz;
+   wv[5].y = tmp->y - sz;
+
+   FINISH_PRIM();
+}
+
+
+static __inline__ void i810_draw_line( i810ContextPtr imesa, 
+				       i810_vertex *tmp0, 
+				       i810_vertex *tmp1,
+				       float width )
+{
+   i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( imesa, 6 * 10 );
+   float dx, dy, ix, iy;
+
+   dx = tmp0->x - tmp1->x;
+   dy = tmp0->y - tmp1->y;
+
+   ix = width * .5; iy = 0;
+   if (dx * dx > dy * dy) {
+      iy = ix; ix = 0;
+   }
+
+   wv[0] = *tmp0;
+   wv[0].x = tmp0->x - ix;
+   wv[0].y = tmp0->y - iy;
+
+   wv[1] = *tmp1;
+   wv[1].x = tmp1->x + ix;
+   wv[1].y = tmp1->y + iy;
+
+   wv[2] = *tmp0;
+   wv[2].x = tmp0->x + ix;
+   wv[2].y = tmp0->y + iy;
+	 
+   wv[3] = *tmp0;
+   wv[3].x = tmp0->x - ix;
+   wv[3].y = tmp0->y - iy;
+
+   wv[4] = *tmp1;
+   wv[4].x = tmp1->x - ix;
+   wv[4].y = tmp1->y - iy;
+
+   wv[5] = *tmp1;
+   wv[5].x = tmp1->x + ix;
+   wv[5].y = tmp1->y + iy;
+
+   FINISH_PRIM();
+}
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h b/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h
new file mode 100644
index 000000000..97c101c17
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h
@@ -0,0 +1,172 @@
+
+static __inline__ void TAG(triangle)( GLcontext *ctx, GLuint e0,
+				      GLuint e1, GLuint e2, GLuint pv )
+{
+   i810ContextPtr imesa = I810_CONTEXT(ctx);
+   struct vertex_buffer *VB = ctx->VB;
+   i810VertexPtr i810VB = I810_DRIVER_DATA(VB)->verts;
+   const i810_vertex *v0 = &i810VB[e0].v;  
+   const i810_vertex *v1 = &i810VB[e1].v;  
+   const i810_vertex *v2 = &i810VB[e2].v;  
+
+#if (IND & I810_OFFSET_BIT)
+   GLfloat offset = ctx->Polygon.OffsetUnits * 1.0/0x10000;
+#endif
+
+#if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT))
+   int c0 = *(int *)&i810VB[pv].v.color; 
+   int c1 = c0;
+   int c2 = c0;
+#endif
+
+
+#if (IND & (I810_TWOSIDE_BIT|I810_OFFSET_BIT)) 
+   {
+      GLfloat ex = v0->x - v2->x;
+      GLfloat ey = v0->y - v2->y;
+      GLfloat fx = v1->x - v2->x;
+      GLfloat fy = v1->y - v2->y;
+      GLfloat c = ex*fy-ey*fx;
+	 
+#if (IND & I810_TWOSIDE_BIT) 
+      {
+	 GLuint facing = (c>0.0) ^ ctx->Polygon.FrontBit;
+	 GLubyte (*vbcolor)[4] = VB->Color[facing]->data;
+	 if (IND & I810_FLAT_BIT) {
+	    I810_COLOR((char *)&c0,vbcolor[pv]);
+	    c2 = c1 = c0;
+	 } else {
+	    I810_COLOR((char *)&c0,vbcolor[e0]);
+	    I810_COLOR((char *)&c1,vbcolor[e1]);
+	    I810_COLOR((char *)&c2,vbcolor[e2]);
+	 }
+      }
+#endif
+      
+#if (IND & I810_OFFSET_BIT) 
+      {
+	 if (c * c > 1e-16) {
+	    GLfloat factor = ctx->Polygon.OffsetFactor;
+	    GLfloat ez = v0->z - v2->z;
+	    GLfloat fz = v1->z - v2->z;
+	    GLfloat a = ey*fz-ez*fy;
+	    GLfloat b = ez*fx-ex*fz;
+	    GLfloat ic = 1.0 / c;
+	    GLfloat ac = a * ic;
+	    GLfloat bc = b * ic;
+	    if (ac<0.0F)  ac = -ac;
+	    if (bc<0.0F)  bc = -bc;
+	    offset += MAX2( ac, bc ) * factor;
+	 }
+      }
+#endif
+   }
+#endif  
+
+   i810glx.c_triangles++;
+
+   
+   BEGIN_CLIP_LOOP(imesa)
+      {
+	 i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( imesa, 30 );
+	 wv[0] = *v0;
+#if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT))
+	 *((int *)(&wv[0].color)) = c0;
+#endif
+#if (IND & I810_OFFSET_BIT)
+	 wv[0].z = v0->z + offset;
+#endif
+
+
+	 wv[1] = *v1;
+#if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT))
+	 *((int *)(&wv[1].color)) = c1;
+#endif
+#if (IND & I810_OFFSET_BIT)
+	 wv[1].z = v1->z + offset;
+#endif
+
+	 wv[2] = *v2;
+#if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT))
+	 *((int *)(&wv[2].color)) = c2;
+#endif
+#if (IND & I810_OFFSET_BIT)
+	 wv[2].z = v2->z + offset;
+#endif
+
+	 FINISH_PRIM();
+      }
+   END_CLIP_LOOP(imesa);
+}
+
+
+
+static void TAG(quad)( GLcontext *ctx, GLuint v0,
+		       GLuint v1, GLuint v2, GLuint v3, 
+		       GLuint pv )
+{
+   TAG(triangle)( ctx, v0, v1, v3, pv );
+   TAG(triangle)( ctx, v1, v2, v3, pv );
+}
+
+
+#if ((IND & ~I810_FLAT_BIT) == 0)
+
+static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   i810VertexPtr i810VB = I810_DRIVER_DATA(ctx->VB)->verts;
+   i810_vertex tmp0 = i810VB[v0].v;
+   i810_vertex tmp1 = i810VB[v1].v;
+   float width = ctx->Line.Width;
+
+   if (IND & I810_FLAT_BIT) {
+      *(int *)&tmp1.color = *(int *)&tmp0.color = 
+	 *(int *)&i810VB[pv].v.color;
+   }
+
+   BEGIN_CLIP_LOOP(imesa)
+      i810_draw_line( imesa, &tmp0, &tmp1, width );
+   END_CLIP_LOOP(imesa);
+}
+
+
+static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   struct vertex_buffer *VB = ctx->VB;
+   i810VertexPtr i810VB = I810_DRIVER_DATA(VB)->verts;
+   GLfloat sz = ctx->Point.Size * .5;
+   int i;
+
+   /* Culling is disabled automatically via. the
+    * ctx->Driver.ReducedPrimitiveChange() callback.  
+    */
+   
+   BEGIN_CLIP_LOOP(imesa)
+      for(i=first;i<=last;i++) {
+	 if(VB->ClipMask[i]==0) {
+	    i810_vertex *tmp = &i810VB[i].v;
+	    i810_draw_point( imesa, tmp, sz );
+	 }
+      }
+   END_CLIP_LOOP(imesa);
+}
+
+#endif
+
+
+static void TAG(init)( void )
+{
+   tri_tab[IND] = TAG(triangle);
+   quad_tab[IND] = TAG(quad);
+
+#if ((IND & ~I810_FLAT_BIT) == 0) 
+   line_tab[IND] = TAG(line);
+   points_tab[IND] = TAG(points);
+#endif
+}
+
+
+#undef IND
+#undef TAG
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810vb.c b/xc/lib/GL/mesa/src/drv/i810/i810vb.c
new file mode 100644
index 000000000..6ba7eb9a5
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810vb.c
@@ -0,0 +1,461 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 "i810lib.h"
+#include "i810context.h"
+#include "i810vb.h"
+#include "i810log.h"
+#include "i810dma.h"
+
+#include "stages.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#define TEX0 {					\
+  v->v.tu0 = tc0[i][0];			\
+  v->v.tv0 = tc0[i][1];			\
+}
+
+#define TEX1 {					\
+  v->v.tu1 = tc1[i][0];			\
+  v->v.tv1 = tc1[i][1];			\
+}
+
+/* Doesn't seem to work very well (golly).
+ */
+#define SPC {					\
+  GLubyte *spec = &(VB->Spec[0][i][0]);		\
+  v->v.specular.red = spec[0];		\
+  v->v.specular.green = spec[1];		\
+  v->v.specular.blue = spec[2];		\
+}
+
+#define FOG {					\
+  GLubyte *spec = &(VB->Spec[0][i][0]);		\
+  v->v.specular.alpha = spec[3];		\
+}
+
+#define COL {					\
+  GLubyte *col = &(VB->Color[0]->data[i][0]);	\
+  v->v.color.blue  = col[2];		\
+  v->v.color.green = col[1];		\
+  v->v.color.red   = col[0];		\
+  v->v.color.alpha = col[3];		\
+}
+
+/* The vertex formats we have don't seem to support projective texturing
+ * in the multitexture case.  (Would require another 1/w value for the
+ * second set of texcoords).    
+ */
+#define TEX0_4						\
+  if (VB->TexCoordPtr[0]->size == 4)			\
+  {							\
+     GLfloat (*tc)[4] = VB->TexCoordPtr[0]->data;	\
+     v = &(I810_DRIVER_DATA(VB)->verts[start]);		\
+     imesa->setupdone &= ~I810_WIN_BIT;		\
+     for (i=start; i < end; i++, v++)	{		\
+        float oow = 1.0 / tc[i][3];			\
+	v->v.oow *= tc[i][3];				\
+	v->v.tu0 *= oow;				\
+	v->v.tv0 *= oow;				\
+     }							\
+  }
+
+
+#define COORD					\
+      GLfloat *win = VB->Win.data[i];		\
+      v->v.x =                 win[0];	\
+      v->v.y =    i810height - win[1];	\
+      v->v.z = (1.0/0x10000) * win[2];	\
+      v->v.oow =               win[3]; 
+
+
+
+#define NOP
+
+
+#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog)		\
+static void name(struct vertex_buffer *VB, GLuint start, GLuint end)	\
+{									\
+   i810ContextPtr imesa = I810_CONTEXT( VB->ctx );			\
+   __DRIdrawablePrivate *dPriv = imesa->driDrawable;			\
+   i810VertexPtr v;							\
+   GLfloat (*tc0)[4];							\
+   GLfloat (*tc1)[4];							\
+   GLfloat i810height = dPriv->h;					\
+   int i;								\
+   (void) i810height; (void) imesa;					\
+									\
+									\
+   gl_import_client_data( VB, VB->ctx->RenderFlags,			\
+			  (VB->ClipOrMask				\
+			   ? VEC_WRITABLE|VEC_GOOD_STRIDE		\
+			   : VEC_GOOD_STRIDE));				\
+									\
+   tc0 = VB->TexCoordPtr[0]->data;					\
+   tc1 = VB->TexCoordPtr[1]->data;					\
+									\
+   v = &(I810_DRIVER_DATA(VB)->verts[start]);				\
+									\
+   if (VB->ClipOrMask == 0)						\
+      for (i=start; i < end; i++, v++) {				\
+	 win;								\
+	 col;								\
+	 spec;								\
+	 fog;								\
+	 tex0;								\
+	 tex1;								\
+      }									\
+   else									\
+      for (i=start; i < end; i++, v++) {				\
+	 if (VB->ClipMask[i] == 0) {					\
+	    win;							\
+	    spec;							\
+	    fog;							\
+	    tex0;							\
+	    tex1;							\
+	 }								\
+	    col;							\
+      }									\
+   tex0_4;								\
+}
+
+
+
+ 
+SETUPFUNC(rs_wt0,	COORD,NOP,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wt0t1,	COORD,NOP,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wft0,	COORD,NOP,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wft0t1,	COORD,NOP,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wg,	COORD,COL,NOP,NOP,NOP,NOP,NOP)
+SETUPFUNC(rs_wgs,	COORD,COL,NOP,NOP,NOP,SPC,NOP)
+SETUPFUNC(rs_wgt0,	COORD,COL,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wgt0t1,	COORD,COL,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wgst0,	COORD,COL,TEX0,NOP,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_wgst0t1,	COORD,COL,TEX0,TEX1,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_wgf,	COORD,COL,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_wgfs,	COORD,COL,NOP,NOP,NOP,SPC,FOG)
+SETUPFUNC(rs_wgft0,	COORD,COL,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wgft0t1,	COORD,COL,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wgfst0,	COORD,COL,TEX0,NOP,TEX0_4,SPC,FOG)
+SETUPFUNC(rs_wgfst0t1,	COORD,COL,TEX0,TEX1,TEX0_4,SPC,FOG)
+
+SETUPFUNC(rs_t0,	NOP,NOP,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_t0t1,	NOP,NOP,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_f,		NOP,NOP,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_ft0,	NOP,NOP,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_ft0t1,	NOP,NOP,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_g,		NOP,COL,NOP,NOP,NOP,NOP,NOP)
+SETUPFUNC(rs_gs,	NOP,COL,NOP,NOP,NOP,SPC,NOP)
+SETUPFUNC(rs_gt0,	NOP,COL,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_gt0t1,	NOP,COL,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_gst0,	NOP,COL,TEX0,NOP,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_gst0t1,	NOP,COL,TEX0,TEX1,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_gf,	NOP,COL,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_gfs,	NOP,COL,NOP,NOP,NOP,SPC,FOG)
+SETUPFUNC(rs_gft0,	NOP,COL,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_gft0t1,	NOP,COL,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_gfst0,	NOP,COL,TEX0,NOP,TEX0_4,SPC,FOG)
+SETUPFUNC(rs_gfst0t1,	NOP,COL,TEX0,TEX1,TEX0_4,SPC,FOG)
+
+
+
+static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end)
+{
+   
+  fprintf(stderr, "i810RasterSetup(): invalid setup function\n");
+}
+
+typedef void (*setupFunc)(struct vertex_buffer *,GLuint,GLuint);
+
+static setupFunc setup_func[0x80];
+
+void i810DDSetupInit( void )
+{
+   int i;
+
+   for (i = 0 ; i < 0x80 ; i++)
+      setup_func[i] = rs_invalid;
+   
+   /* Functions to build vert's from scratch */
+   setup_func[I810_WIN_BIT|I810_TEX0_BIT] = rs_wt0;
+   setup_func[I810_WIN_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wt0t1;
+   setup_func[I810_WIN_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_wft0;
+   setup_func[I810_WIN_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wft0t1;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT] = rs_wg;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT] = rs_wgs;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_TEX0_BIT] = rs_wgt0;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgt0t1;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_wgst0;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgst0t1;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT] = rs_wgf;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT] = rs_wgfs;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_wgft0;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgft0t1;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_wgfst0;
+   setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgfst0t1;
+
+   /* Repair functions */
+   setup_func[I810_TEX0_BIT] = rs_t0;
+   setup_func[I810_TEX0_BIT|I810_TEX1_BIT] = rs_t0t1;
+   setup_func[I810_FOG_BIT] = rs_f;
+   setup_func[I810_FOG_BIT|I810_TEX0_BIT] = rs_ft0;
+   setup_func[I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_ft0t1;
+   setup_func[I810_RGBA_BIT] = rs_g;
+   setup_func[I810_RGBA_BIT|I810_SPEC_BIT] = rs_gs;
+   setup_func[I810_RGBA_BIT|I810_TEX0_BIT] = rs_gt0;
+   setup_func[I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gt0t1;
+   setup_func[I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_gst0;
+   setup_func[I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gst0t1;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT] = rs_gf;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT] = rs_gfs;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_gft0;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gft0t1;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_gfst0;
+   setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gfst0t1;
+
+}
+
+
+void i810PrintSetupFlags(char *msg, GLuint flags )
+{
+   fprintf(stderr, "%s: %d %s%s%s%s%s%s%s\n",
+	   msg,
+	   (int)flags,
+	   (flags & I810_WIN_BIT)      ? " xyzw," : "", 
+	   (flags & I810_RGBA_BIT)     ? " rgba," : "",
+	   (flags & I810_SPEC_BIT)     ? " spec," : "",
+	   (flags & I810_FOG_BIT)      ? " fog," : "",
+	   (flags & I810_TEX0_BIT)     ? " tex-0," : "",
+	   (flags & I810_TEX1_BIT)     ? " tex-1," : "",
+	   (flags & I810_ALPHA_BIT)    ? " alpha," : "");
+}
+
+
+
+
+void i810ChooseRasterSetupFunc(GLcontext *ctx)
+{
+  i810ContextPtr imesa = I810_CONTEXT( ctx );
+  int funcindex = (I810_WIN_BIT | I810_RGBA_BIT);
+
+  if (ctx->Texture.Enabled & 0xf) {
+      if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE)
+	 funcindex &= ~I810_RGBA_BIT;
+
+     funcindex |= I810_TEX0_BIT;
+  }
+
+  if (ctx->Texture.Enabled & 0xf0)
+     funcindex |= I810_TEX1_BIT;
+
+  if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+     funcindex |= I810_SPEC_BIT;
+
+  if (ctx->FogMode == FOG_FRAGMENT)
+     funcindex |= I810_FOG_BIT;
+    
+  if (MESA_VERBOSE)
+     i810PrintSetupFlags("xsmesa: full setup function", funcindex); 
+
+  imesa->setupindex = funcindex;
+  ctx->Driver.RasterSetup = setup_func[funcindex];
+}
+
+
+
+
+void i810DDCheckPartialRasterSetup( GLcontext *ctx, 
+				    struct gl_pipeline_stage *d )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLuint tmp = imesa->setupdone;
+
+   d->type = 0;
+   imesa->setupdone = 0;	/* cleared if we return */
+
+   if ((ctx->Array.Summary & VERT_OBJ_ANY) == 0)
+      return;
+
+   if (ctx->IndirectTriangles) 
+      return;
+
+   imesa->setupdone = tmp;
+
+   /* disabled until we have a merge&render op */
+   /*     d->inputs = available; */
+   /*     d->outputs = VERT_RAST_SETUP_PART; */
+   /*     d->type = PIPE_PRECALC; */
+}
+
+
+/* Repair existing precalculated vertices with new data.
+ */
+void i810DDPartialRasterSetup( struct vertex_buffer *VB )
+{
+   i810ContextPtr imesa = I810_CONTEXT( VB->ctx );
+   GLuint new = VB->pipeline->new_outputs;
+   GLuint available = VB->pipeline->outputs;
+   GLuint ind = 0;
+
+   if (new & VERT_WIN) {
+      new = available;
+      ind |= I810_WIN_BIT | I810_FOG_BIT;
+   }
+
+   if (new & VERT_RGBA)
+      ind |= I810_RGBA_BIT | I810_SPEC_BIT;
+
+   if (new & VERT_TEX0_ANY) 
+      ind |= I810_TEX0_BIT;
+
+   if (new & VERT_TEX1_ANY)
+      ind |= I810_TEX1_BIT;
+
+   if (new & VERT_FOG_COORD)
+      ind |= I810_FOG_BIT;
+
+   imesa->setupdone &= ~ind;
+   ind &= imesa->setupindex;
+   imesa->setupdone |= ind;
+
+   if (0) i810PrintSetupFlags("xsmesa: partial setup function", ind);
+
+   if (ind) 
+      setup_func[ind&~I810_ALPHA_BIT]( VB, VB->Start, VB->Count );   
+}
+
+
+void i810DDDoRasterSetup( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+
+   if (VB->Type == VB_CVA_PRECALC) 
+      i810DDPartialRasterSetup( VB );
+   else if (ctx->Driver.RasterSetup)
+      ctx->Driver.RasterSetup( VB, VB->CopyStart, VB->Count );
+}
+
+
+
+
+void i810DDResizeVB( struct vertex_buffer *VB, GLuint size )
+{
+   i810VertexBufferPtr mvb = I810_DRIVER_DATA(VB);
+
+   while (mvb->size < size)
+      mvb->size *= 2;
+
+   free( mvb->vert_store );
+   mvb->vert_store = malloc( sizeof(i810Vertex) * mvb->size + 31);
+   if (!mvb->vert_store) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+
+   mvb->verts = (i810VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31);
+
+   gl_vector1ui_free( &mvb->clipped_elements );
+   gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 );   
+   if (!mvb->clipped_elements.start) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+
+   free( VB->ClipMask );
+   VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size);
+   if (!VB->ClipMask) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+
+
+   if (VB->Type == VB_IMMEDIATE) {
+      free( mvb->primitive );
+      free( mvb->next_primitive );
+      mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+      mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+      if (!mvb->primitive || !mvb->next_primitive) {
+	 fprintf(stderr, "i810-glx: out of memory !\n");
+	 exit(1);
+      }
+   }
+}
+
+
+void i810DDRegisterVB( struct vertex_buffer *VB )
+{
+   i810VertexBufferPtr mvb;
+
+   mvb = (i810VertexBufferPtr)calloc( 1, sizeof(*mvb) );
+
+   mvb->size = VB->Size * 2;
+   mvb->vert_store = malloc( sizeof(i810Vertex) * mvb->size + 31);
+   if (!mvb->vert_store) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+   
+   mvb->verts = (i810VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31);
+
+   gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 );
+   if (!mvb->clipped_elements.start) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+      
+   free( VB->ClipMask );
+   VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size);
+   if (!VB->ClipMask) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+
+   mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+   mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+   if (!mvb->primitive || !mvb->next_primitive) {
+      fprintf(stderr, "i810-glx: out of memory !\n");
+      exit(1);
+   }
+
+   VB->driver_data = mvb;
+}
+
+
+void i810DDUnregisterVB( struct vertex_buffer *VB )
+{
+   i810VertexBufferPtr mvb = I810_DRIVER_DATA(VB);
+   
+   if (mvb) {
+      if (mvb->vert_store) free(mvb->vert_store);
+      if (mvb->primitive) free(mvb->primitive);
+      if (mvb->next_primitive) free(mvb->next_primitive);
+      gl_vector1ui_free( &mvb->clipped_elements );
+      free(mvb);
+      VB->driver_data = 0;
+   }      
+}
diff --git a/xc/lib/GL/mesa/src/drv/i810/i810vb.h b/xc/lib/GL/mesa/src/drv/i810/i810vb.h
new file mode 100644
index 000000000..23685f106
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/i810/i810vb.h
@@ -0,0 +1,116 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 I810VB_INC
+#define I810VB_INC
+
+#include "vb.h"
+#include "types.h"
+
+/* 
+ *  color type for the vertex data
+ *  we probably want to use an internal datatype here?
+ */
+typedef struct {
+  GLubyte	blue;
+  GLubyte       green;
+  GLubyte       red;
+  GLubyte       alpha;
+} i810_color;
+
+
+/* A basic fixed format vertex to kick things off.  Move to dynamic
+ * layouts later on.  (see also the i810_full_vertex struct in
+ * i810_3d_reg.h)
+ */
+typedef struct {
+   GLfloat x,y,z;	        /* coordinates in screen space*/
+   GLfloat oow;			/* reciprocal homogeneous w */
+   i810_color color;		/* vertex color */
+   i810_color specular;		/* specular color, alpha is fog */
+   GLfloat tu0,tv0;		/* texture 0 */
+   GLfloat tu1,tv1;		/* texture 1 */
+} i810_vertex;
+
+
+/* Unfortunately only have assembly for 16-stride vertices.
+ */
+union i810_vertex_t {
+   i810_vertex v;
+   float f[16];
+};
+
+typedef union i810_vertex_t i810Vertex;
+typedef union i810_vertex_t *i810VertexPtr;
+
+struct i810_vertex_buffer_t {
+   GLvector1ui clipped_elements;
+   i810VertexPtr verts;
+   int last_vert;
+   GLuint *primitive;
+   GLuint *next_primitive;
+   void *vert_store;
+   GLuint size;
+};
+   
+typedef struct i810_vertex_buffer_t *i810VertexBufferPtr;
+
+
+#define I810_CONTEXT(ctx)    ((i810ContextPtr)(ctx->DriverCtx))
+#define I810_DRIVER_DATA(vb) ((i810VertexBufferPtr)((vb)->driver_data))
+
+
+#define I810_SPEC_BIT       0x1
+#define I810_FOG_BIT	    0x2
+#define I810_ALPHA_BIT      0x4	/* GL_BLEND, not used */
+#define I810_TEX1_BIT       0x8
+#define I810_TEX0_BIT       0x10	
+#define I810_RGBA_BIT       0x20
+#define I810_WIN_BIT        0x40
+
+
+extern void i810ChooseRasterSetupFunc(GLcontext *ctx);
+extern void i810PrintSetupFlags(char *msg, GLuint flags );
+extern void i810DDDoRasterSetup( struct vertex_buffer *VB );
+extern void i810DDPartialRasterSetup( struct vertex_buffer *VB );
+extern void i810DDCheckPartialRasterSetup( GLcontext *ctx, 
+					   struct gl_pipeline_stage *d );
+
+extern void i810DDViewport( GLcontext *ctx, 
+			   GLint x, GLint y, 
+			   GLsizei width, GLsizei height );
+
+extern void i810DDDepthRange( GLcontext *ctx, 
+			     GLclampd nearval, GLclampd farval );
+
+
+extern void i810DDUnregisterVB( struct vertex_buffer *VB );
+extern void i810DDRegisterVB( struct vertex_buffer *VB );
+extern void i810DDResizeVB( struct vertex_buffer *VB, GLuint size );
+
+extern void i810DDSetupInit( void );
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/Imakefile b/xc/lib/GL/mesa/src/drv/mga/Imakefile
new file mode 100644
index 000000000..9ff1203ee
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/Imakefile
@@ -0,0 +1,68 @@
+XCOMM $PI:$
+
+#define DoNormalLib NormalLibGlx
+#define DoSharedLib SharedLibGlx
+#define DoExtraLib SharedLibGlx
+#define DoDebugLib DebugLibGlx
+#define DoProfileLib ProfileLibGlx
+
+#if Malloc0ReturnsNull
+ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
+#endif
+
+#if BuildXF86DRI
+  DRI_DEFINES = GlxDefines -DDRIVERTS
+ DRI_INCLUDES = -I../../../../dri -I../../../../glx \
+		-I$(TOP)/include -I$(TOP)/include/GL \
+		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \
+		-I$(XF86DRIVERSRC)/mga \
+		-I../../../include -I../.. -I../../X -I../common \
+	        -I$(XF86OSSRC)/linux/drm/kernel
+#endif
+
+MESA_INCLUDES = -I. -I.. -I../../include
+
+
+
+      DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
+     INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \
+		-I/usr/include/glide
+      DRISRCS = mgaclear.c mgacnvtex.c mgadd.c mgadepth.c	\
+		mgafastpath.c					\
+		mgapipeline.c	\
+		mgaspan.c mgastate.c mgatex.c		\
+		mgatris.c mgavb.c mgaioctl.c mga_xmesa.c
+
+      DRIOBJS = mgaclear.o mgacnvtex.o mgadd.o mgadepth.o	\
+		mgafastpath.o					\
+		mgapipeline.o	\
+		mgaspan.o mgastate.o mgatex.o		\
+		mgatris.o mgavb.o mgaioctl.o mga_xmesa.o
+
+
+	 SRCS = $(DRISRCS) 
+	 OBJS = $(DRIOBJS) 
+
+#if !GlxUseBuiltInDRIDriver
+#undef DoNormalLib NormalLibGlx
+#undef DoExtraLib SharedLibGlx
+#undef DoDebugLib DebugLibGlx
+#undef DoProfileLib ProfileLibGlx
+#endif
+
+#include <Library.tmpl>
+
+LibraryObjectRule()
+
+SubdirLibraryRule($(OBJS))
+NormalLintTarget($(SRCS))
+
+#if !GlxUseBuiltInDRIDriver
+LIBNAME = mga_dri.so
+ALL_OBJS = $(OBJS)
+ALL_DEPS = DONE
+SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
+InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+#endif
+
+DependTarget()
diff --git a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c
new file mode 100644
index 000000000..8c42d0842
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c
@@ -0,0 +1,514 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Daryll Strauss <daryll@precisioninsight.com>
+ *
+ * $PI: $
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <X11/Xlibint.h>
+#include <stdio.h>
+
+#include "mga_xmesa.h"
+#include "context.h"
+#include "vbxform.h"
+#include "matrix.h"
+#include "simple_list.h"
+
+#include "mgadd.h"
+#include "mgastate.h"
+#include "mgatex.h"
+#include "mgaspan.h"
+#include "mgadepth.h"
+#include "mgatris.h"
+#include "mgapipeline.h"
+
+#include "xf86dri.h"
+#include "mga_dri.h"
+#include "mga_drm_public.h"
+#include "mga_xmesa.h"
+
+
+
+
+
+#ifndef MGA_DEBUG
+int MGA_DEBUG = (0
+/*  		  | MGA_DEBUG_ALWAYS_SYNC */
+/*  		  | MGA_DEBUG_VERBOSE_MSG */
+		  );
+#endif
+
+
+static mgaContextPtr      mgaCtx = 0;
+
+mgaGlx_t	mgaglx;
+
+static int count_bits(unsigned int n)
+{
+   int bits = 0;
+
+   while (n > 0) {
+      if (n & 1) bits++;
+      n >>= 1;
+   }
+   return bits;
+}
+
+/* These functions are accessed by dlsym from dri_mesa_init.c:
+ *
+ * XMesaInitDriver
+ * XMesaResetDriver
+ * XMesaCreateVisual
+ * XMesaDestroyVisual
+ * XMesaCreateContext 
+ * XMesaDestroyContext
+ * XMesaCreateWindowBuffer
+ * XMesaCreatePixmapBuffer
+ * XMesaDestroyBuffer
+ * XMesaSwapBuffers
+ * XMesaMakeCurrent
+ *
+ * So this is kind of the public interface to the driver.  The driver
+ * uses the X11 mesa driver context as a kind of wrapper around its
+ * own driver context - but there isn't much justificiation for doing
+ * it that way - the DRI might as well use a (void *) to refer to the
+ * driver contexts.  Nothing in the X context really gets used.
+ */
+
+
+GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv)
+{
+   mgaScreenPrivate *mgaScreen;
+   MGADRIPtr         gDRIPriv = (MGADRIPtr)sPriv->pDevPriv;
+
+   /* Allocate the private area */
+   mgaScreen = (mgaScreenPrivate *)Xmalloc(sizeof(mgaScreenPrivate));
+   if (!mgaScreen) return GL_FALSE;
+
+   mgaScreen->sPriv = sPriv;
+   sPriv->private = (void *)mgaScreen;
+
+   mgaScreen->chipset=gDRIPriv->chipset;
+   mgaScreen->width=gDRIPriv->width;
+   mgaScreen->height=gDRIPriv->height;
+   mgaScreen->mem=gDRIPriv->mem;
+   mgaScreen->cpp=gDRIPriv->cpp;
+   mgaScreen->frontPitch=gDRIPriv->frontPitch;
+   mgaScreen->frontOffset=gDRIPriv->frontOffset;
+   mgaScreen->backOffset=gDRIPriv->backOffset; 
+   mgaScreen->backPitch = gDRIPriv->backPitch;
+   mgaScreen->depthOffset=gDRIPriv->depthOffset;
+   mgaScreen->depthPitch = gDRIPriv->depthPitch;
+   mgaScreen->textureOffset=gDRIPriv->textureOffset;
+   mgaScreen->textureSize=gDRIPriv->textureSize;
+   mgaScreen->logTextureGranularity = gDRIPriv->logTextureGranularity;
+
+
+   mgaScreen->bufs = drmMapBufs(sPriv->fd);
+
+
+   /* Other mgaglx stuff, too??
+    */
+   memset(&mgaglx, 0, sizeof(mgaglx));
+
+   mgaDDFastPathInit();
+   mgaDDTrifuncInit();
+   mgaDDSetupInit();
+
+   return GL_TRUE;
+}
+
+/* Accessed by dlsym from dri_mesa_init.c
+ */
+void XMesaResetDriver(__DRIscreenPrivate *sPriv)
+{
+   Xfree(sPriv->private);
+}
+
+/* Accessed by dlsym from dri_mesa_init.c
+ */
+XMesaVisual XMesaCreateVisual(XMesaDisplay *display,
+			      XMesaVisualInfo visinfo,
+			      GLboolean rgb_flag,
+			      GLboolean alpha_flag,
+			      GLboolean db_flag,
+			      GLboolean stereo_flag,
+			      GLboolean ximage_flag,
+			      GLint depth_size,
+			      GLint stencil_size,
+			      GLint accum_size,
+			      GLint level)
+{
+   XMesaVisual v;
+
+   /* Only RGB visuals are supported on the MGA boards */
+   if (!rgb_flag) return 0;
+
+   v = (XMesaVisual)Xmalloc(sizeof(struct xmesa_visual));
+   if (!v) return 0;
+
+   v->visinfo = (XVisualInfo *)Xmalloc(sizeof(*visinfo));
+   if(!v->visinfo) {
+      Xfree(v);
+      return 0;
+   }
+   memcpy(v->visinfo, visinfo, sizeof(*visinfo));
+
+   v->display = display;
+   v->level = level;
+  
+   v->gl_visual = (GLvisual *)Xmalloc(sizeof(GLvisual));
+   if (!v->gl_visual) {
+      Xfree(v->visinfo);
+      XFree(v);
+      return 0;
+   }
+
+   v->gl_visual->RGBAflag   = rgb_flag;
+   v->gl_visual->DBflag     = db_flag;
+   v->gl_visual->StereoFlag = stereo_flag;
+
+   v->gl_visual->RedBits   = count_bits(visinfo->red_mask);
+   v->gl_visual->GreenBits = count_bits(visinfo->green_mask);
+   v->gl_visual->BlueBits  = count_bits(visinfo->blue_mask);
+   v->gl_visual->AlphaBits = 0; /* Not currently supported */
+
+   v->gl_visual->AccumBits   = accum_size;
+   v->gl_visual->DepthBits   = depth_size;
+   v->gl_visual->StencilBits = stencil_size;
+
+   return v;
+}
+
+void XMesaDestroyVisual(XMesaVisual v)
+{
+   Xfree(v->gl_visual);
+   Xfree(v->visinfo);
+   Xfree(v);
+}
+
+XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list,
+				__DRIcontextPrivate *driContextPriv)
+{
+   GLcontext *ctx;
+   XMesaContext c;
+   mgaContextPtr mmesa;
+   __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
+   mgaScreenPrivate *mgaScreen = (mgaScreenPrivate *)sPriv->private;
+   drm_mga_sarea_t *saPriv=(drm_mga_sarea_t*)(((char*)sPriv->pSAREA)+
+					      sizeof(XF86DRISAREARec));
+   GLcontext *shareCtx = 0;
+
+   c = (XMesaContext)Xmalloc(sizeof(struct xmesa_context));
+   if (!c) {
+      return 0;
+   }
+
+   mmesa = (mgaContextPtr)Xmalloc(sizeof(mgaContext));
+   if (!mmesa) {
+      Xfree(c);
+      return 0;
+   }
+
+   c->driContextPriv = driContextPriv;
+   c->xm_visual = v;
+   c->xm_buffer = 0; /* Set by MakeCurrent */
+   c->display = v->display;
+   c->private = (void *)mmesa;
+
+   if (share_list)
+      shareCtx=((mgaContextPtr)(share_list->private))->glCtx;
+
+   ctx = mmesa->glCtx = gl_create_context(v->gl_visual, shareCtx, 
+					  (void*)mmesa, GL_TRUE);
+
+   /* Dri stuff
+    */
+   mmesa->display = v->display;
+   mmesa->hHWContext = driContextPriv->hHWContext;
+   mmesa->driFd = sPriv->fd;
+   mmesa->driHwLock = &sPriv->pSAREA->lock;
+
+   mmesa->mgaScreen = mgaScreen;
+   mmesa->driScreen = sPriv;
+   mmesa->sarea = saPriv;
+
+   mmesa->glBuffer=gl_create_framebuffer(v->gl_visual);
+
+
+   mmesa->needClip=1;
+
+   mmesa->texHeap = mmInit( 0, mgaScreen->textureSize );
+
+   /* Utah stuff
+    */
+   mmesa->renderindex = -1;		/* impossible value */
+   mmesa->new_state = ~0;
+   mmesa->dirty = ~0;
+
+   mmesa->warp_pipe = 0;
+
+
+   make_empty_list(&mmesa->SwappedOut);
+   make_empty_list(&mmesa->TexObjList);
+   
+   mmesa->CurrentTexObj[0] = 0;
+   mmesa->CurrentTexObj[1] = 0;
+   
+   mgaDDExtensionsInit( ctx );
+
+   mgaDDInitStateFuncs( ctx );
+   mgaDDInitTextureFuncs( ctx );
+   mgaDDInitSpanFuncs( ctx );
+   mgaDDInitDepthFuncs( ctx );
+   mgaDDInitDriverFuncs( ctx );
+   mgaDDInitIoctlFuncs( ctx );
+
+
+   ctx->Driver.TriangleCaps = (DD_TRI_CULL|
+			       DD_TRI_LIGHT_TWOSIDE|
+			       DD_TRI_OFFSET);
+
+   /* Ask mesa to clip fog coordinates for us.
+    */
+   ctx->TriangleCaps |= DD_CLIP_FOG_COORD;
+
+   ctx->Shared->DefaultD[2][0].DriverData = 0;
+   ctx->Shared->DefaultD[2][1].DriverData = 0;
+
+   if (ctx->VB) 
+      mgaDDRegisterVB( ctx->VB );
+
+   if (ctx->NrPipelineStages)
+      ctx->NrPipelineStages =
+	 mgaDDRegisterPipelineStages(ctx->PipelineStage,
+				      ctx->PipelineStage,
+				      ctx->NrPipelineStages);
+   return c;
+}
+
+void XMesaDestroyContext(XMesaContext c)
+{
+   mgaContextPtr mmesa = (mgaContextPtr) c->private;
+
+   if (mmesa) {
+/*        mgaTextureObjectPtr next_t, t; */
+
+      gl_destroy_context(mmesa->glCtx);
+      gl_destroy_framebuffer(mmesa->glBuffer);
+
+/*        foreach_s (t, next_t, &(mmesa->TexObjList)) */
+/*  	 mgaDestroyTexObj(mmesa, t); */
+
+/*        foreach_s (t, next_t, &(mmesa->SwappedOut)) */
+/*  	 mgaDestroyTexObj(mmesa, t); */
+
+      Xfree(mmesa);
+
+      c->private = 0;
+   }
+}
+
+XMesaBuffer XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w,
+				    __DRIdrawablePrivate *driDrawPriv)
+{
+  return (XMesaBuffer)1;
+}
+
+XMesaBuffer XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p,
+				    XMesaColormap c, 
+				    __DRIdrawablePrivate *driDrawPriv)
+{
+  return (XMesaBuffer)1;
+}
+
+void XMesaDestroyBuffer(XMesaBuffer b)
+{
+}
+
+void XMesaSwapBuffers(XMesaBuffer bogus_value_do_not_use)
+{
+   mgaContextPtr mmesa = mgaCtx;    
+   FLUSH_VB( mmesa->glCtx, "swap buffers" );
+   mgaSwapBuffers(mmesa);
+}
+
+
+
+
+
+void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa )
+{
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
+
+   mmesa->numClipRects = dPriv->numClipRects;
+   mmesa->pClipRects = dPriv->pClipRects;
+   mmesa->drawX = dPriv->x;
+   mmesa->drawY = dPriv->y;
+
+   mmesa->drawOffset = mmesa->mgaScreen->frontOffset;
+}
+
+
+void mgaXMesaSetBackClipRects( mgaContextPtr mmesa )
+{
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
+
+   if (dPriv->numAuxClipRects == 0) 
+   {
+      mmesa->numClipRects = dPriv->numClipRects;
+      mmesa->pClipRects = dPriv->pClipRects;
+      mmesa->drawX = dPriv->x;
+      mmesa->drawY = dPriv->y;
+   } else {
+      mmesa->numClipRects = dPriv->numAuxClipRects;
+      mmesa->pClipRects = dPriv->pAuxClipRects;
+      mmesa->drawX = dPriv->auxX;
+      mmesa->drawY = dPriv->auxY;
+   }
+
+   mmesa->drawOffset = mmesa->mgaScreen->backOffset;
+}
+
+
+static void mgaXMesaWindowMoved( mgaContextPtr mmesa ) 
+{
+   /* Clear any contaminated CVA data.
+    */
+   mmesa->setupdone = 0;
+
+   switch (mmesa->glCtx->Color.DriverDrawBuffer) {
+   case GL_FRONT_LEFT:
+      mgaXMesaSetFrontClipRects( mmesa );
+      break;
+   case GL_BACK_LEFT:
+      mgaXMesaSetBackClipRects( mmesa );
+      break;
+   default:
+      fprintf(stderr, "fallback buffer\n");
+      break;
+   }
+
+}
+
+
+/* This looks buggy to me - the 'b' variable isn't used anywhere...
+ * Hmm - It seems that the drawable is already hooked in to
+ * driDrawablePriv.  
+ *
+ * But why are we doing context initialization here???
+ */
+GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b)
+{
+
+   if (c->private==(void *)mgaCtx) return GL_TRUE;
+
+   if (c) {
+      __DRIdrawablePrivate *dPriv = c->driContextPriv->driDrawablePriv;
+
+      mgaCtx = (mgaContextPtr)c->private;
+
+
+      gl_make_current(mgaCtx->glCtx, mgaCtx->glBuffer);
+
+      mgaXMesaWindowMoved( mgaCtx );
+      mgaCtx->driDrawable = dPriv;
+      mgaCtx->dirty = ~0;
+
+      if (!mgaCtx->glCtx->Viewport.Width)
+	 gl_Viewport(mgaCtx->glCtx, 0, 0, dPriv->w, dPriv->h);
+
+   } else {
+      gl_make_current(0,0);
+      mgaCtx = NULL;
+   }
+
+   return GL_TRUE;
+}
+
+
+void mgaXMesaUpdateState( mgaContextPtr mmesa ) 
+{
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
+   __DRIscreenPrivate *sPriv = mmesa->driScreen;
+   drm_mga_sarea_t *sarea = mmesa->sarea;
+
+   int me = mmesa->hHWContext;
+   int stamp = dPriv->lastStamp; 
+
+   /* If the window moved, may need to set a new cliprect now.
+    *
+    * NOTE: This releases and regains the hw lock, so all state
+    * checking must be done *after* this call:
+    */
+   XMESA_VALIDATE_DRAWABLE_INFO(mmesa->display, sPriv, dPriv);		
+
+   if (sarea->ctxOwner != me) {
+      mmesa->dirty |= MGA_UPLOAD_CTX;
+   }
+
+   if (sarea->texAge != mmesa->texAge) {
+      int sz = 1 << (mmesa->mgaScreen->logTextureGranularity);
+      int idx, nr = 0;
+
+      /* Have to go right round from the back to ensure stuff ends up
+       * LRU in our local list...
+       */
+      for (idx = sarea->texList[MGA_NR_TEX_REGIONS].prev ; 
+	   idx != MGA_NR_TEX_REGIONS && nr < MGA_NR_TEX_REGIONS ; 
+	   idx = sarea->texList[idx].prev, nr++)
+      {
+	 if (sarea->texList[idx].age > mmesa->texAge)
+	    mgaTexturesGone(mmesa, idx * sz, sz, 1);
+      }
+
+      if (nr == MGA_NR_TEX_REGIONS) {
+	 mgaTexturesGone(mmesa, 0, mmesa->mgaScreen->textureSize, 0);
+	 mgaResetGlobalLRU( mmesa );
+      }
+
+      mmesa->texAge = sarea->texAge;
+      mmesa->dirty |= MGA_UPLOAD_TEX0IMAGE | MGA_UPLOAD_TEX1IMAGE;
+   }
+
+   if (dPriv->lastStamp != stamp) 
+      mgaXMesaWindowMoved( mmesa );
+
+   sarea->ctxOwner=me;
+}
+
+
+
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h
new file mode 100644
index 000000000..c24e982d0
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h
@@ -0,0 +1,121 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Keith Whitwell <keithw@precisioninsight.com>
+ *   Daryll Strauss <daryll@precisioninsight.com> (Origninal tdfx driver).
+ *
+ * $PI: $
+ */
+
+#ifndef _MGA_INIT_H_
+#define _MGA_INIT_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <sys/time.h>
+#include "dri_tmm.h"
+#include "dri_mesaint.h"
+#include "dri_mesa.h"
+#include "types.h"
+#include "xmesaP.h"
+
+typedef struct {
+
+   int chipset;
+   int width;
+   int height;
+   int mem;
+
+   int cpp;			/* for front and back buffers */
+
+   int Attrib;
+
+   int frontOffset;
+   int frontPitch;
+   int backOffset;
+   int backPitch;
+
+   int depthOffset;
+   int depthPitch;
+   int depthCpp;
+
+   int textureOffset;
+   int textureSize;
+   int logTextureGranularity;
+
+   __DRIscreenPrivate *sPriv;
+   drmBufMapPtr  bufs;
+
+} mgaScreenPrivate;
+
+
+#include "mgalib.h"
+
+extern void mgaXMesaUpdateState( mgaContextPtr mmesa );
+extern void mgaEmitHwStateLocked( mgaContextPtr mmesa );
+extern void mgaEmitScissorValues( mgaContextPtr mmesa, int box_nr, int emit );
+extern void mgaXMesaSetBackClipRects( mgaContextPtr mmesa );
+extern void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa );
+
+
+
+/* Lock the hardware and validate our state.  
+ */
+#define LOCK_HARDWARE( mmesa )				\
+  do {							\
+    char __ret=0;					\
+    DRM_CAS(mmesa->driHwLock, mmesa->hHWContext,	\
+	    (DRM_LOCK_HELD|mmesa->hHWContext), __ret);	\
+    if (__ret) {					\
+        drmGetLock(mmesa->driFd, mmesa->hHWContext, 0);	\
+        mgaXMesaUpdateState( mmesa );			\
+    }							\
+  } while (0)
+
+
+/* Unlock the hardware using the global current context 
+ */
+#define UNLOCK_HARDWARE(mmesa)					\
+    DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext);	
+
+
+/* Freshen our snapshot of the drawables
+ */
+#define REFRESH_DRAWABLE_INFO( mmesa )		\
+do {						\
+   LOCK_HARDWARE( mmesa );			\
+   UNLOCK_HARDWARE( mmesa );			\
+} while (0)
+
+
+#define GET_DRAWABLE_LOCK( mmesa ) while(0)
+#define RELEASE_DRAWABLE_LOCK( mmesa ) while(0)
+
+#endif
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaclear.c b/xc/lib/GL/mesa/src/drv/mga/mgaclear.c
new file mode 100644
index 000000000..48b9b30a7
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaclear.c
@@ -0,0 +1,10 @@
+#include "types.h"
+#include "vbrender.h"
+
+#include <stdio.h>
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgadd.h"
+#include "mgaclear.h"
+#include "mgastate.h"
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaclear.h b/xc/lib/GL/mesa/src/drv/mga/mgaclear.h
new file mode 100644
index 000000000..15a723d65
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaclear.h
@@ -0,0 +1,7 @@
+#ifndef _MGA_CLEAR_H
+#define _MGA_CLEAR_H
+
+extern GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+			    GLint x, GLint y, GLint width, GLint height );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c b/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c
new file mode 100644
index 000000000..ae8d95037
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c
@@ -0,0 +1,250 @@
+/* -*- mode: C; c-basic-offset:8 -*- */
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    original by Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ *	9/20/99 rewrite by John Carmack <johnc@idsoftware.com>
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <GL/gl.h>
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgatex.h"
+
+
+/*
+ * mgaConvertTexture
+ * Converts a mesa format texture to the apropriate hardware format
+ * Note that sometimes width may be larger than the texture, like 64x1
+ * for an 8x8 texture.  This happens when we have to crutch the pitch
+ * limits of the mga by uploading a block of texels as a single line.
+ */
+void mgaConvertTexture( mgaUI32 *destPtr, int texelBytes, 
+			struct gl_texture_image *image,
+			int x, int y, int width, int height ) {
+	register int		i, j;
+	mgaUI8		*src;
+	int stride;
+	
+	/* FIXME: g400 luminance_alpha internal format */
+	switch (texelBytes) {
+	  case 1:
+	    switch (image->Format) {
+		   case GL_COLOR_INDEX:
+		   case GL_INTENSITY:
+		   case GL_LUMINANCE:
+		   case GL_ALPHA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 2  ; j ; j-- ) {
+			
+				   *destPtr++ = src[0] | ( src[1] << 8 ) | ( src[2] << 16 ) | ( src[3] << 24 );
+				   src += 4;
+			    }
+				 src += stride;
+		     }
+			  break;
+			default:
+			  goto format_error;
+		 }
+		 break;
+	  case 2:
+	    switch (image->Format) {
+			case GL_RGB:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 3;
+			  stride = (image->Width - width) * 3;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR565(src[0],src[1],src[2]) |  
+					   ( MGAPACKCOLOR565(src[3],src[4],src[5]) << 16 );
+				   src += 6;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_RGBA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 4;
+			  stride = (image->Width - width) * 4;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR4444(src[0],src[1],src[2],src[3]) |  
+				   	( MGAPACKCOLOR4444(src[4],src[5],src[6],src[7]) << 16 );
+				   src += 8;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_LUMINANCE:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+				   /* FIXME: should probably use 555 texture to get true grey */
+				   *destPtr++ = MGAPACKCOLOR565(src[0],src[0],src[0]) |  
+					   ( MGAPACKCOLOR565(src[1],src[1],src[1]) << 16 );
+				   src += 2;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_INTENSITY:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[0]) |  
+					   ( MGAPACKCOLOR4444(src[1],src[1],src[1],src[1]) << 16 );
+				   src += 2;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_ALPHA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR4444(255,255,255,src[0]) |  
+					   ( MGAPACKCOLOR4444(255,255,255,src[1]) << 16 );
+				   src += 2;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_LUMINANCE_ALPHA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2;
+			  stride = (image->Width - width) * 2;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width >> 1  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[1]) |  
+					   ( MGAPACKCOLOR4444(src[2],src[2],src[2],src[3]) << 16 );
+				   src += 4;
+			    }
+				 src += stride;
+		     }
+			  break;
+			default:
+			  goto format_error;
+		 }
+		 break;
+	  case 4:
+		 switch (image->Format) {
+			case GL_RGB:
+ 	        src = (mgaUI8 *)image->Data + (  y * image->Width + x ) * 3;
+			  stride = (image->Width - width) * 3;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2], 255);
+				   src += 3;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_RGBA:
+ 	        src = (mgaUI8 *)image->Data + (  y * image->Width + x ) * 4;
+			  stride = (image->Width - width) * 4;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width  ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2],src[3]);
+				   src += 4;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_LUMINANCE:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0], 255);
+				   src += 1;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_INTENSITY:
+ 	        src = (mgaUI8 *)image->Data + (  y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0],src[0]);
+				   src += 1;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_ALPHA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x );
+			  stride = (image->Width - width);
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(255,255,255,src[0]);
+				   src += 1;
+			    }
+				 src += stride;
+		     }
+			  break;
+			case GL_LUMINANCE_ALPHA:
+ 	        src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2;
+			  stride = (image->Width - width) * 2;
+		     for ( i = height ; i ; i-- ) {
+			    for ( j = width ; j ; j-- ) {
+			
+				   *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],
+						       src[0],src[1]);
+				   src += 2;
+			    }
+				 src += stride;
+		     }
+			  break;
+			default:
+			  goto format_error;
+		 }
+		 break;
+	  default:
+		 goto format_error;
+	}
+
+	return;
+
+format_error:
+
+		mgaError( "Unsupported texelBytes %i, image->Format %i\n", 
+			  texelBytes, image->Format );
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgacommon.h b/xc/lib/GL/mesa/src/drv/mga/mgacommon.h
new file mode 100644
index 000000000..fd7c7987f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgacommon.h
@@ -0,0 +1,44 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+
+#ifndef MGACOMMON_INC
+#define MGACOMMON_INC
+
+typedef unsigned int mgaUI32;
+typedef unsigned short mgaUI16;
+typedef unsigned char mgaUI8;
+typedef int mgaI32;
+typedef short mgaI16;
+typedef char mgaI8;
+
+typedef mgaUI8 mgaColor[4];
+
+struct mga_context_t;
+typedef struct mga_context_t mgaContext;
+typedef struct mga_context_t *mgaContextPtr;
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadd.c b/xc/lib/GL/mesa/src/drv/mga/mgadd.c
new file mode 100644
index 000000000..ad56cbbc3
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadd.c
@@ -0,0 +1,146 @@
+/*
+ * GLX Hardware Device Driver for Matrox G200/G400
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+
+
+#include "types.h"
+#include "vbrender.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgaclear.h"
+#include "mgadd.h"
+#include "mgadepth.h"
+#include "mgalog.h"
+#include "mgastate.h"
+#include "mgaspan.h"
+#include "mgatex.h"
+#include "mgatris.h"
+#include "mgavb.h"
+#include "mgapipeline.h"
+#include "extensions.h"
+#include "vb.h"
+#include "dd.h"
+
+
+
+/***************************************
+ * Mesa's Driver Functions
+ ***************************************/
+
+
+static const GLubyte *mgaDDGetString( GLcontext *ctx, GLenum name )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   switch (name) {
+   case GL_VENDOR:
+      return "Utah GLX";
+   case GL_RENDERER:
+      if (MGA_IS_G200(mmesa)) return "GLX-MGA-G200";
+      if (MGA_IS_G400(mmesa)) return "GLX-MGA-G400";
+      return "GLX-MGA";
+   default:
+      return 0;
+   }
+}
+
+
+static GLint mgaGetParameteri(const GLcontext *ctx, GLint param)
+{
+  switch (param) {
+  case DD_HAVE_HARDWARE_FOG:  
+    return 1; 
+  default:
+    mgaError("mgaGetParameteri(): unknown parameter!\n");
+    return 0;
+  }
+}
+
+
+static void mgaBufferSize(GLcontext *ctx, GLuint *width, GLuint *height)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);  
+   
+/*     LOCK_HARDWARE( mmesa ); */
+   *width = mmesa->driDrawable->w;
+   *height = mmesa->driDrawable->h;
+/*     UNLOCK_HARDWARE( mmesa ); */
+}
+
+void mgaDDExtensionsInit( GLcontext *ctx )
+{
+   /* paletted_textures currently doesn't work, but we could fix them later */
+   gl_extensions_disable( ctx, "GL_EXT_shared_texture_palette" );
+   gl_extensions_disable( ctx, "GL_EXT_paletted_texture" );
+
+   /* Support multitexture only on the g400.
+    */
+   if (!MGA_IS_G400(MGA_CONTEXT(ctx))) 
+   {
+      gl_extensions_disable( ctx, "GL_EXT_multitexture" );
+      gl_extensions_disable( ctx, "GL_SGIS_multitexture" );
+      gl_extensions_disable( ctx, "GL_ARB_multitexture" );
+   }
+
+   /* Turn on texenv_add for the G400.
+    */
+   if (MGA_IS_G400(MGA_CONTEXT(ctx)))
+   {
+      gl_extensions_enable( ctx, "GL_EXT_texture_env_add" );
+   }
+
+   /* we don't support point parameters in hardware yet */
+   gl_extensions_disable( ctx, "GL_EXT_point_parameters" );
+
+   /* No support for fancy imaging stuff.  This should kill off 
+    * a few rogue fallbacks.
+    */
+   gl_extensions_disable( ctx, "ARB_imaging" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_minmax" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_logic_op" );
+   gl_extensions_disable( ctx, "GL_EXT_blend_subtract" );
+   gl_extensions_disable( ctx, "GL_INGR_blend_func_separate" );   
+}
+
+
+
+
+
+
+
+void mgaDDInitDriverFuncs( GLcontext *ctx )
+{
+   ctx->Driver.GetBufferSize = mgaBufferSize;
+   ctx->Driver.GetString = mgaDDGetString;
+   ctx->Driver.GetParameteri = mgaGetParameteri;
+   ctx->Driver.RegisterVB = mgaDDRegisterVB;
+   ctx->Driver.UnregisterVB = mgaDDUnregisterVB;
+   ctx->Driver.BuildPrecalcPipeline = mgaDDBuildPrecalcPipeline;
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadd.h b/xc/lib/GL/mesa/src/drv/mga/mgadd.h
new file mode 100644
index 000000000..0bd4c712e
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadd.h
@@ -0,0 +1,36 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+
+#ifndef MGADD_INC
+#define MGADD_INC
+
+#include "context.h"
+
+void mgaDDInitDriverFuncs( GLcontext *ctx );
+void mgaDDExtensionsInit( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadepth.c b/xc/lib/GL/mesa/src/drv/mga/mgadepth.c
new file mode 100644
index 000000000..0d55137d1
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadepth.c
@@ -0,0 +1,636 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   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, 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.
+ */
+
+/*
+ * This file has been modified by Wittawat Yamwong for GLX module.
+ */
+
+/*
+ * Depth buffer functions
+ */
+
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include <stdlib.h>
+#include <string.h>
+#include "context.h"
+#include "mgadepth.h"
+#include "types.h"
+#include "mm.h"
+#include "mgalib.h"
+#endif
+
+
+
+/*
+ * Return the address of the Z-buffer value for window coordinate (x,y):
+ */
+#define Z_SETUP								\
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);				\
+   __DRIscreenPrivate *sPriv = mmesa->driScreen;			\
+   mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;			\
+   GLdepth *zbstart = (GLdepth *)(sPriv->pFB + mgaScreen->depthOffset);\
+   GLint zbpitch = mgaScreen->depthPitch
+
+#define Z_ADDRESS( X, Y )  \
+  (zbstart + zbpitch * (Y) + (X))
+
+
+/**********************************************************************/
+/*****                   Depth Testing Functions                  *****/
+/**********************************************************************/
+
+
+/*
+ * Depth test horizontal spans of fragments.  These functions are called
+ * via ctx->Driver.depth_test_span only.
+ *
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in span in window coords
+ *         z - array [n] of integer depth values
+ * In/Out:  mask - array [n] of flags (1=draw pixel, 0=don't draw) 
+ * Return:  number of pixels which passed depth test
+ */
+
+
+/*
+ * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
+ */
+static GLuint mga_depth_test_span_generic( GLcontext* ctx,
+					   GLuint n, GLint x, GLint y,
+					   const GLdepth z[],
+					   GLubyte mask[] )
+{
+   Z_SETUP;
+   GLdepth *zptr = Z_ADDRESS( x, y );
+   GLubyte *m = mask;
+   GLuint i;
+   GLuint passed = 0;
+
+   LOCK_HARDWARE(mmesa);
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     /* fail */
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] <= *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] >= *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] > *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] != *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] == *zptr) {
+		     *zptr = z[i];
+		     passed++;
+		  }
+		  else {
+		     *m =0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     *m =0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0;i<n;i++,zptr++,m++) {
+	       if (*m) {
+		  *zptr = z[i];
+		  passed++;
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	    passed = n;
+	 }
+	 break;
+      case GL_NEVER:
+	 for (i=0;i<n;i++) {
+	    mask[i] = 0;
+	 }
+	 break;
+      default:
+   }
+
+   UNLOCK_HARDWARE(mmesa);
+
+   return passed;
+}
+
+
+
+
+
+/*
+ * Depth test an array of randomly positioned fragments.
+ */
+
+/*
+ * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ).
+ */
+static void mga_depth_test_pixels_generic( GLcontext* ctx,
+					   GLuint n, 
+					   const GLint x[], const GLint y[],
+					   const GLdepth z[], GLubyte mask[] )
+{
+   Z_SETUP;
+   register GLdepth *zptr;
+   register GLuint i;
+
+   LOCK_HARDWARE(mmesa);
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zptr = Z_ADDRESS(x[i],y[i]);
+		  *zptr = z[i];
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	 }
+	 break;
+      case GL_NEVER:
+	 /* depth test never passes */
+	 for (i=0;i<n;i++) {
+	    mask[i] = 0;
+	 }
+	 break;
+      default:
+    } 
+
+   UNLOCK_HARDWARE(mmesa);
+}
+
+
+
+/**********************************************************************/
+/*****                      Read Depth Buffer                     *****/
+/**********************************************************************/
+
+
+/*
+ * Return a span of depth values from the depth buffer as floats in [0,1].
+ * This function is only called through Driver.read_depth_span_float()
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  depth - the array of depth values
+ */
+static void mga_read_depth_span_float( GLcontext* ctx,
+				       GLuint n, GLint x, GLint y, 
+				       GLfloat depth[] )
+{
+   Z_SETUP;
+   GLdepth *zptr;
+   GLfloat scale;
+   GLuint i;
+
+   LOCK_HARDWARE(mmesa);
+
+   scale = 1.0F / DEPTH_SCALE;
+
+   if (ctx->Buffer->Depth) {
+      zptr = Z_ADDRESS( x, y );
+      for (i=0;i<n;i++) {
+	 depth[i] = (GLfloat) zptr[i] * scale;
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+	 depth[i] = 0.0F;
+      }
+   }
+   
+   UNLOCK_HARDWARE(mmesa);
+}
+
+
+/*
+ * Return a span of depth values from the depth buffer as integers in
+ * [0,MAX_DEPTH].
+ * This function is only called through Driver.read_depth_span_int()
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  depth - the array of depth values
+ */
+static void mga_read_depth_span_int( GLcontext* ctx,
+				     GLuint n, GLint x, GLint y, 
+				     GLdepth depth[] )
+{
+   Z_SETUP;
+   
+   LOCK_HARDWARE(mmesa);
+      
+   if (ctx->Buffer->Depth) {
+      GLdepth *zptr = Z_ADDRESS( x, y );
+      MEMCPY( depth, zptr, n * sizeof(GLdepth) );
+   }
+   else {
+      GLuint i;
+      for (i=0;i<n;i++) {
+	 depth[i] = 0;
+      }
+   }
+   
+   UNLOCK_HARDWARE(mmesa);
+}
+
+
+void mgaDDInitDepthFuncs( GLcontext *ctx )
+{
+   ctx->Driver.ReadDepthSpanFloat = mga_read_depth_span_float;
+   ctx->Driver.ReadDepthSpanInt = mga_read_depth_span_int;
+   ctx->Driver.DepthTestSpan = mga_depth_test_span_generic;
+   ctx->Driver.DepthTestPixels = mga_depth_test_pixels_generic;
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadepth.h b/xc/lib/GL/mesa/src/drv/mga/mgadepth.h
new file mode 100644
index 000000000..e47a114ee
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadepth.h
@@ -0,0 +1,37 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   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, 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.
+ */
+
+/*
+ * This file has been modified by Wittawat Yamwong for GLX module.
+ */
+
+
+#ifndef MGADEPTH_INC
+#define MGADEPTH_INC
+
+
+#include "types.h"
+void mgaDDInitDepthFuncs( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadma.c b/xc/lib/GL/mesa/src/drv/mga/mgadma.c
new file mode 100644
index 000000000..becfb32f5
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadma.c
@@ -0,0 +1,59 @@
+/* -*- mode: C; c-basic-offset:8 -*- */
+/*
+ * GLX Hardware Device Driver for Matrox G200/G400
+ * Copyright (C) 1999 Jeff Hartmann
+ *
+ * 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
+ * JEFF HARTMANN, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ * original by Jeff Hartmann <slicer@ionet.net>
+ * 6/16/99: rewrite by John Carmack <johnc@idsoftware.com>
+ * 1/13/00: rewrite for DRI by Keith Whitwell <keithw@precisioninsight.com>
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
+
+#include "mm.h"
+#include "mgabuf.h"
+#include "mgadd.h"
+#include "mgalib.h"
+#include "mgalog.h"
+#include "mgastate.h"
+#include "mgaglx.h"
+
+#include "pb.h"
+
+
+
+
+
+
+
+
+
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadma.h b/xc/lib/GL/mesa/src/drv/mga/mgadma.h
new file mode 100644
index 000000000..9a02d1f36
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgadma.h
@@ -0,0 +1,41 @@
+/*
+  GLX Hardware Device Driver for Matrox Millenium G200
+  Copyright (C) 1999  Stephen Crowley (crow@debian.org)
+  
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  any later version.
+  
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  
+ original by Jeff Hartmann <slicer@ionet.net>
+  6/16/99: rewrite by John Carmack <johnc@idsoftware.com>
+*/
+
+#ifndef MGADMA_H
+#define MGADMA_H
+
+#include "mgacommon.h"
+#include "mm.h"
+#include <stdio.h>
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c b/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c
new file mode 100644
index 000000000..8017e7f02
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c
@@ -0,0 +1,529 @@
+/*
+ * GLX Hardware Device Driver for Intel i810
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 <stdio.h>
+
+#include "types.h"
+#include "enums.h"
+#include "cva.h"
+#include "vertices.h"
+#include "mmath.h"
+
+#include "mgalib.h"
+#include "mgapipeline.h"
+#include "mgatris.h"
+#include "mgastate.h"
+#include "mgavb.h"
+
+
+extern void mgaDDResizeVB( struct vertex_buffer *VB, GLuint size );
+
+extern void gl_fast_copy_vb( struct vertex_buffer *VB );
+  
+struct mga_fast_tab {
+   void (*build_vertices)( struct vertex_buffer *VB, GLuint do_cliptest );
+   void (*interp)( GLfloat t, GLfloat *O, const GLfloat *I, const GLfloat *J );
+};
+
+
+
+
+#define POINT(x) mga_draw_point(mmesa, &ivert[x], psize)
+#define LINE(x,y) mga_draw_line(mmesa, &ivert[x], &ivert[y], lwidth)
+#define TRI(x,y,z) mga_draw_triangle(mmesa, &ivert[x], &ivert[y], &ivert[z])
+
+
+
+
+/* Direct, and no clipping required.  I haven't written the clip funcs
+ * yet, so this is only useful for the fast path.
+ */
+#define RENDER_POINTS( start, count )		\
+do {						\
+   GLuint e;					\
+   for(e=start;e<=count;e++)			\
+     POINT(elt[e]);				\
+} while (0)
+
+#define RENDER_LINE( i1, i )			\
+do {						\
+   GLuint e1 = elt[i1], e = elt[i];		\
+   LINE( e1, e );				\
+} while (0)
+
+
+#define RENDER_TRI( i2, i1, i, pv, parity)		\
+do {							\
+{  GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  if (parity) {GLuint tmp = e2; e2 = e1; e1 = tmp;}	\
+  TRI(e2, e1, e);					\
+}} while (0)
+
+
+#define RENDER_QUAD( i3, i2, i1, i, pv)				\
+do {								\
+  GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  TRI(e3, e2, e);						\
+  TRI(e2, e1, e);						\
+} while (0)
+
+#define LOCAL_VARS					\
+   mgaVertexPtr ivert = MGA_DRIVER_DATA(VB)->verts;	\
+   const GLuint *elt = VB->EltPtr->data;		\
+   GLcontext *ctx = VB->ctx;				\
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);	\
+   const GLfloat lwidth = ctx->Line.Width;		\
+   const GLfloat psize = ctx->Point.Size;		\
+   (void) lwidth; (void)psize; (void) ivert;
+
+
+#define TAG(x) x##_mga_smooth_indirect
+#include "render_tmp.h"
+
+
+
+static void mga_render_elements_direct( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLenum prim = ctx->CVA.elt_mode;
+   GLuint nr = VB->EltPtr->count;
+   render_func func = render_tab_mga_smooth_indirect[prim];
+   GLuint p = 0;
+   
+   if (mmesa->new_state)
+      mgaDDUpdateHwState( ctx );
+
+   do {
+      func( VB, 0, nr, 0 );
+   } while (ctx->Driver.MultipassFunc &&
+	    ctx->Driver.MultipassFunc( VB, ++p ));
+}
+
+
+
+#define NEGATIVE(f)          (f < 0)
+#define DIFFERENT_SIGNS(a,b) ((a*b) < 0)
+#define LINTERP( T, A, B )   ( (A) + (T) * ( (B) - (A) ) )
+
+
+#define INTERP_RGBA(t, out, a, b) {			\
+   int i;						\
+   for (i = 0; i < 4; i++) {				\
+      GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a[i]);	\
+      GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b[i]);	\
+      GLfloat fo = LINTERP(t, fa, fb);			\
+      FLOAT_COLOR_TO_UBYTE_COLOR(out[i], fo);		\
+   }							\
+}
+
+
+#define CLIP(SGN,V,PLANE)					\
+if (mask & PLANE) {						\
+   GLuint *indata = inlist[in];					\
+   GLuint *outdata = inlist[in ^= 1];				\
+   GLuint nr = n;						\
+   GLfloat *J = verts[indata[nr-1]].f;			\
+   GLfloat dpJ = (SGN J[V]) + J[3];				\
+								\
+   inlist[0] = vlist1;						\
+   for (i = n = 0 ; i < nr ; i++) {				\
+      GLuint elt_i = indata[i];					\
+      GLfloat *I = verts[elt_i].f;				\
+      GLfloat dpI = (SGN I[V]) + I[3];				\
+								\
+      if (DIFFERENT_SIGNS(dpI, dpJ)) {				\
+								\
+	 GLfloat *O = verts[next_vert].f;			\
+	 GLfloat t, *in, *out;					\
+								\
+	 if (NEGATIVE(dpI)) {					\
+	     t = dpI / (dpI - dpJ);				\
+	     in = I;						\
+	     out = J;						\
+	 }							\
+         else							\
+	 {							\
+	    t = dpJ / (dpJ - dpI);				\
+	    in = J;						\
+	    out = I;						\
+	 }							\
+								\
+	 interp(t, O, in, out);					\
+								\
+	 clipmask[next_vert] = 0;				\
+	 outdata[n++] = next_vert++;				\
+      }								\
+								\
+      clipmask[elt_i] |= PLANE;		/* don't set up */	\
+								\
+      if (!NEGATIVE(dpI)) {					\
+	 outdata[n++] = elt_i;					\
+	 clipmask[elt_i] &= ~PLANE;	/* set up after all */	\
+      }								\
+								\
+      J = I;							\
+      dpJ = dpI;						\
+   }								\
+								\
+   if (n < 3) return;						\
+}
+
+#define LINE_CLIP(x,y,z,w,PLANE)		\
+if (mask & PLANE) {				\
+   GLfloat dpI = DOT4V(I,x,y,z,w);		\
+   GLfloat dpJ = DOT4V(J,x,y,z,w);		\
+						\
+   if (DIFFERENT_SIGNS(dpI, dpJ)) {		\
+      GLfloat *O = verts[next_vert].f;	\
+      GLfloat t = dpI / (dpI - dpJ);		\
+						\
+      interp(t, O, I, J);			\
+						\
+      clipmask[next_vert] = 0;			\
+						\
+      if (NEGATIVE(dpI)) {			\
+  	 clipmask[elts[0]] |= PLANE;		\
+	 I = O; elts[0] = next_vert++;		\
+      } else {					\
+  	 clipmask[elts[1]] |= PLANE;		\
+	 J = O;	elts[1] = next_vert++;		\
+      }						\
+   }						\
+   else if (NEGATIVE(dpI))			\
+      return;					\
+}
+
+
+static __inline void mga_tri_clip( GLuint **p_elts,
+				    mgaVertex *verts,
+				    GLubyte *clipmask,
+				    GLuint *p_next_vert,
+				    GLubyte mask,
+				    mga_interp_func interp )
+{
+   GLuint *elts = *p_elts;
+   GLuint next_vert = *p_next_vert;
+   GLuint vlist1[VB_MAX_CLIPPED_VERTS];
+   GLuint vlist2[VB_MAX_CLIPPED_VERTS];
+   GLuint *inlist[2];
+   GLuint *out;
+   GLuint in = 0;
+   GLuint n = 3;
+   GLuint i;
+
+   inlist[0] = elts;
+   inlist[1] = vlist2;
+
+   CLIP(-,0,CLIP_RIGHT_BIT);
+   CLIP(+,0,CLIP_LEFT_BIT);
+   CLIP(-,1,CLIP_TOP_BIT);
+   CLIP(+,1,CLIP_BOTTOM_BIT);
+   CLIP(-,2,CLIP_FAR_BIT);
+   CLIP(+,2,CLIP_NEAR_BIT);
+
+   /* Convert the planar polygon to a list of triangles.
+    */
+   out = inlist[in];
+   
+   for (i = 2 ; i < n ; i++) {
+      elts[0] = out[0];
+      elts[1] = out[i-1];
+      elts[2] = out[i];
+      elts += 3;
+   }
+
+   *p_next_vert = next_vert;
+   *p_elts = elts;
+}
+
+
+static __inline void mga_line_clip( GLuint **p_elts,
+				    mgaVertex *verts,
+				    GLubyte *clipmask,
+				    GLuint *p_next_vert,
+				    GLubyte mask,
+				    mga_interp_func interp )
+{
+   GLuint *elts = *p_elts;
+   GLfloat *I = verts[elts[0]].f;
+   GLfloat *J = verts[elts[1]].f;
+   GLuint next_vert = *p_next_vert;
+
+   LINE_CLIP(1,0,0,-1,CLIP_LEFT_BIT);
+   LINE_CLIP(-1,0,0,1,CLIP_RIGHT_BIT);
+   LINE_CLIP(0,1,0,-1,CLIP_TOP_BIT);
+   LINE_CLIP(0,-1,0,1,CLIP_BOTTOM_BIT);
+   LINE_CLIP(0,0,1,-1,CLIP_FAR_BIT);
+   LINE_CLIP(0,0,-1,1,CLIP_NEAR_BIT);
+
+   *p_next_vert = next_vert;
+   *p_elts += 2;
+}
+
+
+
+#define CLIP_POINT( e )				\
+   if (mask[e])					\
+      *out++ = e 
+
+#define CLIP_LINE( e1, e0 )						\
+do {									\
+   GLubyte ormask = mask[e0] | mask[e1];				\
+   out[0] = e1;								\
+   out[1] = e0;								\
+   out+=2;								\
+   if (ormask) {							\
+      out-=2;								\
+      if (!(mask[e0] & mask[e1])) {					\
+	 mga_line_clip( &out, verts, mask, &next_vert, ormask, interp); \
+      }									\
+   }									\
+} while (0)
+
+#define CLIP_TRIANGLE( e2, e1, e0 )					\
+do {									\
+   GLubyte ormask;							\
+   out[0] = e2;								\
+   out[1] = e1;								\
+   out[2] = e0;								\
+   out += 3;								\
+   ormask = mask[e2] | mask[e1] | mask[e0];				\
+   if (ormask) {							\
+      out -= 3;								\
+      if ( !(mask[e2] & mask[e1] & mask[e0])) {				\
+	 mga_tri_clip( &out, verts, mask, &next_vert, ormask, interp ); \
+      }									\
+   }									\
+} while (0)
+
+
+
+
+
+
+/* Build a table of functions to clip each primitive type.  These
+ * produce a list of elements in the appropriate 'reduced' primitive,
+ * ie (points, lines, triangles) containing all the clipped and
+ * unclipped primitives from the original list.
+ */
+#define LOCAL_VARS						\
+   mgaContextPtr mmesa = MGA_CONTEXT( VB->ctx );                \
+   GLuint *elt = VB->EltPtr->data;				\
+   mgaVertex *verts = MGA_DRIVER_DATA(VB)->verts;		\
+   GLuint next_vert = MGA_DRIVER_DATA(VB)->last_vert;		\
+   GLuint *out = MGA_DRIVER_DATA(VB)->clipped_elements.data;	\
+   GLubyte *mask = VB->ClipMask;				\
+   mga_interp_func interp = mmesa->interp;                      \
+   (void) interp; (void) verts;
+
+#define POSTFIX							\
+   MGA_DRIVER_DATA(VB)->clipped_elements.count =		\
+          out - MGA_DRIVER_DATA(VB)->clipped_elements.data;	\
+   MGA_DRIVER_DATA(VB)->last_vert = next_vert;		
+
+
+#define INIT(x)
+
+#define RENDER_POINTS(start, count)			\
+do {							\
+   GLuint i;						\
+   for (i = start ; i < count ; i++ )			\
+      CLIP_POINT( elt[i] );				\
+} while (0)
+
+#define RENDER_LINE(i1, i0)      			\
+   CLIP_LINE(elt[i1], elt[i0])
+
+#define RENDER_TRI(i2, i1, i0, pv, parity)		\
+do {							\
+   GLuint e2 = elt[i2], e1 = elt[i1], e0 = elt[i0];	\
+   if (parity) e2 = elt[i1], e1 = elt[i2];		\
+   CLIP_TRIANGLE( e2, e1, e0 );				\
+} while (0)
+
+#define RENDER_QUAD(i3, i2, i1, i0, pv )		\
+  CLIP_TRIANGLE(elt[i3], elt[i2], elt[i0]);     	\
+  CLIP_TRIANGLE(elt[i2], elt[i1], elt[i0])
+
+#define TAG(x) mga_clip_##x##_elt
+#include "render_tmp.h"
+
+
+
+static void mga_project_vertices( struct vertex_buffer *VB )
+{
+   mgaVertexBufferPtr mgaVB = MGA_DRIVER_DATA(VB);
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLmatrix *mat = &ctx->Viewport.WindowMap;
+   GLfloat m[16];
+
+   m[MAT_SX] =   mat->m[MAT_SX];
+   m[MAT_TX] =   mat->m[MAT_TX] + mmesa->drawX - .5;
+   m[MAT_SY] = (- mat->m[MAT_SY]);
+   m[MAT_TY] = (- mat->m[MAT_TY]) + mmesa->driDrawable->h + mmesa->drawY - .5;
+   m[MAT_SZ] =   mat->m[MAT_SZ] * (1.0 / 0x10000);
+   m[MAT_TZ] =   mat->m[MAT_TZ] * (1.0 / 0x10000);
+
+   gl_project_v16( mgaVB->verts[VB->CopyStart].f,
+		   mgaVB->verts[mgaVB->last_vert].f,
+		   m,
+		   16 * 4 );
+}
+
+static void mga_project_clipped_vertices( struct vertex_buffer *VB )
+{
+   mgaVertexBufferPtr mgaVB = MGA_DRIVER_DATA(VB);
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLmatrix *mat = &ctx->Viewport.WindowMap;
+   GLfloat m[16];
+
+   m[MAT_SX] =   mat->m[MAT_SX];
+   m[MAT_TX] =   mat->m[MAT_TX] + mmesa->drawX - .5;
+   m[MAT_SY] = (- mat->m[MAT_SY]);
+   m[MAT_TY] = (- mat->m[MAT_TY]) + mmesa->driDrawable->h + mmesa->drawY - .5;
+   m[MAT_SZ] =   mat->m[MAT_SZ] * (1.0 / 0x10000);
+   m[MAT_TZ] =   mat->m[MAT_TZ] * (1.0 / 0x10000);
+
+   gl_project_clipped_v16( mgaVB->verts[VB->CopyStart].f,
+			   mgaVB->verts[mgaVB->last_vert].f,
+			   m,
+			   16 * 4,
+			   VB->ClipMask + VB->CopyStart );
+}
+
+
+/* Pack rgba and/or texture into the remaining half of a 32 byte vertex.
+ */
+#define CLIP_UBYTE_COLOR  4
+#define CLIP_UBYTE_B 0   
+#define CLIP_UBYTE_G 1  
+#define CLIP_UBYTE_R 2
+#define CLIP_UBYTE_A 3   
+#define CLIP_S0 6
+#define CLIP_T0 7
+#define CLIP_S1 8
+#define CLIP_T1 9
+
+#define TYPE (0)
+#define TAG(x) x
+#include "mgafasttmp.h"
+
+#define TYPE (MGA_RGBA_BIT)
+#define TAG(x) x##_RGBA
+#include "mgafasttmp.h"
+
+#define TYPE (MGA_TEX0_BIT)
+#define TAG(x) x##_TEX0
+#include "mgafasttmp.h"
+
+#define TYPE (MGA_RGBA_BIT|MGA_TEX0_BIT)
+#define TAG(x) x##_RGBA_TEX0
+#include "mgafasttmp.h"
+
+#define TYPE (MGA_RGBA_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT)
+#define TAG(x) x##_RGBA_TEX0_TEX1
+#include "mgafasttmp.h"
+
+#define TYPE (MGA_TEX0_BIT|MGA_TEX1_BIT)
+#define TAG(x) x##_TEX0_TEX1
+#include "mgafasttmp.h"
+
+
+/* Very sparsely popluated array - fix the indices.
+ */
+static struct mga_fast_tab mgaFastTab[0x80];
+
+void mgaDDFastPathInit( void )
+{
+   mga_clip_render_init_elt();
+   render_init_mga_smooth_indirect();
+
+   mga_init_fastpath( &mgaFastTab[0] );
+   mga_init_fastpath_RGBA( &mgaFastTab[MGA_RGBA_BIT] );
+   mga_init_fastpath_TEX0( &mgaFastTab[MGA_TEX0_BIT] );
+   mga_init_fastpath_RGBA_TEX0( &mgaFastTab[MGA_RGBA_BIT|MGA_TEX0_BIT] );
+   mga_init_fastpath_TEX0_TEX1( &mgaFastTab[MGA_TEX0_BIT|MGA_TEX1_BIT] );
+   mga_init_fastpath_RGBA_TEX0_TEX1( &mgaFastTab[MGA_RGBA_BIT|MGA_TEX0_BIT|
+						  MGA_TEX1_BIT] );
+}
+
+#define VALID_SETUP (MGA_RGBA_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT)
+
+
+void mgaDDFastPath( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   GLenum prim = ctx->CVA.elt_mode;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx ); 
+   struct mga_fast_tab *tab = &mgaFastTab[mmesa->setupindex & VALID_SETUP];
+   GLuint do_cliptest = 1;
+
+   gl_prepare_arrays_cva( VB );	                 /* still need this */
+
+   /* Reserve enough space for the pathological case.
+    */
+   if (VB->EltPtr->count * 12 > MGA_DRIVER_DATA(VB)->size) {
+      mgaDDResizeVB( VB, VB->EltPtr->count * 12 );
+      do_cliptest = 1;
+   }
+
+   tab->build_vertices( VB, do_cliptest );       /* object->clip space */
+
+   if (mmesa->new_state)
+      mgaDDUpdateHwState( ctx );
+
+   if (VB->ClipOrMask) {
+      if (!VB->ClipAndMask) {
+	 render_func *clip = mga_clip_render_tab_elt;
+      
+	 mmesa->interp = tab->interp;
+      
+	 clip[prim]( VB, 0, VB->EltPtr->count, 0 ); /* build new elts */
+
+	 ctx->CVA.elt_mode = gl_reduce_prim[prim];
+	 VB->EltPtr = &(MGA_DRIVER_DATA(VB)->clipped_elements);
+
+	 LOCK_HARDWARE( mmesa );
+	 mga_project_clipped_vertices( VB );    /* clip->device space */
+	 mga_render_elements_direct( VB );        /* render using new list */
+	 mgaFlushVerticesLocked( mmesa );
+	 UNLOCK_HARDWARE( mmesa );
+      }
+   } else {
+      LOCK_HARDWARE( mmesa );
+      mga_project_vertices( VB );               /* clip->device space  */
+      mga_render_elements_direct( VB );           /* render using orig list */
+      mgaFlushVerticesLocked( mmesa );
+      UNLOCK_HARDWARE( mmesa );
+   }
+
+   /* This indicates that there is no cached data to reuse.  
+    */
+   VB->pipeline->data_valid = 0;
+   VB->pipeline->new_state = 0;
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h b/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h
new file mode 100644
index 000000000..43caddcac
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h
@@ -0,0 +1,143 @@
+/*
+ * DRI Hardware Device Driver for G200/G400
+ * Copyright (C) 1999 Keith Whitwell
+ *
+ * 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
+ * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ */
+
+
+
+/* The first part of setup is applied to all vertices, clipped or
+ * unclipped.  This data will be used for clipping, and then all
+ * vertices with a zero clipmask will be projected to device space.
+ *
+ * This could be split into several loops, but - it seems that the
+ * large stride of the fxVertices makes cache issues the big
+ * performance factor, and that multiple loops mean multiple cache
+ * misses....
+ */
+static void TAG(mga_setup_full)( struct vertex_buffer *VB, GLuint do_cliptest )
+{
+   GLcontext *ctx = VB->ctx;
+   const GLfloat * const m = ctx->ModelProjectMatrix.m;
+   GLuint start = VB->CopyStart;
+   GLuint count = VB->Count;
+   GLuint i;
+
+   gl_xform_points3_v16_general(MGA_DRIVER_DATA(VB)->verts[start].f,
+				m, 
+				VB->ObjPtr->start,
+				VB->ObjPtr->stride,
+				count - start);
+
+   if (do_cliptest)
+   {
+      VB->ClipAndMask = ~0; 
+      VB->ClipOrMask = 0;
+      gl_cliptest_points4_v16(MGA_DRIVER_DATA(VB)->verts[start].f,
+			      MGA_DRIVER_DATA(VB)->verts[count].f,
+			      &(VB->ClipOrMask),
+			      &(VB->ClipAndMask),
+			      VB->ClipMask + start);
+   }
+
+   /* These branches are all resolved at compile time.  Hopefully all
+    * the pointers are valid addresses even when not enabled.
+    */
+   if (TYPE) {
+      GLubyte *color = VB->ColorPtr->start;
+      GLfloat *tex0_data = VB->TexCoordPtr[0]->start;
+      GLfloat *tex1_data = VB->TexCoordPtr[1]->start;
+
+      GLuint color_stride = VB->ColorPtr->stride;
+      GLuint tex0_stride = VB->TexCoordPtr[0]->stride;
+      GLuint tex1_stride = VB->TexCoordPtr[1]->stride;
+
+      GLfloat *f = MGA_DRIVER_DATA(VB)->verts[start].f;
+
+      for (i = start ; i < count ; i++, f += 16) {
+	 if (TYPE & MGA_RGBA_BIT) {
+	    GLubyte *b = (GLubyte *)&f[CLIP_UBYTE_COLOR];
+	    GLubyte *col = color; color += color_stride;
+	    b[CLIP_UBYTE_R] = col[0];
+	    b[CLIP_UBYTE_G] = col[1];
+	    b[CLIP_UBYTE_B] = col[2];
+	    b[CLIP_UBYTE_A] = col[3];
+	 }
+	 if (TYPE & MGA_TEX0_BIT) {
+	    f[CLIP_S0] = tex0_data[0];
+	    f[CLIP_T0] = tex0_data[1];
+	    STRIDE_F(tex0_data, tex0_stride);
+	 }
+	 if (TYPE & MGA_TEX1_BIT) {
+	    f[CLIP_S1] = tex1_data[0];
+	    f[CLIP_T1] = tex1_data[1];
+	    STRIDE_F(tex1_data, tex1_stride);
+	 }
+      }
+   }
+
+   MGA_DRIVER_DATA(VB)->clipped_elements.count = start;
+   MGA_DRIVER_DATA(VB)->last_vert = count;
+}
+
+
+/* Changed to just put the interp func instead of the whole clip
+ * routine into the header.  Less code and better chance of doing some
+ * of this stuff in assembly.
+ */
+static void TAG(mga_interp_vert)( GLfloat t, 
+				  GLfloat *O,
+				  const GLfloat *I,
+				  const GLfloat *J )
+{
+   O[0] = LINTERP(t, I[0], J[0]);
+   O[1] = LINTERP(t, I[1], J[1]);
+   O[2] = LINTERP(t, I[2], J[2]);
+   O[3] = LINTERP(t, I[3], J[3]);
+
+   if (TYPE & MGA_RGBA_BIT) {
+      INTERP_RGBA(t,
+		  ((GLubyte *)&(O[4])),
+		  ((GLubyte *)&(I[4])),
+		  ((GLubyte *)&(J[4])));
+   }
+
+   if (TYPE & MGA_TEX0_BIT) {
+      O[6] = LINTERP(t, I[6], J[6]);
+      O[7] = LINTERP(t, I[7], J[7]);
+   }
+
+   if (TYPE & MGA_TEX1_BIT) {
+      O[8] = LINTERP(t, I[8], J[8]);
+      O[9] = LINTERP(t, I[9], J[9]);
+   }
+}
+
+
+static void TAG(mga_init_fastpath)( struct mga_fast_tab *tab )
+{
+   tab->interp = TAG(mga_interp_vert);
+   tab->build_vertices = TAG(mga_setup_full);
+}
+
+#undef TYPE
+#undef TAG
+#undef SIZE
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c
new file mode 100644
index 000000000..c1819924d
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c
@@ -0,0 +1,321 @@
+#include <stdio.h>
+
+
+#include "types.h"
+#include "pb.h"
+#include "dd.h"
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgadd.h"
+#include "mgastate.h"
+#include "mgadepth.h"
+#include "mgatex.h"
+#include "mgalog.h"
+#include "mgavb.h"
+#include "mgatris.h"
+
+#include "drm.h"
+#include <sys/ioctl.h>
+
+static void mga_iload_dma_ioctl(mgaContextPtr mmesa,
+				int x1, int y1, int x2, int y2, 
+				unsigned long dest, unsigned int maccess)
+{
+   int retcode;
+   drm_mga_iload_t iload;
+   drmBufPtr buf = mmesa->dma_buffer;
+   
+   iload.idx = buf->idx;
+   iload.destOrg = dest;	
+   iload.mAccess = maccess;
+   iload.texture.x1 = x1;
+   iload.texture.y1 = y1;
+   iload.texture.y2 = x2;
+   iload.texture.x2 = y2;
+   
+   if ((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_ILOAD, &iload))) {
+      printf("send iload retcode = %d\n", retcode);
+      exit(1);
+   }
+}
+
+
+static void mga_vertex_dma_ioctl(mgaContextPtr mmesa)
+{
+   int retcode;
+   int size = MGA_DMA_BUF_SZ;
+   drmDMAReq dma;
+   drmBufPtr buf = mmesa->dma_buffer;
+
+   dma.context = mmesa->hHWContext;
+   dma.send_count = 1;
+   dma.send_list = &buf->idx;
+   dma.send_sizes = &size;
+   dma.flags = DRM_DMA_WAIT;
+   dma.request_count = 0;
+   dma.request_size = 0;
+   dma.request_list = 0;
+   dma.request_sizes = 0;
+
+   if ((retcode = drmDMA(mmesa->driFd, &dma))) {
+      printf("send iload retcode = %d\n", retcode);
+      exit(1);
+   }
+}
+
+
+static void mga_get_buffer_ioctl( mgaContextPtr mmesa )
+{
+   int idx = 0;
+   int size = 0;
+   drmDMAReq dma;
+   int retcode;
+   
+   fprintf(stderr,  "Getting dma buffer\n");
+   
+   dma.context = mmesa->hHWContext;
+   dma.send_count = 0;
+   dma.send_list = NULL;
+   dma.send_sizes = NULL;
+   dma.flags = DRM_DMA_WAIT;
+   dma.request_count = 1;
+   dma.request_size = MGA_DMA_BUF_SZ;
+   dma.request_list = &idx;
+   dma.request_sizes = &size;
+   
+   if ((retcode = drmDMA(mmesa->driFd, &dma))) {
+      fprintf(stderr, "request drmDMA retcode = %d\n", retcode);
+      exit(1);
+   }
+
+   mmesa->dma_buffer = &mmesa->mgaScreen->bufs->list[idx];
+}
+
+static void mga_swap_ioctl( mgaContextPtr mmesa )
+{
+   int retcode;
+   drm_mga_swap_t swap;
+      
+   if((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_SWAP, &swap))) {
+      printf("send swap retcode = %d\n", retcode);
+      exit(1);
+   }
+}
+
+
+
+static void mga_clear_ioctl( mgaContextPtr mmesa, int flags, int col, int zval )
+{
+   int retcode;
+   drm_mga_clear_t clear;
+   
+   clear.flags = flags;
+   clear.clear_color = col;
+   clear.clear_depth = zval;
+      
+   if((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_CLEAR, &clear))) {
+      printf("send clear retcode = %d\n", retcode);
+      exit(1);
+   }
+}
+
+
+
+
+
+
+
+GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+		     GLint cx, GLint cy, GLint cw, GLint ch ) 
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint c = mmesa->ClearColor;
+   mgaUI32 zval = (mgaUI32) (ctx->Depth.Clear * DEPTH_SCALE);
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
+   int flags = 0;
+   int i;
+
+   mgaMsg( 10, "mgaClear( %i, %i, %i, %i, %i )\n", 
+	   mask, x, y, width, height );
+
+
+   mgaFlushVertices( mmesa );
+
+
+   if (mask & GL_COLOR_BUFFER_BIT) {
+      if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT) {
+	 flags |= MGA_CLEAR_FRONT;
+	 mask &= ~GL_COLOR_BUFFER_BIT;
+      } else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT) {
+	 flags |= MGA_CLEAR_BACK;
+	 mask &= ~GL_COLOR_BUFFER_BIT;
+      }
+   }
+
+   if ((flags & GL_DEPTH_BUFFER_BIT) && ctx->Depth.Mask) {
+      flags |= MGA_CLEAR_DEPTH;
+      mask &= ~GL_DEPTH_BUFFER_BIT;
+   }
+
+   if (!flags)
+      return mask;
+
+   LOCK_HARDWARE( mmesa );
+   
+   /* flip top to bottom */
+   cy = dPriv->h-cy-ch;
+   cx += mmesa->drawX;
+   cy += mmesa->drawY;
+
+   for (i = 0 ; i < dPriv->numClipRects ; ) { 	 
+
+      /* Use the cliprects for the current draw buffer
+       */
+      int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, mmesa->numClipRects);
+      XF86DRIClipRectRec *box = mmesa->pClipRects;	 
+      xf86drmClipRectRec *b = mmesa->sarea->boxes;
+      mmesa->sarea->nbox = nr - i;
+
+      if (!all) {
+	 for ( ; i < nr ; i++) {
+	    GLint x = box[i].x1;
+	    GLint y = box[i].y1;
+	    GLint w = box[i].x2 - x;
+	    GLint h = box[i].y2 - y;
+
+	    if (x < cx) w -= cx - x, x = cx; 
+	    if (y < cy) h -= cy - y, y = cy;
+	    if (x + w > cx + cw) w = cx + cw - x;
+	    if (y + h > cy + ch) h = cy + ch - y;
+	    if (w <= 0) continue;
+	    if (h <= 0) continue;
+
+	    b->x1 = x;
+	    b->y1 = y;
+	    b->x2 = x + w;
+	    b->y2 = y + h;
+	    b++;
+	 }
+      } else {
+	 for ( ; i < nr ; i++) 
+	    *b++ = *(xf86drmClipRectRec *)&box[i];
+      }
+
+      mga_clear_ioctl( mmesa, mask, c, zval );
+   }
+
+   UNLOCK_HARDWARE( mmesa );
+   return mask;
+}
+
+
+
+
+/*
+ * Copy the back buffer to the front buffer. 
+ */
+void mgaSwapBuffers( mgaContextPtr mmesa ) 
+{
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
+   int i;
+
+   mgaFlushVertices( mmesa );
+
+   LOCK_HARDWARE( mmesa );
+   {
+      /* Use the frontbuffer cliprects
+       */
+      XF86DRIClipRectPtr pbox = dPriv->pClipRects;
+      int nbox = dPriv->numClipRects;
+
+      for (i = 0 ; i < nbox ; )
+      {
+	 int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, dPriv->numClipRects);
+	 XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)mmesa->sarea->boxes;
+	 mmesa->sarea->nbox = nr - i;
+
+	 for ( ; i < nr ; i++) 
+	    *b++ = pbox[i];
+	 
+	 mga_swap_ioctl( mmesa );
+      }
+   }
+
+
+#if 1
+   UNLOCK_HARDWARE(mmesa);
+#else
+   {
+      last_enqueue = mmesa->sarea->lastEnqueue;
+      last_dispatch = mmesa->sarea->lastDispatch;
+      UNLOCK_HARDWARE;
+      
+      /* Throttle runaway apps - there should be an easier way to sleep
+       * on dma without locking out the rest of the system!
+       */
+      if (mmesa->lastSwap > last_dispatch) {
+	 drmGetLock(mmesa->driFd, mmesa->hHWContext, DRM_LOCK_QUIESCENT);	
+	 DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext);	
+      }
+
+      mmesa->lastSwap = last_enqueue;
+   }
+#endif
+}
+
+
+/* This is overkill
+ */
+void mgaDDFinish( GLcontext *ctx  ) 
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   drmGetLock(mmesa->driFd, mmesa->hHWContext, DRM_LOCK_QUIESCENT);	
+   DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext);	
+}
+
+
+
+
+void mgaFlushVertices( mgaContextPtr mmesa ) 
+{
+   LOCK_HARDWARE( mmesa );
+   mgaFlushVerticesLocked( mmesa );
+   UNLOCK_HARDWARE( mmesa );
+}
+
+
+void mgaFlushVerticesLocked( mgaContextPtr mmesa )
+{
+   XF86DRIClipRectPtr pbox = mmesa->pClipRects;
+   int nbox = mmesa->numClipRects;
+   int i;
+
+   if (mmesa->dirty)
+      mgaEmitHwStateLocked( mmesa );
+
+   for (i = 0 ; i < nbox ; )
+   {
+      int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, nbox);
+      XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)mmesa->sarea->boxes;
+      mmesa->sarea->nbox = nr - i;
+
+      for ( ; i < nr ; i++) 
+	 *b++ = pbox[i];
+	 
+      mga_vertex_dma_ioctl( mmesa );
+
+      break;			/* fix dma multiple dispatch */
+   }
+
+   mga_get_buffer_ioctl( mmesa );
+}
+
+
+
+void mgaDDInitIoctlFuncs( GLcontext *ctx )
+{
+   ctx->Driver.Clear = mgaClear;
+   ctx->Driver.Flush = 0;
+   ctx->Driver.Finish = mgaDDFinish;
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h
new file mode 100644
index 000000000..22ca26e17
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h
@@ -0,0 +1,23 @@
+#ifndef MGA_IOCTL_H
+#define MGA_IOCTL_H
+
+#include "mgalib.h"
+
+GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+		     GLint cx, GLint cy, GLint cw, GLint ch ); 
+
+
+void mgaSwapBuffers( mgaContextPtr mmesa ); 
+
+void mgaFlushVertices( mgaContextPtr mmesa ); 
+void mgaFlushVerticesLocked( mgaContextPtr mmesa );
+
+/* upload texture
+ */
+
+void mgaDDFinish( GLcontext *ctx );
+
+void mgaDDInitIoctlFuncs( GLcontext *ctx );
+ 
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgalib.h b/xc/lib/GL/mesa/src/drv/mga/mgalib.h
new file mode 100644
index 000000000..4600a69a0
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgalib.h
@@ -0,0 +1,266 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+
+#ifndef MGALIB_INC
+#define MGALIB_INC
+
+#include <X11/Xlibint.h>
+#include "dri_tmm.h"
+#include "dri_mesaint.h"
+#include "dri_mesa.h"
+#include "xmesaP.h"
+
+#include "types.h"
+
+#include "mgacommon.h"
+#include "mm.h"
+#include "mgalog.h"
+#include "mgaioctl.h"
+#include "mgatex.h"
+#include "mgavb.h"
+
+#include "mga_drm_public.h"
+#include "mga_xmesa.h"
+
+
+#define MGA_SET_FIELD(reg,mask,val)  reg = ((reg) & (mask)) | ((val) & ~(mask))
+#define MGA_FIELD(field,val) (((val) << (field ## _SHIFT)) & ~(field ## _MASK))
+#define MGA_GET_FIELD(field, val) ((val & ~(field ## _MASK)) >> (field ## _SHIFT))
+
+#define MGA_CHIP_MGAG200 0
+#define MGA_CHIP_MGAG400 1
+
+#define MGA_IS_G200(mmesa) (mmesa->mgaScreen->chipset == MGA_CHIP_MGAG200)
+#define MGA_IS_G400(mmesa) (mmesa->mgaScreen->chipset == MGA_CHIP_MGAG400)
+
+
+/* SoftwareFallback 
+ *    - texture env GL_BLEND -- can be fixed 
+ *    - 1D and 3D textures
+ *    - incomplete textures
+ */
+#define MGA_FALLBACK_TEXTURE   0x1
+#define MGA_FALLBACK_BUFFER    0x2
+
+
+/* For mgaCtx->new_state.
+ */
+#define MGA_NEW_DEPTH   0x1
+#define MGA_NEW_ALPHA   0x2
+#define MGA_NEW_FOG     0x4
+#define MGA_NEW_CLIP    0x8
+#define MGA_NEW_MASK    0x10
+#define MGA_NEW_TEXTURE 0x20
+#define MGA_NEW_CULL    0x40
+#define MGA_NEW_WARP    0x80
+#define MGA_NEW_CONTEXT 0x100
+
+
+typedef void (*mga_interp_func)( GLfloat t, 
+				 GLfloat *result,
+				 const GLfloat *in,
+				 const GLfloat *out );
+				 
+
+
+
+/* if type == MGA_COLORBUFFER */
+#define MGA_PF_MASK  0xf0
+#define MGA_PF_INDEX 0
+#define MGA_PF_565   (1 << 4)
+#define MGA_PF_555   (9 << 4)
+#define MGA_PF_888   (3 << 4)
+#define MGA_PF_8888  (10 << 4)
+#define MGA_PF_HASALPHA (8 << 4)
+
+struct mga_context_t {
+
+   GLcontext *glCtx;
+
+   /* Hardware state - moved from mgabuf.h
+    */
+   mgaUI32 Setup[MGA_CTX_SETUP_SIZE];
+
+   /* Variable sized vertices
+    */
+   mgaUI32 vertsize;
+
+   /* Map GL texture units onto hardware.
+    */
+   mgaUI32 multitex;
+   mgaUI32 tmu_source[2];
+   mgaUI32 tex_dest[2];
+
+
+
+   /* bookkeeping for textureing */
+   struct mga_texture_object_s TexObjList;
+   struct mga_texture_object_s SwappedOut;
+   struct mga_texture_object_s *CurrentTexObj[2];
+
+
+   /* shared texture palette */
+   mgaUI16	GlobalPalette[256];
+  
+   int Fallback;  /* or'ed values of FALLBACK_* */
+
+   /* Support for CVA and the fast paths */
+   unsigned int setupdone;
+   unsigned int setupindex;
+   unsigned int renderindex;
+   unsigned int using_fast_path;
+   unsigned int using_immediate_fast_path;
+   mga_interp_func interp;
+
+   /* Shortcircuit some state changes */
+   points_func   PointsFunc;
+   line_func     LineFunc;
+   triangle_func TriangleFunc;
+   quad_func     QuadFunc;
+
+   /* Manage our own state */
+   GLuint        new_state; 
+   GLuint        dirty;
+
+   GLubyte       clearcolor[4];
+   GLushort MonoColor;
+   GLushort ClearColor;
+
+   
+   /* DRI stuff
+    */
+   drmBufPtr  dma_buffer;
+
+   GLframebuffer *glBuffer;
+   memHeap_t *texHeap;
+
+   GLuint needClip;
+   GLuint warp_pipe;
+
+   /* These refer to the current draw (front vs. back) buffer:
+    */
+   int drawOffset;		/* draw buffer address in agp space */
+   int drawX;			/* origin of drawable in draw buffer */
+   int drawY;
+   GLuint numClipRects;		/* cliprects for that buffer */
+   XF86DRIClipRectPtr pClipRects;
+
+   int texAge;
+
+   XF86DRIClipRectRec draw_rect;
+
+   drmContext hHWContext;
+   drmLock *driHwLock;
+   int driFd;
+   Display *display;
+
+   __DRIdrawablePrivate *driDrawable;
+   __DRIscreenPrivate *driScreen;
+   mgaScreenPrivate *mgaScreen; 
+   drm_mga_sarea_t *sarea;
+};
+
+
+
+
+typedef struct {
+
+	/* dma stuff */
+        mgaUI32         systemTexture;
+        mgaUI32         noSetupDma;
+
+        mgaUI32         default32BitTextures;
+        mgaUI32         swapBuffersCount;
+        
+	/* options */
+	mgaUI32		nullprims;  /* skip all primitive generation */
+	mgaUI32		noFallback; /* don't fall back to software, do
+                                       best-effort rendering */
+ 	mgaUI32		skipDma;    /* don't send anything to the hardware */
+ 	
+	/* performance counters */	
+	mgaUI32		c_textureUtilization;
+	mgaUI32		c_textureSwaps;
+	mgaUI32		c_setupPointers;
+	mgaUI32		c_triangles;
+	mgaUI32		c_points;
+	mgaUI32		c_lines;
+	mgaUI32		c_drawWaits;
+	mgaUI32		c_dmaFlush;
+	mgaUI32		c_overflows;
+
+} mgaGlx_t;
+
+extern mgaGlx_t	mgaglx;
+
+
+#define MGAPACKCOLOR555(r,g,b,a) \
+  ((((r) & 0xf8) << 7) | (((g) & 0xf8) << 2) | (((b) & 0xf8) >> 3) | \
+    ((a) ? 0x8000 : 0))
+
+#define MGAPACKCOLOR565(r,g,b) \
+  ((((r) & 0xf8) << 8) | (((g) & 0xfc) << 3) | (((b) & 0xf8) >> 3))
+
+#define MGAPACKCOLOR888(r,g,b) \
+  (((r) << 16) | ((g) << 8) | (b))
+
+#define MGAPACKCOLOR8888(r,g,b,a) \
+  (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
+
+#define MGAPACKCOLOR4444(r,g,b,a) \
+  ((((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | ((g) & 0xf0) | ((b) >> 4))
+
+
+#define MGA_DEBUG 0   
+#ifndef MGA_DEBUG
+extern int MGA_DEBUG;
+#endif
+
+#define MGA_DEBUG_ALWAYS_SYNC    0x1
+#define MGA_DEBUG_VERBOSE_MSG    0x2
+#define MGA_DEBUG_VERBOSE_LRU    0x4
+#define MGA_DEBUG_VERBOSE_DRI    0x8
+
+static __inline__ mgaUI32 mgaPackColor(mgaUI32 format,
+				       mgaUI8 r, mgaUI8 g, 
+				       mgaUI8 b, mgaUI8 a)
+{
+  switch (format & MGA_PF_MASK) {
+  case MGA_PF_555:
+    return MGAPACKCOLOR555(r,g,b,a);
+  case MGA_PF_565:
+    return MGAPACKCOLOR565(r,g,b);
+  case MGA_PF_888:
+    return MGAPACKCOLOR888(r,g,b);
+  case MGA_PF_8888:
+    return MGAPACKCOLOR8888(r,g,b,a);
+  default:
+    return 0;
+  }
+}
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgalog.h b/xc/lib/GL/mesa/src/drv/mga/mgalog.h
new file mode 100644
index 000000000..74f52f8d6
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgalog.h
@@ -0,0 +1,47 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+ 
+/* Usage:
+ * - use mgaError for error messages. Always write to X error and log file.
+ * - use mgaMsg for debugging. Can be disabled by undefining MGA_LOG_ENABLED.
+ */
+ 
+#ifndef MGALOG_INC
+#define MGALOG_INC
+#include "hwlog.h"
+
+/* Mapping between old function names and new common code: */
+/* (Feel free to replace all mgaMsg with hwMsg etc. in all *.c
+ * files, I was to lazy to do this...) */
+#define mgaOpenLog(f) 	hwOpenLog(f,"[mga] ")
+#define mgaCloseLog 	hwCloseLog
+#define mgaIsLogReady 	hwIsLogReady
+#define mgaSetLogLevel  hwSetLogLevel
+#define mgaGetLogLevel  hwGetLogLevel
+#define mgaMsg		hwMsg
+#define mgaError	hwError
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgapipeline.c b/xc/lib/GL/mesa/src/drv/mga/mgapipeline.c
new file mode 100644
index 000000000..8f8fea669
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgapipeline.c
@@ -0,0 +1,138 @@
+/*  #include "mgapipeline.h" */
+
+#include <stdio.h>
+#include "mgavb.h"
+#include "mgadd.h"
+#include "mgalib.h"
+#include "mgatris.h"
+#include "mgapipeline.h"
+#include "fog.h"
+
+static struct gl_pipeline_stage mga_fast_stage = {
+   "MGA fast path",
+   (PIPE_OP_VERT_XFORM|PIPE_OP_RAST_SETUP_0|
+    PIPE_OP_RAST_SETUP_1|PIPE_OP_RENDER),
+   PIPE_PRECALC,
+   0, 0, 0, 0, 0, 0, 0, 0, 0,	
+   mgaDDFastPath
+};
+
+
+#define ILLEGAL_ENABLES (TEXTURE0_3D|		\
+			 TEXTURE1_3D|		\
+			 ENABLE_TEXMAT0 |	\
+			 ENABLE_TEXMAT1 |	\
+			 ENABLE_TEXGEN0 |	\
+			 ENABLE_TEXGEN1 |	\
+			 ENABLE_USERCLIP |	\
+			 ENABLE_LIGHT |		\
+			 ENABLE_FOG)
+			
+
+/* The driver gets first shot at building the pipeline - make some
+ * quick tests to see if we can use the fast path.
+ */
+GLboolean mgaDDBuildPrecalcPipeline( GLcontext *ctx )
+{   
+   struct gl_pipeline *pipe = &ctx->CVA.pre;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   
+   if (mmesa->renderindex == 0 && 
+       (ctx->Enabled & ILLEGAL_ENABLES) == 0 &&
+       (ctx->Array.Flags & (VERT_OBJ_234|
+			    VERT_TEX0_4|
+			    VERT_TEX1_4|
+			    VERT_ELT)) == (VERT_OBJ_23|VERT_ELT))
+   {
+      pipe->stages[0] = &mga_fast_stage;
+      pipe->stages[1] = 0;
+      pipe->new_inputs = ctx->RenderFlags & VERT_DATA;
+      pipe->ops = pipe->stages[0]->ops;
+      mmesa->using_fast_path = 1;
+      return 1;
+   } 
+
+   if (mmesa->using_fast_path) 
+   {
+      mmesa->using_fast_path = 0;
+      ctx->CVA.VB->ClipOrMask = 0;
+      ctx->CVA.VB->ClipAndMask = CLIP_ALL_BITS;
+      ctx->Array.NewArrayState |= ctx->Array.Summary;
+      return 0;
+   }
+   
+   return 0;
+}
+
+
+
+
+/* Still do the normal fixup and copy-to-current, so this isn't so
+ * bad.  
+ */
+#define ILLEGAL_INPUTS_IMM (VERT_OBJ_4|		\
+                            VERT_TEX0_4|	\
+			    VERT_TEX1_4|	\
+			    VERT_MATERIAL)
+
+
+static void mgaDDCheckRasterSetup( GLcontext *ctx, struct gl_pipeline_stage *d )
+{
+   d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
+   d->inputs = ctx->RenderFlags;
+
+   /* MGA requires an extra input:
+    */
+   if (ctx->FogMode == FOG_FRAGMENT)
+      d->inputs |= VERT_FOG_COORD;
+
+   d->outputs = VERT_SETUP_FULL;
+
+   if (ctx->IndirectTriangles & DD_SW_SETUP)
+      d->type = PIPE_IMMEDIATE;
+}
+
+
+GLuint mgaDDRegisterPipelineStages( struct gl_pipeline_stage *out,
+				    const struct gl_pipeline_stage *in,
+				    GLuint nr )
+{
+   GLuint i, o;
+
+   for (i = o = 0 ; i < nr ; i++) {
+      switch (in[i].ops) {
+
+	 /* Completely replace Mesa's fog processing to generate fog
+	  * coordinates instead of messing with colors.
+	  */
+      case PIPE_OP_FOG:
+	 out[o] = gl_fog_coord_stage;
+	 o++;
+	 break;
+
+      case PIPE_OP_RAST_SETUP_0:
+	 out[o] = in[i];
+	 out[o].cva_state_change = NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS;
+	 out[o].state_change = ~0;
+	 out[o].check = mgaDDCheckPartialRasterSetup;
+	 out[o].run = mgaDDPartialRasterSetup;
+	 o++;
+	 break;
+
+      case PIPE_OP_RAST_SETUP_0|PIPE_OP_RAST_SETUP_1:
+	 out[o] = in[i];
+	 out[o].check = mgaDDCheckRasterSetup;
+	 out[o].run = mgaDDDoRasterSetup;
+	 o++;
+	 break;
+
+      default:
+	 out[o++] = in[i];
+	 break;
+      }
+   }
+
+   return o;
+}
+
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgapipeline.h b/xc/lib/GL/mesa/src/drv/mga/mgapipeline.h
new file mode 100644
index 000000000..d42abddfe
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgapipeline.h
@@ -0,0 +1,15 @@
+#ifndef _MGA_PIPELINE_H
+#define _MGA_PIPELINE_H
+
+
+extern GLuint mgaDDRegisterPipelineStages( struct gl_pipeline_stage *out,
+					   const struct gl_pipeline_stage *in,
+					   GLuint nr );
+
+extern GLboolean mgaDDBuildImmediatePipeline( GLcontext *ctx );
+extern GLboolean mgaDDBuildPrecalcPipeline( GLcontext *ctx );
+
+extern void mgaDDFastPath( struct vertex_buffer *VB );
+extern void mgaDDFastPathInit( void );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaregs.h b/xc/lib/GL/mesa/src/drv/mga/mgaregs.h
new file mode 100644
index 000000000..3842ee258
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaregs.h
@@ -0,0 +1,1377 @@
+/* author: stephen crowley, crow@debian.org */
+
+/*
+ * 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
+ * STEPHEN CROWLEY, OR ANY OTHER CONTRIBUTORS 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 _MGAREGS_H_
+#define _MGAREGS_H_
+
+/*************** (START) AUTOMATICLY GENERATED REGISTER FILE *****************/
+/*
+ * Generated on Wed Jan 26 13:44:46 MST 2000
+ */
+
+
+
+/*
+ * Power Graphic Mode Memory Space Registers
+ */
+
+#define MGAREG_MGA_EXEC 			0x0100
+#define MGAREG_AGP_PLL 			0x1e4c
+
+    #define AGP_PLL_agp2xpllen_MASK 	0xfffffffe 	/* bit 0 */
+    #define AGP_PLL_agp2xpllen_disable 	0x0 		
+    #define AGP_PLL_agp2xpllen_enable 	0x1 		
+
+#define MGAREG_CFG_OR 				0x1e4c
+
+    #define CFG_OR_comp_or_MASK 	0xfffffff7 	/* bit 3 */
+    #define CFG_OR_comp_or_disable 	0x0 		
+    #define CFG_OR_comp_or_enable 	0x8 		
+    #define CFG_OR_compfreq_MASK 	0xffffff0f 	/* bits 4-7 */
+    #define CFG_OR_compfreq_SHIFT 	4 		
+    #define CFG_OR_comporup_MASK 	0xfffff0ff 	/* bits 8-11 */
+    #define CFG_OR_comporup_SHIFT 	8 		
+    #define CFG_OR_compordn_MASK 	0xffff0fff 	/* bits 12-15 */
+    #define CFG_OR_compordn_SHIFT 	12 		
+    #define CFG_OR_e2pq_MASK 		0xfffeffff 	/* bit 16 */
+    #define CFG_OR_e2pq_disable 	0x0 		
+    #define CFG_OR_e2pq_enable 		0x10000 	
+    #define CFG_OR_e2pqbypcsn_MASK 	0xfffdffff 	/* bit 17 */
+    #define CFG_OR_e2pqbypcsn_disable 	0x0 		
+    #define CFG_OR_e2pqbypcsn_enable 	0x20000 	
+    #define CFG_OR_e2pqbypd_MASK 	0xfffbffff 	/* bit 18 */
+    #define CFG_OR_e2pqbypd_disable 	0x0 		
+    #define CFG_OR_e2pqbypd_enable 	0x40000 	
+    #define CFG_OR_e2pbypclk_MASK 	0xfff7ffff 	/* bit 19 */
+    #define CFG_OR_e2pbypclk_disable 	0x0 		
+    #define CFG_OR_e2pbypclk_enable 	0x80000 	
+    #define CFG_OR_e2pbyp_MASK 		0xffefffff 	/* bit 20 */
+    #define CFG_OR_e2pbyp_disable 	0x0 		
+    #define CFG_OR_e2pbyp_enable 	0x100000 	
+    #define CFG_OR_rate_cap_or_MASK 	0xff1fffff 	/* bits 21-23 */
+    #define CFG_OR_rate_cap_or_SHIFT 	21 		
+    #define CFG_OR_rq_or_MASK 		0xe0ffffff 	/* bits 24-28 */
+    #define CFG_OR_rq_or_SHIFT 		24 		
+
+#define MGAREG_ALPHACTRL 			0x2c7c
+
+    #define AC_src_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define AC_src_zero 		0x0 		/* val 0, shift 0 */
+    #define AC_src_one 			0x1 		/* val 1, shift 0 */
+    #define AC_src_dst_color 		0x2 		/* val 2, shift 0 */
+    #define AC_src_om_dst_color 	0x3 		/* val 3, shift 0 */
+    #define AC_src_src_alpha 		0x4 		/* val 4, shift 0 */
+    #define AC_src_om_src_alpha 	0x5 		/* val 5, shift 0 */
+    #define AC_src_dst_alpha 		0x6 		/* val 6, shift 0 */
+    #define AC_src_om_dst_alpha 	0x7 		/* val 7, shift 0 */
+    #define AC_src_src_alpha_sat 	0x8 		/* val 8, shift 0 */
+    #define AC_dst_MASK 		0xffffff0f 	/* bits 4-7 */
+    #define AC_dst_zero 		0x0 		/* val 0, shift 4 */
+    #define AC_dst_one 			0x10 		/* val 1, shift 4 */
+    #define AC_dst_src_color 		0x20 		/* val 2, shift 4 */
+    #define AC_dst_om_src_color 	0x30 		/* val 3, shift 4 */
+    #define AC_dst_src_alpha 		0x40 		/* val 4, shift 4 */
+    #define AC_dst_om_src_alpha 	0x50 		/* val 5, shift 4 */
+    #define AC_dst_dst_alpha 		0x60 		/* val 6, shift 4 */
+    #define AC_dst_om_dst_alpha 	0x70 		/* val 7, shift 4 */
+    #define AC_amode_MASK 		0xfffffcff 	/* bits 8-9 */
+    #define AC_amode_FCOL 		0x0 		/* val 0, shift 8 */
+    #define AC_amode_alpha_channel 	0x100 		/* val 1, shift 8 */
+    #define AC_amode_video_alpha 	0x200 		/* val 2, shift 8 */
+    #define AC_amode_RSVD 		0x300 		/* val 3, shift 8 */
+    #define AC_astipple_MASK 		0xfffff7ff 	/* bit 11 */
+    #define AC_astipple_disable 	0x0 		
+    #define AC_astipple_enable 		0x800 		
+    #define AC_aten_MASK 		0xffffefff 	/* bit 12 */
+    #define AC_aten_disable 		0x0 		
+    #define AC_aten_enable 		0x1000 		
+    #define AC_atmode_MASK 		0xffff1fff 	/* bits 13-15 */
+    #define AC_atmode_noacmp 		0x0 		/* val 0, shift 13 */
+    #define AC_atmode_ae 		0x4000 		/* val 2, shift 13 */
+    #define AC_atmode_ane 		0x6000 		/* val 3, shift 13 */
+    #define AC_atmode_alt 		0x8000 		/* val 4, shift 13 */
+    #define AC_atmode_alte 		0xa000 		/* val 5, shift 13 */
+    #define AC_atmode_agt 		0xc000 		/* val 6, shift 13 */
+    #define AC_atmode_agte 		0xe000 		/* val 7, shift 13 */
+    #define AC_atref_MASK 		0xff00ffff 	/* bits 16-23 */
+    #define AC_atref_SHIFT 		16 		
+    #define AC_alphasel_MASK 		0xfcffffff 	/* bits 24-25 */
+    #define AC_alphasel_fromtex 	0x0 		/* val 0, shift 24 */
+    #define AC_alphasel_diffused 	0x1000000 	/* val 1, shift 24 */
+    #define AC_alphasel_modulated 	0x2000000 	/* val 2, shift 24 */
+    #define AC_alphasel_trans 		0x3000000 	/* val 3, shift 24 */
+
+#define MGAREG_ALPHASTART 			0x2c70
+#define MGAREG_ALPHAXINC 			0x2c74
+#define MGAREG_ALPHAYINC 			0x2c78
+#define MGAREG_AR0 				0x1c60
+
+    #define AR0_ar0_MASK 		0xfffc0000 	/* bits 0-17 */
+    #define AR0_ar0_SHIFT 		0 		
+
+#define MGAREG_AR1 				0x1c64
+
+    #define AR1_ar1_MASK 		0xff000000 	/* bits 0-23 */
+    #define AR1_ar1_SHIFT 		0 		
+
+#define MGAREG_AR2 				0x1c68
+
+    #define AR2_ar2_MASK 		0xfffc0000 	/* bits 0-17 */
+    #define AR2_ar2_SHIFT 		0 		
+
+#define MGAREG_AR3 				0x1c6c
+
+    #define AR3_ar3_MASK 		0xff000000 	/* bits 0-23 */
+    #define AR3_ar3_SHIFT 		0 		
+    #define AR3_spage_MASK 		0xf8ffffff 	/* bits 24-26 */
+    #define AR3_spage_SHIFT 		24 		
+
+#define MGAREG_AR4 				0x1c70
+
+    #define AR4_ar4_MASK 		0xfffc0000 	/* bits 0-17 */
+    #define AR4_ar4_SHIFT 		0 		
+
+#define MGAREG_AR5 				0x1c74
+
+    #define AR5_ar5_MASK 		0xfffc0000 	/* bits 0-17 */
+    #define AR5_ar5_SHIFT 		0 		
+
+#define MGAREG_AR6 				0x1c78
+
+    #define AR6_ar6_MASK 		0xfffc0000 	/* bits 0-17 */
+    #define AR6_ar6_SHIFT 		0 		
+
+#define MGAREG_BCOL 				0x1c20
+#define MGAREG_BESA1CORG 			0x3d10
+#define MGAREG_BESA1ORG 			0x3d00
+#define MGAREG_BESA2CORG 			0x3d14
+#define MGAREG_BESA2ORG 			0x3d04
+#define MGAREG_BESB1CORG 			0x3d18
+#define MGAREG_BESB1ORG 			0x3d08
+#define MGAREG_BESB2CORG 			0x3d1c
+#define MGAREG_BESB2ORG 			0x3d0c
+#define MGAREG_BESCTL 				0x3d20
+
+    #define BC_besen_MASK 		0xfffffffe 	/* bit 0 */
+    #define BC_besen_disable 		0x0 		
+    #define BC_besen_enable 		0x1 		
+    #define BC_besv1srcstp_MASK 	0xffffffbf 	/* bit 6 */
+    #define BC_besv1srcstp_even 	0x0 		
+    #define BC_besv1srcstp_odd 		0x40 		
+    #define BC_besv2srcstp_MASK 	0xfffffeff 	/* bit 8 */
+    #define BC_besv2srcstp_disable 	0x0 		
+    #define BC_besv2srcstp_enable 	0x100 		
+    #define BC_beshfen_MASK 		0xfffffbff 	/* bit 10 */
+    #define BC_beshfen_disable 		0x0 		
+    #define BC_beshfen_enable 		0x400 		
+    #define BC_besvfen_MASK 		0xfffff7ff 	/* bit 11 */
+    #define BC_besvfen_disable 		0x0 		
+    #define BC_besvfen_enable 		0x800 		
+    #define BC_beshfixc_MASK 		0xffffefff 	/* bit 12 */
+    #define BC_beshfixc_weight 		0x0 		
+    #define BC_beshfixc_coeff 		0x1000 		
+    #define BC_bescups_MASK 		0xfffeffff 	/* bit 16 */
+    #define BC_bescups_disable 		0x0 		
+    #define BC_bescups_enable 		0x10000 	
+    #define BC_bes420pl_MASK 		0xfffdffff 	/* bit 17 */
+    #define BC_bes420pl_422 		0x0 		
+    #define BC_bes420pl_420 		0x20000 	
+    #define BC_besdith_MASK 		0xfffbffff 	/* bit 18 */
+    #define BC_besdith_disable 		0x0 		
+    #define BC_besdith_enable 		0x40000 	
+    #define BC_beshmir_MASK 		0xfff7ffff 	/* bit 19 */
+    #define BC_beshmir_disable 		0x0 		
+    #define BC_beshmir_enable 		0x80000 	
+    #define BC_besbwen_MASK 		0xffefffff 	/* bit 20 */
+    #define BC_besbwen_color 		0x0 		
+    #define BC_besbwen_bw 		0x100000 	
+    #define BC_besblank_MASK 		0xffdfffff 	/* bit 21 */
+    #define BC_besblank_disable 	0x0 		
+    #define BC_besblank_enable 		0x200000 	
+    #define BC_besfselm_MASK 		0xfeffffff 	/* bit 24 */
+    #define BC_besfselm_soft 		0x0 		
+    #define BC_besfselm_hard 		0x1000000 	
+    #define BC_besfsel_MASK 		0xf9ffffff 	/* bits 25-26 */
+    #define BC_besfsel_a1 		0x0 		/* val 0, shift 25 */
+    #define BC_besfsel_a2 		0x2000000 	/* val 1, shift 25 */
+    #define BC_besfsel_b1 		0x4000000 	/* val 2, shift 25 */
+    #define BC_besfsel_b2 		0x6000000 	/* val 3, shift 25 */
+
+#define MGAREG_BESGLOBCTL 			0x3dc0
+
+    #define BGC_beshzoom_MASK 		0xfffffffe 	/* bit 0 */
+    #define BGC_beshzoom_disable 	0x0 		
+    #define BGC_beshzoom_enable 	0x1 		
+    #define BGC_beshzoomf_MASK 		0xfffffffd 	/* bit 1 */
+    #define BGC_beshzoomf_disable 	0x0 		
+    #define BGC_beshzoomf_enable 	0x2 		
+    #define BGC_bescorder_MASK 		0xfffffff7 	/* bit 3 */
+    #define BGC_bescorder_even 		0x0 		
+    #define BGC_bescorder_odd 		0x8 		
+    #define BGC_besreghup_MASK 		0xffffffef 	/* bit 4 */
+    #define BGC_besreghup_disable 	0x0 		
+    #define BGC_besreghup_enable 	0x10 		
+    #define BGC_besvcnt_MASK 		0xf000ffff 	/* bits 16-27 */
+    #define BGC_besvcnt_SHIFT 		16 		
+
+#define MGAREG_BESHCOORD 			0x3d28
+
+    #define BHC_besright_MASK 		0xfffff800 	/* bits 0-10 */
+    #define BHC_besright_SHIFT 		0 		
+    #define BHC_besleft_MASK 		0xf800ffff 	/* bits 16-26 */
+    #define BHC_besleft_SHIFT 		16 		
+
+#define MGAREG_BESHISCAL 			0x3d30
+
+    #define BHISF_beshiscal_MASK 	0xffe00003 	/* bits 2-20 */
+    #define BHISF_beshiscal_SHIFT 	2 		
+
+#define MGAREG_BESHSRCEND 			0x3d3c
+
+    #define BHSE_beshsrcend_MASK 	0xfc000003 	/* bits 2-25 */
+    #define BHSE_beshsrcend_SHIFT 	2 		
+
+#define MGAREG_BESHSRCLST 			0x3d50
+
+    #define BHSL_beshsrclst_MASK 	0xfc00ffff 	/* bits 16-25 */
+    #define BHSL_beshsrclst_SHIFT 	16 		
+
+#define MGAREG_BESHSRCST 			0x3d38
+
+    #define BHSS_beshsrcst_MASK 	0xfc000003 	/* bits 2-25 */
+    #define BHSS_beshsrcst_SHIFT 	2 		
+
+#define MGAREG_BESPITCH 			0x3d24
+
+    #define BP_bespitch_MASK 		0xfffff000 	/* bits 0-11 */
+    #define BP_bespitch_SHIFT 		0 		
+
+#define MGAREG_BESSTATUS 			0x3dc4
+
+    #define BS_besstat_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define BS_besstat_a1 		0x0 		/* val 0, shift 0 */
+    #define BS_besstat_a2 		0x1 		/* val 1, shift 0 */
+    #define BS_besstat_b1 		0x2 		/* val 2, shift 0 */
+    #define BS_besstat_b2 		0x3 		/* val 3, shift 0 */
+
+#define MGAREG_BESV1SRCLST 			0x3d54
+
+    #define BSF_besv1srclast_MASK 	0xfffffc00 	/* bits 0-9 */
+    #define BSF_besv1srclast_SHIFT 	0 		
+
+#define MGAREG_BESV2SRCLST 			0x3d58
+
+    #define BSF_besv2srclst_MASK 	0xfffffc00 	/* bits 0-9 */
+    #define BSF_besv2srclst_SHIFT 	0 		
+
+#define MGAREG_BESV1WGHT 			0x3d48
+
+    #define BSF_besv1wght_MASK 		0xffff0003 	/* bits 2-15 */
+    #define BSF_besv1wght_SHIFT 	2 		
+    #define BSF_besv1wghts_MASK 	0xfffeffff 	/* bit 16 */
+    #define BSF_besv1wghts_disable 	0x0 		
+    #define BSF_besv1wghts_enable 	0x10000 	
+
+#define MGAREG_BESV2WGHT 			0x3d4c
+
+    #define BSF_besv2wght_MASK 		0xffff0003 	/* bits 2-15 */
+    #define BSF_besv2wght_SHIFT 	2 		
+    #define BSF_besv2wghts_MASK 	0xfffeffff 	/* bit 16 */
+    #define BSF_besv2wghts_disable 	0x0 		
+    #define BSF_besv2wghts_enable 	0x10000 	
+
+#define MGAREG_BESVCOORD 			0x3d2c
+
+    #define BVC_besbot_MASK 		0xfffff800 	/* bits 0-10 */
+    #define BVC_besbot_SHIFT 		0 		
+    #define BVC_bestop_MASK 		0xf800ffff 	/* bits 16-26 */
+    #define BVC_bestop_SHIFT 		16 		
+
+#define MGAREG_BESVISCAL 			0x3d34
+
+    #define BVISF_besviscal_MASK 	0xffe00003 	/* bits 2-20 */
+    #define BVISF_besviscal_SHIFT 	2 		
+
+#define MGAREG_CODECADDR 			0x3e44
+#define MGAREG_CODECCTL 			0x3e40
+#define MGAREG_CODECHARDPTR 			0x3e4c
+#define MGAREG_CODECHOSTPTR 			0x3e48
+#define MGAREG_CODECLCODE 			0x3e50
+#define MGAREG_CXBNDRY 			0x1c80
+
+    #define CXB_cxleft_MASK 		0xfffff000 	/* bits 0-11 */
+    #define CXB_cxleft_SHIFT 		0 		
+    #define CXB_cxright_MASK 		0xf000ffff 	/* bits 16-27 */
+    #define CXB_cxright_SHIFT 		16 		
+
+#define MGAREG_CXLEFT 				0x1ca0
+#define MGAREG_CXRIGHT 			0x1ca4
+#define MGAREG_DMAMAP30 			0x1e30
+#define MGAREG_DMAMAP74 			0x1e34
+#define MGAREG_DMAMAPB8 			0x1e38
+#define MGAREG_DMAMAPFC 			0x1e3c
+#define MGAREG_DMAPAD 				0x1c54
+#define MGAREG_DR0_Z32LSB 			0x2c50
+#define MGAREG_DR0_Z32MSB 			0x2c54
+#define MGAREG_DR2_Z32LSB 			0x2c60
+#define MGAREG_DR2_Z32MSB 			0x2c64
+#define MGAREG_DR3_Z32LSB 			0x2c68
+#define MGAREG_DR3_Z32MSB 			0x2c6c
+#define MGAREG_DR0 				0x1cc0
+#define MGAREG_DR2 				0x1cc8
+#define MGAREG_DR3 				0x1ccc
+#define MGAREG_DR4 				0x1cd0
+#define MGAREG_DR6 				0x1cd8
+#define MGAREG_DR7 				0x1cdc
+#define MGAREG_DR8 				0x1ce0
+#define MGAREG_DR10 				0x1ce8
+#define MGAREG_DR11 				0x1cec
+#define MGAREG_DR12 				0x1cf0
+#define MGAREG_DR14 				0x1cf8
+#define MGAREG_DR15 				0x1cfc
+#define MGAREG_DSTORG 				0x2cb8
+
+    #define DO_dstmap_MASK 		0xfffffffe 	/* bit 0 */
+    #define DO_dstmap_fb 		0x0 		
+    #define DO_dstmap_sys 		0x1 		
+    #define DO_dstacc_MASK 		0xfffffffd 	/* bit 1 */
+    #define DO_dstacc_pci 		0x0 		
+    #define DO_dstacc_agp 		0x2 		
+    #define DO_dstorg_MASK 		0x7 		/* bits 3-31 */
+    #define DO_dstorg_SHIFT 		3 		
+
+#define MGAREG_DWG_INDIR_WT 			0x1e80
+#define MGAREG_DWGCTL 				0x1c00
+
+    #define DC_opcod_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define DC_opcod_line_open 		0x0 		/* val 0, shift 0 */
+    #define DC_opcod_autoline_open 	0x1 		/* val 1, shift 0 */
+    #define DC_opcod_line_close 	0x2 		/* val 2, shift 0 */
+    #define DC_opcod_autoline_close 	0x3 		/* val 3, shift 0 */
+    #define DC_opcod_trap 		0x4 		/* val 4, shift 0 */
+    #define DC_opcod_texture_trap 	0x6 		/* val 6, shift 0 */
+    #define DC_opcod_bitblt 		0x8 		/* val 8, shift 0 */
+    #define DC_opcod_iload 		0x9 		/* val 9, shift 0 */
+    #define DC_atype_MASK 		0xffffff8f 	/* bits 4-6 */
+    #define DC_atype_rpl 		0x0 		/* val 0, shift 4 */
+    #define DC_atype_rstr 		0x10 		/* val 1, shift 4 */
+    #define DC_atype_zi 		0x30 		/* val 3, shift 4 */
+    #define DC_atype_blk 		0x40 		/* val 4, shift 4 */
+    #define DC_atype_i 			0x70 		/* val 7, shift 4 */
+    #define DC_linear_MASK 		0xffffff7f 	/* bit 7 */
+    #define DC_linear_xy 		0x0 		
+    #define DC_linear_linear 		0x80 		
+    #define DC_zmode_MASK 		0xfffff8ff 	/* bits 8-10 */
+    #define DC_zmode_nozcmp 		0x0 		/* val 0, shift 8 */
+    #define DC_zmode_ze 		0x200 		/* val 2, shift 8 */
+    #define DC_zmode_zne 		0x300 		/* val 3, shift 8 */
+    #define DC_zmode_zlt 		0x400 		/* val 4, shift 8 */
+    #define DC_zmode_zlte 		0x500 		/* val 5, shift 8 */
+    #define DC_zmode_zgt 		0x600 		/* val 6, shift 8 */
+    #define DC_zmode_zgte 		0x700 		/* val 7, shift 8 */
+    #define DC_solid_MASK 		0xfffff7ff 	/* bit 11 */
+    #define DC_solid_disable 		0x0 		
+    #define DC_solid_enable 		0x800 		
+    #define DC_arzero_MASK 		0xffffefff 	/* bit 12 */
+    #define DC_arzero_disable 		0x0 		
+    #define DC_arzero_enable 		0x1000 		
+    #define DC_sgnzero_MASK 		0xffffdfff 	/* bit 13 */
+    #define DC_sgnzero_disable 		0x0 		
+    #define DC_sgnzero_enable 		0x2000 		
+    #define DC_shftzero_MASK 		0xffffbfff 	/* bit 14 */
+    #define DC_shftzero_disable 	0x0 		
+    #define DC_shftzero_enable 		0x4000 		
+    #define DC_bop_MASK 		0xfff0ffff 	/* bits 16-19 */
+    #define DC_bop_SHIFT 		16 		
+    #define DC_trans_MASK 		0xff0fffff 	/* bits 20-23 */
+    #define DC_trans_SHIFT 		20 		
+    #define DC_bltmod_MASK 		0xe1ffffff 	/* bits 25-28 */
+    #define DC_bltmod_bmonolef 		0x0 		/* val 0, shift 25 */
+    #define DC_bltmod_bmonowf 		0x8000000 	/* val 4, shift 25 */
+    #define DC_bltmod_bplan 		0x2000000 	/* val 1, shift 25 */
+    #define DC_bltmod_bfcol 		0x4000000 	/* val 2, shift 25 */
+    #define DC_bltmod_bu32bgr 		0x6000000 	/* val 3, shift 25 */
+    #define DC_bltmod_bu32rgb 		0xe000000 	/* val 7, shift 25 */
+    #define DC_bltmod_bu24bgr 		0x16000000 	/* val 11, shift 25 */
+    #define DC_bltmod_bu24rgb 		0x1e000000 	/* val 15, shift 25 */
+    #define DC_pattern_MASK 		0xdfffffff 	/* bit 29 */
+    #define DC_pattern_disable 		0x0 		
+    #define DC_pattern_enable 		0x20000000 	
+    #define DC_transc_MASK 		0xbfffffff 	/* bit 30 */
+    #define DC_transc_disable 		0x0 		
+    #define DC_transc_enable 		0x40000000 	
+    #define DC_clipdis_MASK 		0x7fffffff 	/* bit 31 */
+    #define DC_clipdis_disable 		0x0 		
+    #define DC_clipdis_enable 		0x80000000 	
+
+#define MGAREG_DWGSYNC 			0x2c4c
+
+    #define DS_dwgsyncaddr_MASK 	0x3 		/* bits 2-31 */
+    #define DS_dwgsyncaddr_SHIFT 	2 		
+
+#define MGAREG_FCOL 				0x1c24
+#define MGAREG_FIFOSTATUS 			0x1e10
+
+    #define FS_fifocount_MASK 		0xffffff80 	/* bits 0-6 */
+    #define FS_fifocount_SHIFT 		0 		
+    #define FS_bfull_MASK 		0xfffffeff 	/* bit 8 */
+    #define FS_bfull_disable 		0x0 		
+    #define FS_bfull_enable 		0x100 		
+    #define FS_bempty_MASK 		0xfffffdff 	/* bit 9 */
+    #define FS_bempty_disable 		0x0 		
+    #define FS_bempty_enable 		0x200 		
+
+#define MGAREG_FOGCOL 				0x1cf4
+#define MGAREG_FOGSTART 			0x1cc4
+#define MGAREG_FOGXINC 			0x1cd4
+#define MGAREG_FOGYINC 			0x1ce4
+#define MGAREG_FXBNDRY 			0x1c84
+
+    #define XA_fxleft_MASK 		0xffff0000 	/* bits 0-15 */
+    #define XA_fxleft_SHIFT 		0 		
+    #define XA_fxright_MASK 		0xffff 		/* bits 16-31 */
+    #define XA_fxright_SHIFT 		16 		
+
+#define MGAREG_FXLEFT 				0x1ca8
+#define MGAREG_FXRIGHT 			0x1cac
+#define MGAREG_ICLEAR 				0x1e18
+
+    #define IC_softrapiclr_MASK 	0xfffffffe 	/* bit 0 */
+    #define IC_softrapiclr_disable 	0x0 		
+    #define IC_softrapiclr_enable 	0x1 		
+    #define IC_pickiclr_MASK 		0xfffffffb 	/* bit 2 */
+    #define IC_pickiclr_disable 	0x0 		
+    #define IC_pickiclr_enable 		0x4 		
+    #define IC_vlineiclr_MASK 		0xffffffdf 	/* bit 5 */
+    #define IC_vlineiclr_disable 	0x0 		
+    #define IC_vlineiclr_enable 	0x20 		
+    #define IC_wiclr_MASK 		0xffffff7f 	/* bit 7 */
+    #define IC_wiclr_disable 		0x0 		
+    #define IC_wiclr_enable 		0x80 		
+    #define IC_wciclr_MASK 		0xfffffeff 	/* bit 8 */
+    #define IC_wciclr_disable 		0x0 		
+    #define IC_wciclr_enable 		0x100 		
+
+#define MGAREG_IEN 				0x1e1c
+
+    #define IE_softrapien_MASK 		0xfffffffe 	/* bit 0 */
+    #define IE_softrapien_disable 	0x0 		
+    #define IE_softrapien_enable 	0x1 		
+    #define IE_pickien_MASK 		0xfffffffb 	/* bit 2 */
+    #define IE_pickien_disable 		0x0 		
+    #define IE_pickien_enable 		0x4 		
+    #define IE_vlineien_MASK 		0xffffffdf 	/* bit 5 */
+    #define IE_vlineien_disable 	0x0 		
+    #define IE_vlineien_enable 		0x20 		
+    #define IE_extien_MASK 		0xffffffbf 	/* bit 6 */
+    #define IE_extien_disable 		0x0 		
+    #define IE_extien_enable 		0x40 		
+    #define IE_wien_MASK 		0xffffff7f 	/* bit 7 */
+    #define IE_wien_disable 		0x0 		
+    #define IE_wien_enable 		0x80 		
+    #define IE_wcien_MASK 		0xfffffeff 	/* bit 8 */
+    #define IE_wcien_disable 		0x0 		
+    #define IE_wcien_enable 		0x100 		
+
+#define MGAREG_LEN 				0x1c5c
+#define MGAREG_MACCESS 			0x1c04
+
+    #define MA_pwidth_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define MA_pwidth_8 		0x0 		/* val 0, shift 0 */
+    #define MA_pwidth_16 		0x1 		/* val 1, shift 0 */
+    #define MA_pwidth_32 		0x2 		/* val 2, shift 0 */
+    #define MA_pwidth_24 		0x3 		/* val 3, shift 0 */
+    #define MA_zwidth_MASK 		0xffffffe7 	/* bits 3-4 */
+    #define MA_zwidth_16 		0x0 		/* val 0, shift 3 */
+    #define MA_zwidth_32 		0x8 		/* val 1, shift 3 */
+    #define MA_zwidth_15 		0x10 		/* val 2, shift 3 */
+    #define MA_zwidth_24 		0x18 		/* val 3, shift 3 */
+    #define MA_memreset_MASK 		0xffff7fff 	/* bit 15 */
+    #define MA_memreset_disable 	0x0 		
+    #define MA_memreset_enable 		0x8000 		
+    #define MA_fogen_MASK 		0xfbffffff 	/* bit 26 */
+    #define MA_fogen_disable 		0x0 		
+    #define MA_fogen_enable 		0x4000000 	
+    #define MA_tlutload_MASK 		0xdfffffff 	/* bit 29 */
+    #define MA_tlutload_disable 	0x0 		
+    #define MA_tlutload_enable 		0x20000000 	
+    #define MA_nodither_MASK 		0xbfffffff 	/* bit 30 */
+    #define MA_nodither_disable 	0x0 		
+    #define MA_nodither_enable 		0x40000000 	
+    #define MA_dit555_MASK 		0x7fffffff 	/* bit 31 */
+    #define MA_dit555_disable 		0x0 		
+    #define MA_dit555_enable 		0x80000000 	
+
+#define MGAREG_MCTLWTST 			0x1c08
+
+    #define MCWS_casltncy_MASK 		0xfffffff8 	/* bits 0-2 */
+    #define MCWS_casltncy_SHIFT 	0 		
+    #define MCWS_rrddelay_MASK 		0xffffffcf 	/* bits 4-5 */
+    #define MCWS_rcddelay_MASK 		0xfffffe7f 	/* bits 7-8 */
+    #define MCWS_rasmin_MASK 		0xffffe3ff 	/* bits 10-12 */
+    #define MCWS_rasmin_SHIFT 		10 		
+    #define MCWS_rpdelay_MASK 		0xffff3fff 	/* bits 14-15 */
+    #define MCWS_wrdelay_MASK 		0xfff3ffff 	/* bits 18-19 */
+    #define MCWS_rddelay_MASK 		0xffdfffff 	/* bit 21 */
+    #define MCWS_rddelay_disable 	0x0 		
+    #define MCWS_rddelay_enable 	0x200000 	
+    #define MCWS_smrdelay_MASK 		0xfe7fffff 	/* bits 23-24 */
+    #define MCWS_bwcdelay_MASK 		0xf3ffffff 	/* bits 26-27 */
+    #define MCWS_bpldelay_MASK 		0x1fffffff 	/* bits 29-31 */
+    #define MCWS_bpldelay_SHIFT 	29 		
+
+#define MGAREG_MEMRDBK 			0x1e44
+
+    #define MRB_mclkbrd0_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define MRB_mclkbrd0_SHIFT 		0 		
+    #define MRB_mclkbrd1_MASK 		0xfffffe1f 	/* bits 5-8 */
+    #define MRB_mclkbrd1_SHIFT 		5 		
+    #define MRB_strmfctl_MASK 		0xff3fffff 	/* bits 22-23 */
+    #define MRB_mrsopcod_MASK 		0xe1ffffff 	/* bits 25-28 */
+    #define MRB_mrsopcod_SHIFT 		25 		
+
+#define MGAREG_OPMODE 				0x1e54
+
+    #define OM_dmamod_MASK 		0xfffffff3 	/* bits 2-3 */
+    #define OM_dmamod_general 		0x0 		/* val 0, shift 2 */
+    #define OM_dmamod_blit 		0x4 		/* val 1, shift 2 */
+    #define OM_dmamod_vector 		0x8 		/* val 2, shift 2 */
+    #define OM_dmamod_vertex 		0xc 		/* val 3, shift 2 */
+    #define OM_dmadatasiz_MASK 		0xfffffcff 	/* bits 8-9 */
+    #define OM_dmadatasiz_8 		0x0 		/* val 0, shift 8 */
+    #define OM_dmadatasiz_16 		0x100 		/* val 1, shift 8 */
+    #define OM_dmadatasiz_32 		0x200 		/* val 2, shift 8 */
+    #define OM_dirdatasiz_MASK 		0xfffcffff 	/* bits 16-17 */
+    #define OM_dirdatasiz_8 		0x0 		/* val 0, shift 16 */
+    #define OM_dirdatasiz_16 		0x10000 	/* val 1, shift 16 */
+    #define OM_dirdatasiz_32 		0x20000 	/* val 2, shift 16 */
+
+#define MGAREG_PAT0 				0x1c10
+#define MGAREG_PAT1 				0x1c14
+#define MGAREG_PITCH 				0x1c8c
+
+    #define P_iy_MASK 			0xffffe000 	/* bits 0-12 */
+    #define P_iy_SHIFT 			0 		
+    #define P_ylin_MASK 		0xffff7fff 	/* bit 15 */
+    #define P_ylin_disable 		0x0 		
+    #define P_ylin_enable 		0x8000 		
+
+#define MGAREG_PLNWT 				0x1c1c
+#define MGAREG_PRIMADDRESS 			0x1e58
+
+    #define PDCA_primod_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define PDCA_primod_general 	0x0 		/* val 0, shift 0 */
+    #define PDCA_primod_blit 		0x1 		/* val 1, shift 0 */
+    #define PDCA_primod_vector 		0x2 		/* val 2, shift 0 */
+    #define PDCA_primod_vertex 		0x3 		/* val 3, shift 0 */
+    #define PDCA_primaddress_MASK 	0x3 		/* bits 2-31 */
+    #define PDCA_primaddress_SHIFT 	2 		
+
+#define MGAREG_PRIMEND 			0x1e5c
+
+    #define PDEA_primnostart_MASK 	0xfffffffe 	/* bit 0 */
+    #define PDEA_primnostart_disable 	0x0 		
+    #define PDEA_primnostart_enable 	0x1 		
+    #define PDEA_pagpxfer_MASK 		0xfffffffd 	/* bit 1 */
+    #define PDEA_pagpxfer_disable 	0x0 		
+    #define PDEA_pagpxfer_enable 	0x2 		
+    #define PDEA_primend_MASK 		0x3 		/* bits 2-31 */
+    #define PDEA_primend_SHIFT 		2 		
+
+#define MGAREG_PRIMPTR 			0x1e50
+
+    #define PLS_primptren0_MASK 	0xfffffffe 	/* bit 0 */
+    #define PLS_primptren0_disable 	0x0 		
+    #define PLS_primptren0_enable 	0x1 		
+    #define PLS_primptren1_MASK 	0xfffffffd 	/* bit 1 */
+    #define PLS_primptren1_disable 	0x0 		
+    #define PLS_primptren1_enable 	0x2 		
+    #define PLS_primptr_MASK 		0x7 		/* bits 3-31 */
+    #define PLS_primptr_SHIFT 		3 		
+
+#define MGAREG_RST 				0x1e40
+
+    #define R_softreset_MASK 		0xfffffffe 	/* bit 0 */
+    #define R_softreset_disable 	0x0 		
+    #define R_softreset_enable 		0x1 		
+    #define R_softextrst_MASK 		0xfffffffd 	/* bit 1 */
+    #define R_softextrst_disable 	0x0 		
+    #define R_softextrst_enable 	0x2 		
+
+#define MGAREG_SECADDRESS 			0x2c40
+
+    #define SDCA_secmod_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define SDCA_secmod_general 	0x0 		/* val 0, shift 0 */
+    #define SDCA_secmod_blit 		0x1 		/* val 1, shift 0 */
+    #define SDCA_secmod_vector 		0x2 		/* val 2, shift 0 */
+    #define SDCA_secmod_vertex 		0x3 		/* val 3, shift 0 */
+    #define SDCA_secaddress_MASK 	0x3 		/* bits 2-31 */
+    #define SDCA_secaddress_SHIFT 	2 		
+
+#define MGAREG_SECEND 				0x2c44
+
+    #define SDEA_sagpxfer_MASK 		0xfffffffd 	/* bit 1 */
+    #define SDEA_sagpxfer_disable 	0x0 		
+    #define SDEA_sagpxfer_enable 	0x2 		
+    #define SDEA_secend_MASK 		0x3 		/* bits 2-31 */
+    #define SDEA_secend_SHIFT 		2 		
+
+#define MGAREG_SETUPADDRESS 			0x2cd0
+
+    #define SETADD_mode_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define SETADD_mode_vertlist 	0x0 		/* val 0, shift 0 */
+    #define SETADD_address_MASK 	0x3 		/* bits 2-31 */
+    #define SETADD_address_SHIFT 	2 		
+
+#define MGAREG_SETUPEND 			0x2cd4
+
+    #define SETEND_agpxfer_MASK 	0xfffffffd 	/* bit 1 */
+    #define SETEND_agpxfer_disable 	0x0 		
+    #define SETEND_agpxfer_enable 	0x2 		
+    #define SETEND_address_MASK 	0x3 		/* bits 2-31 */
+    #define SETEND_address_SHIFT 	2 		
+
+#define MGAREG_SGN 				0x1c58
+
+    #define S_sdydxl_MASK 		0xfffffffe 	/* bit 0 */
+    #define S_sdydxl_y 			0x0 		
+    #define S_sdydxl_x 			0x1 		
+    #define S_scanleft_MASK 		0xfffffffe 	/* bit 0 */
+    #define S_scanleft_disable 		0x0 		
+    #define S_scanleft_enable 		0x1 		
+    #define S_sdxl_MASK 		0xfffffffd 	/* bit 1 */
+    #define S_sdxl_pos 			0x0 		
+    #define S_sdxl_neg 			0x2 		
+    #define S_sdy_MASK 			0xfffffffb 	/* bit 2 */
+    #define S_sdy_pos 			0x0 		
+    #define S_sdy_neg 			0x4 		
+    #define S_sdxr_MASK 		0xffffffdf 	/* bit 5 */
+    #define S_sdxr_pos 			0x0 		
+    #define S_sdxr_neg 			0x20 		
+    #define S_brkleft_MASK 		0xfffffeff 	/* bit 8 */
+    #define S_brkleft_disable 		0x0 		
+    #define S_brkleft_enable 		0x100 		
+    #define S_errorinit_MASK 		0x7fffffff 	/* bit 31 */
+    #define S_errorinit_disable 	0x0 		
+    #define S_errorinit_enable 		0x80000000 	
+
+#define MGAREG_SHIFT 				0x1c50
+
+    #define FSC_x_off_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define FSC_x_off_SHIFT 		0 		
+    #define FSC_funcnt_MASK 		0xffffff80 	/* bits 0-6 */
+    #define FSC_funcnt_SHIFT 		0 		
+    #define FSC_y_off_MASK 		0xffffff8f 	/* bits 4-6 */
+    #define FSC_y_off_SHIFT 		4 		
+    #define FSC_funoff_MASK 		0xffc0ffff 	/* bits 16-21 */
+    #define FSC_funoff_SHIFT 		16 		
+    #define FSC_stylelen_MASK 		0xffc0ffff 	/* bits 16-21 */
+    #define FSC_stylelen_SHIFT 		16 		
+
+#define MGAREG_SOFTRAP 			0x2c48
+
+    #define STH_softraphand_MASK 	0x3 		/* bits 2-31 */
+    #define STH_softraphand_SHIFT 	2 		
+
+#define MGAREG_SPECBSTART 			0x2c98
+#define MGAREG_SPECBXINC 			0x2c9c
+#define MGAREG_SPECBYINC 			0x2ca0
+#define MGAREG_SPECGSTART 			0x2c8c
+#define MGAREG_SPECGXINC 			0x2c90
+#define MGAREG_SPECGYINC 			0x2c94
+#define MGAREG_SPECRSTART 			0x2c80
+#define MGAREG_SPECRXINC 			0x2c84
+#define MGAREG_SPECRYINC 			0x2c88
+#define MGAREG_SRC0 				0x1c30
+#define MGAREG_SRC1 				0x1c34
+#define MGAREG_SRC2 				0x1c38
+#define MGAREG_SRC3 				0x1c3c
+#define MGAREG_SRCORG 				0x2cb4
+
+    #define SO_srcmap_MASK 		0xfffffffe 	/* bit 0 */
+    #define SO_srcmap_fb 		0x0 		
+    #define SO_srcmap_sys 		0x1 		
+    #define SO_srcacc_MASK 		0xfffffffd 	/* bit 1 */
+    #define SO_srcacc_pci 		0x0 		
+    #define SO_srcacc_agp 		0x2 		
+    #define SO_srcorg_MASK 		0x7 		/* bits 3-31 */
+    #define SO_srcorg_SHIFT 		3 		
+
+#define MGAREG_STATUS 				0x1e14
+
+    #define STAT_softrapen_MASK 	0xfffffffe 	/* bit 0 */
+    #define STAT_softrapen_disable 	0x0 		
+    #define STAT_softrapen_enable 	0x1 		
+    #define STAT_pickpen_MASK 		0xfffffffb 	/* bit 2 */
+    #define STAT_pickpen_disable 	0x0 		
+    #define STAT_pickpen_enable 	0x4 		
+    #define STAT_vsyncsts_MASK 		0xfffffff7 	/* bit 3 */
+    #define STAT_vsyncsts_disable 	0x0 		
+    #define STAT_vsyncsts_enable 	0x8 		
+    #define STAT_vsyncpen_MASK 		0xffffffef 	/* bit 4 */
+    #define STAT_vsyncpen_disable 	0x0 		
+    #define STAT_vsyncpen_enable 	0x10 		
+    #define STAT_vlinepen_MASK 		0xffffffdf 	/* bit 5 */
+    #define STAT_vlinepen_disable 	0x0 		
+    #define STAT_vlinepen_enable 	0x20 		
+    #define STAT_extpen_MASK 		0xffffffbf 	/* bit 6 */
+    #define STAT_extpen_disable 	0x0 		
+    #define STAT_extpen_enable 		0x40 		
+    #define STAT_wpen_MASK 		0xffffff7f 	/* bit 7 */
+    #define STAT_wpen_disable 		0x0 		
+    #define STAT_wpen_enable 		0x80 		
+    #define STAT_wcpen_MASK 		0xfffffeff 	/* bit 8 */
+    #define STAT_wcpen_disable 		0x0 		
+    #define STAT_wcpen_enable 		0x100 		
+    #define STAT_dwgengsts_MASK 	0xfffeffff 	/* bit 16 */
+    #define STAT_dwgengsts_disable 	0x0 		
+    #define STAT_dwgengsts_enable 	0x10000 	
+    #define STAT_endprdmasts_MASK 	0xfffdffff 	/* bit 17 */
+    #define STAT_endprdmasts_disable 	0x0 		
+    #define STAT_endprdmasts_enable 	0x20000 	
+    #define STAT_wbusy_MASK 		0xfffbffff 	/* bit 18 */
+    #define STAT_wbusy_disable 		0x0 		
+    #define STAT_wbusy_enable 		0x40000 	
+    #define STAT_swflag_MASK 		0xfffffff 	/* bits 28-31 */
+    #define STAT_swflag_SHIFT 		28 		
+
+#define MGAREG_STENCIL 			0x2cc8
+
+    #define S_sref_MASK 		0xffffff00 	/* bits 0-7 */
+    #define S_sref_SHIFT 		0 		
+    #define S_smsk_MASK 		0xffff00ff 	/* bits 8-15 */
+    #define S_smsk_SHIFT 		8 		
+    #define S_swtmsk_MASK 		0xff00ffff 	/* bits 16-23 */
+    #define S_swtmsk_SHIFT 		16 		
+
+#define MGAREG_STENCILCTL 			0x2ccc
+
+    #define SC_smode_MASK 		0xfffffff8 	/* bits 0-2 */
+    #define SC_smode_salways 		0x0 		/* val 0, shift 0 */
+    #define SC_smode_snever 		0x1 		/* val 1, shift 0 */
+    #define SC_smode_se 		0x2 		/* val 2, shift 0 */
+    #define SC_smode_sne 		0x3 		/* val 3, shift 0 */
+    #define SC_smode_slt 		0x4 		/* val 4, shift 0 */
+    #define SC_smode_slte 		0x5 		/* val 5, shift 0 */
+    #define SC_smode_sgt 		0x6 		/* val 6, shift 0 */
+    #define SC_smode_sgte 		0x7 		/* val 7, shift 0 */
+    #define SC_sfailop_MASK 		0xffffffc7 	/* bits 3-5 */
+    #define SC_sfailop_keep 		0x0 		/* val 0, shift 3 */
+    #define SC_sfailop_zero 		0x8 		/* val 1, shift 3 */
+    #define SC_sfailop_replace 		0x10 		/* val 2, shift 3 */
+    #define SC_sfailop_incrsat 		0x18 		/* val 3, shift 3 */
+    #define SC_sfailop_decrsat 		0x20 		/* val 4, shift 3 */
+    #define SC_sfailop_invert 		0x28 		/* val 5, shift 3 */
+    #define SC_sfailop_incr 		0x30 		/* val 6, shift 3 */
+    #define SC_sfailop_decr 		0x38 		/* val 7, shift 3 */
+    #define SC_szfailop_MASK 		0xfffffe3f 	/* bits 6-8 */
+    #define SC_szfailop_keep 		0x0 		/* val 0, shift 6 */
+    #define SC_szfailop_zero 		0x40 		/* val 1, shift 6 */
+    #define SC_szfailop_replace 	0x80 		/* val 2, shift 6 */
+    #define SC_szfailop_incrsat 	0xc0 		/* val 3, shift 6 */
+    #define SC_szfailop_decrsat 	0x100 		/* val 4, shift 6 */
+    #define SC_szfailop_invert 		0x140 		/* val 5, shift 6 */
+    #define SC_szfailop_incr 		0x180 		/* val 6, shift 6 */
+    #define SC_szfailop_decr 		0x1c0 		/* val 7, shift 6 */
+    #define SC_szpassop_MASK 		0xfffff1ff 	/* bits 9-11 */
+    #define SC_szpassop_keep 		0x0 		/* val 0, shift 9 */
+    #define SC_szpassop_zero 		0x200 		/* val 1, shift 9 */
+    #define SC_szpassop_replace 	0x400 		/* val 2, shift 9 */
+    #define SC_szpassop_incrsat 	0x600 		/* val 3, shift 9 */
+    #define SC_szpassop_decrsat 	0x800 		/* val 4, shift 9 */
+    #define SC_szpassop_invert 		0xa00 		/* val 5, shift 9 */
+    #define SC_szpassop_incr 		0xc00 		/* val 6, shift 9 */
+    #define SC_szpassop_decr 		0xe00 		/* val 7, shift 9 */
+
+#define MGAREG_TDUALSTAGE0 			0x2cf8
+
+    #define TD0_color_arg2_MASK 	0xfffffffc 	/* bits 0-1 */
+    #define TD0_color_arg2_diffuse 	0x0 		/* val 0, shift 0 */
+    #define TD0_color_arg2_specular 	0x1 		/* val 1, shift 0 */
+    #define TD0_color_arg2_fcol 	0x2 		/* val 2, shift 0 */
+    #define TD0_color_arg2_prevstage 	0x3 		/* val 3, shift 0 */
+    #define TD0_color_alpha_MASK 	0xffffffe3 	/* bits 2-4 */
+    #define TD0_color_alpha_diffuse 	0x0 		/* val 0, shift 2 */
+    #define TD0_color_alpha_fcol 	0x4 		/* val 1, shift 2 */
+    #define TD0_color_alpha_currtex 	0x8 		/* val 2, shift 2 */
+    #define TD0_color_alpha_prevtex 	0xc 		/* val 3, shift 2 */
+    #define TD0_color_alpha_prevstage 	0x10 		/* val 4, shift 2 */
+    #define TD0_color_arg1_replicatealpha_MASK 0xffffffdf 	/* bit 5 */
+    #define TD0_color_arg1_replicatealpha_disable 0x0 		
+    #define TD0_color_arg1_replicatealpha_enable 0x20 		
+    #define TD0_color_arg1_inv_MASK 	0xffffffbf 	/* bit 6 */
+    #define TD0_color_arg1_inv_disable 	0x0 		
+    #define TD0_color_arg1_inv_enable 	0x40 		
+    #define TD0_color_arg2_replicatealpha_MASK 0xffffff7f 	/* bit 7 */
+    #define TD0_color_arg2_replicatealpha_disable 0x0 		
+    #define TD0_color_arg2_replicatealpha_enable 0x80 		
+    #define TD0_color_arg2_inv_MASK 	0xfffffeff 	/* bit 8 */
+    #define TD0_color_arg2_inv_disable 	0x0 		
+    #define TD0_color_arg2_inv_enable 	0x100 		
+    #define TD0_color_alpha1inv_MASK 	0xfffffdff 	/* bit 9 */
+    #define TD0_color_alpha1inv_disable 0x0 		
+    #define TD0_color_alpha1inv_enable 	0x200 		
+    #define TD0_color_alpha2inv_MASK 	0xfffffbff 	/* bit 10 */
+    #define TD0_color_alpha2inv_disable 0x0 		
+    #define TD0_color_alpha2inv_enable 	0x400 		
+    #define TD0_color_arg1mul_MASK 	0xfffff7ff 	/* bit 11 */
+    #define TD0_color_arg1mul_disable 	0x0 		/* val 0, shift 11 */
+    #define TD0_color_arg1mul_alpha1 	0x800 		/* val 1, shift 11 */
+    #define TD0_color_arg2mul_MASK 	0xffffefff 	/* bit 12 */
+    #define TD0_color_arg2mul_disable 	0x0 		/* val 0, shift 12 */
+    #define TD0_color_arg2mul_alpha2 	0x1000 		/* val 1, shift 12 */
+    #define TD0_color_arg1add_MASK 	0xffffdfff 	/* bit 13 */
+    #define TD0_color_arg1add_disable 	0x0 		/* val 0, shift 13 */
+    #define TD0_color_arg1add_mulout 	0x2000 		/* val 1, shift 13 */
+    #define TD0_color_arg2add_MASK 	0xffffbfff 	/* bit 14 */
+    #define TD0_color_arg2add_disable 	0x0 		/* val 0, shift 14 */
+    #define TD0_color_arg2add_mulout 	0x4000 		/* val 1, shift 14 */
+    #define TD0_color_modbright_MASK 	0xfffe7fff 	/* bits 15-16 */
+    #define TD0_color_modbright_disable 0x0 		/* val 0, shift 15 */
+    #define TD0_color_modbright_2x 	0x8000 		/* val 1, shift 15 */
+    #define TD0_color_modbright_4x 	0x10000 	/* val 2, shift 15 */
+    #define TD0_color_add_MASK 		0xfffdffff 	/* bit 17 */
+    #define TD0_color_add_sub 		0x0 		/* val 0, shift 17 */
+    #define TD0_color_add_add 		0x20000 	/* val 1, shift 17 */
+    #define TD0_color_add2x_MASK 	0xfffbffff 	/* bit 18 */
+    #define TD0_color_add2x_disable 	0x0 		
+    #define TD0_color_add2x_enable 	0x40000 	
+    #define TD0_color_addbias_MASK 	0xfff7ffff 	/* bit 19 */
+    #define TD0_color_addbias_disable 	0x0 		
+    #define TD0_color_addbias_enable 	0x80000 	
+    #define TD0_color_blend_MASK 	0xffefffff 	/* bit 20 */
+    #define TD0_color_blend_disable 	0x0 		
+    #define TD0_color_blend_enable 	0x100000 	
+    #define TD0_color_sel_MASK 		0xff9fffff 	/* bits 21-22 */
+    #define TD0_color_sel_arg1 		0x0 		/* val 0, shift 21 */
+    #define TD0_color_sel_arg2 		0x200000 	/* val 1, shift 21 */
+    #define TD0_color_sel_add 		0x400000 	/* val 2, shift 21 */
+    #define TD0_color_sel_mul 		0x600000 	/* val 3, shift 21 */
+    #define TD0_alpha_arg1_inv_MASK 	0xff7fffff 	/* bit 23 */
+    #define TD0_alpha_arg1_inv_disable 	0x0 		
+    #define TD0_alpha_arg1_inv_enable 	0x800000 	
+    #define TD0_alpha_arg2_MASK 	0xfcffffff 	/* bits 24-25 */
+    #define TD0_alpha_arg2_diffuse 	0x0 		/* val 0, shift 24 */
+    #define TD0_alpha_arg2_fcol 	0x1000000 	/* val 1, shift 24 */
+    #define TD0_alpha_arg2_prevtex 	0x2000000 	/* val 2, shift 24 */
+    #define TD0_alpha_arg2_prevstage 	0x3000000 	/* val 3, shift 24 */
+    #define TD0_alpha_arg2_inv_MASK 	0xfbffffff 	/* bit 26 */
+    #define TD0_alpha_arg2_inv_disable 	0x0 		
+    #define TD0_alpha_arg2_inv_enable 	0x4000000 	
+    #define TD0_alpha_add_MASK 		0xf7ffffff 	/* bit 27 */
+    #define TD0_alpha_add_disable 	0x0 		
+    #define TD0_alpha_add_enable 	0x8000000 	
+    #define TD0_alpha_addbias_MASK 	0xefffffff 	/* bit 28 */
+    #define TD0_alpha_addbias_disable 	0x0 		
+    #define TD0_alpha_addbias_enable 	0x10000000 	
+    #define TD0_alpha_add2x_MASK 	0xdfffffff 	/* bit 29 */
+    #define TD0_alpha_add2x_disable 	0x0 		
+    #define TD0_alpha_add2x_enable 	0x20000000 	
+    #define TD0_alpha_modbright_MASK 	0xcfffffff 	/* bits 28-29 */
+    #define TD0_alpha_modbright_disable 0x0 		/* val 0, shift 28 */
+    #define TD0_alpha_modbright_2x 	0x10000000 	/* val 1, shift 28 */
+    #define TD0_alpha_modbright_4x 	0x20000000 	/* val 2, shift 28 */
+    #define TD0_alpha_sel_MASK 		0x3fffffff 	/* bits 30-31 */
+    #define TD0_alpha_sel_arg1 		0x0 		/* val 0, shift 30 */
+    #define TD0_alpha_sel_arg2 		0x40000000 	/* val 1, shift 30 */
+    #define TD0_alpha_sel_add 		0x80000000 	/* val 2, shift 30 */
+    #define TD0_alpha_sel_mul 		0xc0000000 	/* val 3, shift 30 */
+
+#define MGAREG_TDUALSTAGE1 			0x2cfc
+
+    #define TD1_color_arg2_MASK 	0xfffffffc 	/* bits 0-1 */
+    #define TD1_color_arg2_diffuse 	0x0 		/* val 0, shift 0 */
+    #define TD1_color_arg2_specular 	0x1 		/* val 1, shift 0 */
+    #define TD1_color_arg2_fcol 	0x2 		/* val 2, shift 0 */
+    #define TD1_color_arg2_prevstage 	0x3 		/* val 3, shift 0 */
+    #define TD1_color_alpha_MASK 	0xffffffe3 	/* bits 2-4 */
+    #define TD1_color_alpha_diffuse 	0x0 		/* val 0, shift 2 */
+    #define TD1_color_alpha_fcol 	0x4 		/* val 1, shift 2 */
+    #define TD1_color_alpha_tex0 	0x8 		/* val 2, shift 2 */
+    #define TD1_color_alpha_prevtex 	0xc 		/* val 3, shift 2 */
+    #define TD1_color_alpha_prevstage 	0x10 		/* val 4, shift 2 */
+    #define TD1_color_arg1_replicatealpha_MASK 0xffffffdf 	/* bit 5 */
+    #define TD1_color_arg1_replicatealpha_disable 0x0 		
+    #define TD1_color_arg1_replicatealpha_enable 0x20 		
+    #define TD1_color_arg1_inv_MASK 	0xffffffbf 	/* bit 6 */
+    #define TD1_color_arg1_inv_disable 	0x0 		
+    #define TD1_color_arg1_inv_enable 	0x40 		
+    #define TD1_color_arg2_replicatealpha_MASK 0xffffff7f 	/* bit 7 */
+    #define TD1_color_arg2_replicatealpha_disable 0x0 		
+    #define TD1_color_arg2_replicatealpha_enable 0x80 		
+    #define TD1_color_arg2_inv_MASK 	0xfffffeff 	/* bit 8 */
+    #define TD1_color_arg2_inv_disable 	0x0 		
+    #define TD1_color_arg2_inv_enable 	0x100 		
+    #define TD1_color_alpha1inv_MASK 	0xfffffdff 	/* bit 9 */
+    #define TD1_color_alpha1inv_disable 0x0 		
+    #define TD1_color_alpha1inv_enable 	0x200 		
+    #define TD1_color_alpha2inv_MASK 	0xfffffbff 	/* bit 10 */
+    #define TD1_color_alpha2inv_disable 0x0 		
+    #define TD1_color_alpha2inv_enable 	0x400 		
+    #define TD1_color_arg1mul_MASK 	0xfffff7ff 	/* bit 11 */
+    #define TD1_color_arg1mul_disable 	0x0 		/* val 0, shift 11 */
+    #define TD1_color_arg1mul_alpha1 	0x800 		/* val 1, shift 11 */
+    #define TD1_color_arg2mul_MASK 	0xffffefff 	/* bit 12 */
+    #define TD1_color_arg2mul_disable 	0x0 		/* val 0, shift 12 */
+    #define TD1_color_arg2mul_alpha2 	0x1000 		/* val 1, shift 12 */
+    #define TD1_color_arg1add_MASK 	0xffffdfff 	/* bit 13 */
+    #define TD1_color_arg1add_disable 	0x0 		/* val 0, shift 13 */
+    #define TD1_color_arg1add_mulout 	0x2000 		/* val 1, shift 13 */
+    #define TD1_color_arg2add_MASK 	0xffffbfff 	/* bit 14 */
+    #define TD1_color_arg2add_disable 	0x0 		/* val 0, shift 14 */
+    #define TD1_color_arg2add_mulout 	0x4000 		/* val 1, shift 14 */
+    #define TD1_color_modbright_MASK 	0xfffe7fff 	/* bits 15-16 */
+    #define TD1_color_modbright_disable 0x0 		/* val 0, shift 15 */
+    #define TD1_color_modbright_2x 	0x8000 		/* val 1, shift 15 */
+    #define TD1_color_modbright_4x 	0x10000 	/* val 2, shift 15 */
+    #define TD1_color_add_MASK 		0xfffdffff 	/* bit 17 */
+    #define TD1_color_add_sub 		0x0 		/* val 0, shift 17 */
+    #define TD1_color_add_add 		0x20000 	/* val 1, shift 17 */
+    #define TD1_color_add2x_MASK 	0xfffbffff 	/* bit 18 */
+    #define TD1_color_add2x_disable 	0x0 		
+    #define TD1_color_add2x_enable 	0x40000 	
+    #define TD1_color_addbias_MASK 	0xfff7ffff 	/* bit 19 */
+    #define TD1_color_addbias_disable 	0x0 		
+    #define TD1_color_addbias_enable 	0x80000 	
+    #define TD1_color_blend_MASK 	0xffefffff 	/* bit 20 */
+    #define TD1_color_blend_disable 	0x0 		
+    #define TD1_color_blend_enable 	0x100000 	
+    #define TD1_color_sel_MASK 		0xff9fffff 	/* bits 21-22 */
+    #define TD1_color_sel_arg1 		0x0 		/* val 0, shift 21 */
+    #define TD1_color_sel_arg2 		0x200000 	/* val 1, shift 21 */
+    #define TD1_color_sel_add 		0x400000 	/* val 2, shift 21 */
+    #define TD1_color_sel_mul 		0x600000 	/* val 3, shift 21 */
+    #define TD1_alpha_arg1_inv_MASK 	0xff7fffff 	/* bit 23 */
+    #define TD1_alpha_arg1_inv_disable 	0x0 		
+    #define TD1_alpha_arg1_inv_enable 	0x800000 	
+    #define TD1_alpha_arg2_MASK 	0xfcffffff 	/* bits 24-25 */
+    #define TD1_alpha_arg2_diffuse 	0x0 		/* val 0, shift 24 */
+    #define TD1_alpha_arg2_fcol 	0x1000000 	/* val 1, shift 24 */
+    #define TD1_alpha_arg2_prevtex 	0x2000000 	/* val 2, shift 24 */
+    #define TD1_alpha_arg2_prevstage 	0x3000000 	/* val 3, shift 24 */
+    #define TD1_alpha_arg2_inv_MASK 	0xfbffffff 	/* bit 26 */
+    #define TD1_alpha_arg2_inv_disable 	0x0 		
+    #define TD1_alpha_arg2_inv_enable 	0x4000000 	
+    #define TD1_alpha_add_MASK 		0xf7ffffff 	/* bit 27 */
+    #define TD1_alpha_add_disable 	0x0 		
+    #define TD1_alpha_add_enable 	0x8000000 	
+    #define TD1_alpha_addbias_MASK 	0xefffffff 	/* bit 28 */
+    #define TD1_alpha_addbias_disable 	0x0 		
+    #define TD1_alpha_addbias_enable 	0x10000000 	
+    #define TD1_alpha_add2x_MASK 	0xdfffffff 	/* bit 29 */
+    #define TD1_alpha_add2x_disable 	0x0 		
+    #define TD1_alpha_add2x_enable 	0x20000000 	
+    #define TD1_alpha_modbright_MASK 	0xcfffffff 	/* bits 28-29 */
+    #define TD1_alpha_modbright_disable 0x0 		/* val 0, shift 28 */
+    #define TD1_alpha_modbright_2x 	0x10000000 	/* val 1, shift 28 */
+    #define TD1_alpha_modbright_4x 	0x20000000 	/* val 2, shift 28 */
+    #define TD1_alpha_sel_MASK 		0x3fffffff 	/* bits 30-31 */
+    #define TD1_alpha_sel_arg1 		0x0 		/* val 0, shift 30 */
+    #define TD1_alpha_sel_arg2 		0x40000000 	/* val 1, shift 30 */
+    #define TD1_alpha_sel_add 		0x80000000 	/* val 2, shift 30 */
+    #define TD1_alpha_sel_mul 		0xc0000000 	/* val 3, shift 30 */
+
+#define MGAREG_TEST0 				0x1e48
+
+    #define TST_ramtsten_MASK 		0xfffffffe 	/* bit 0 */
+    #define TST_ramtsten_disable 	0x0 		
+    #define TST_ramtsten_enable 	0x1 		
+    #define TST_ramtstdone_MASK 	0xfffffffd 	/* bit 1 */
+    #define TST_ramtstdone_disable 	0x0 		
+    #define TST_ramtstdone_enable 	0x2 		
+    #define TST_wramtstpass_MASK 	0xfffffffb 	/* bit 2 */
+    #define TST_wramtstpass_disable 	0x0 		
+    #define TST_wramtstpass_enable 	0x4 		
+    #define TST_tcachetstpass_MASK 	0xfffffff7 	/* bit 3 */
+    #define TST_tcachetstpass_disable 	0x0 		
+    #define TST_tcachetstpass_enable 	0x8 		
+    #define TST_tluttstpass_MASK 	0xffffffef 	/* bit 4 */
+    #define TST_tluttstpass_disable 	0x0 		
+    #define TST_tluttstpass_enable 	0x10 		
+    #define TST_luttstpass_MASK 	0xffffffdf 	/* bit 5 */
+    #define TST_luttstpass_disable 	0x0 		
+    #define TST_luttstpass_enable 	0x20 		
+    #define TST_besramtstpass_MASK 	0xffffffbf 	/* bit 6 */
+    #define TST_besramtstpass_disable 	0x0 		
+    #define TST_besramtstpass_enable 	0x40 		
+    #define TST_ringen_MASK 		0xfffffeff 	/* bit 8 */
+    #define TST_ringen_disable 		0x0 		
+    #define TST_ringen_enable 		0x100 		
+    #define TST_apllbyp_MASK 		0xfffffdff 	/* bit 9 */
+    #define TST_apllbyp_disable 	0x0 		
+    #define TST_apllbyp_enable 		0x200 		
+    #define TST_hiten_MASK 		0xfffffbff 	/* bit 10 */
+    #define TST_hiten_disable 		0x0 		
+    #define TST_hiten_enable 		0x400 		
+    #define TST_tmode_MASK 		0xffffc7ff 	/* bits 11-13 */
+    #define TST_tmode_SHIFT 		11 		
+    #define TST_tclksel_MASK 		0xfffe3fff 	/* bits 14-16 */
+    #define TST_tclksel_SHIFT 		14 		
+    #define TST_ringcnten_MASK 		0xfffdffff 	/* bit 17 */
+    #define TST_ringcnten_disable 	0x0 		
+    #define TST_ringcnten_enable 	0x20000 	
+    #define TST_ringcnt_MASK 		0xc003ffff 	/* bits 18-29 */
+    #define TST_ringcnt_SHIFT 		18 		
+    #define TST_ringcntclksl_MASK 	0xbfffffff 	/* bit 30 */
+    #define TST_ringcntclksl_disable 	0x0 		
+    #define TST_ringcntclksl_enable 	0x40000000 	
+    #define TST_biosboot_MASK 		0x7fffffff 	/* bit 31 */
+    #define TST_biosboot_disable 	0x0 		
+    #define TST_biosboot_enable 	0x80000000 	
+
+#define MGAREG_TEXBORDERCOL 			0x2c5c
+#define MGAREG_TEXCTL 				0x2c30
+
+    #define TMC_tformat_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define TMC_tformat_tw4 		0x0 		/* val 0, shift 0 */
+    #define TMC_tformat_tw8 		0x1 		/* val 1, shift 0 */
+    #define TMC_tformat_tw15 		0x2 		/* val 2, shift 0 */
+    #define TMC_tformat_tw16 		0x3 		/* val 3, shift 0 */
+    #define TMC_tformat_tw12 		0x4 		/* val 4, shift 0 */
+    #define TMC_tformat_tw32 		0x6 		/* val 6, shift 0 */
+    #define TMC_tformat_tw422 		0xa 		/* val 10, shift 0 */
+    #define TMC_tpitchlin_MASK 		0xfffffeff 	/* bit 8 */
+    #define TMC_tpitchlin_disable 	0x0 		
+    #define TMC_tpitchlin_enable 	0x100 		
+    #define TMC_tpitchext_MASK 		0xfff001ff 	/* bits 9-19 */
+    #define TMC_tpitchext_SHIFT 	9 		
+    #define TMC_tpitch_MASK 		0xfff8ffff 	/* bits 16-18 */
+    #define TMC_tpitch_SHIFT 		16 		
+    #define TMC_owalpha_MASK 		0xffbfffff 	/* bit 22 */
+    #define TMC_owalpha_disable 	0x0 		
+    #define TMC_owalpha_enable 		0x400000 	
+    #define TMC_azeroextend_MASK 	0xff7fffff 	/* bit 23 */
+    #define TMC_azeroextend_disable 	0x0 		
+    #define TMC_azeroextend_enable 	0x800000 	
+    #define TMC_decalckey_MASK 		0xfeffffff 	/* bit 24 */
+    #define TMC_decalckey_disable 	0x0 		
+    #define TMC_decalckey_enable 	0x1000000 	
+    #define TMC_takey_MASK 		0xfdffffff 	/* bit 25 */
+    #define TMC_takey_0 		0x0 		
+    #define TMC_takey_1 		0x2000000 	
+    #define TMC_tamask_MASK 		0xfbffffff 	/* bit 26 */
+    #define TMC_tamask_0 		0x0 		
+    #define TMC_tamask_1 		0x4000000 	
+    #define TMC_clampv_MASK 		0xf7ffffff 	/* bit 27 */
+    #define TMC_clampv_disable 		0x0 		
+    #define TMC_clampv_enable 		0x8000000 	
+    #define TMC_clampu_MASK 		0xefffffff 	/* bit 28 */
+    #define TMC_clampu_disable 		0x0 		
+    #define TMC_clampu_enable 		0x10000000 	
+    #define TMC_tmodulate_MASK 		0xdfffffff 	/* bit 29 */
+    #define TMC_tmodulate_disable 	0x0 		
+    #define TMC_tmodulate_enable 	0x20000000 	
+    #define TMC_strans_MASK 		0xbfffffff 	/* bit 30 */
+    #define TMC_strans_disable 		0x0 		
+    #define TMC_strans_enable 		0x40000000 	
+    #define TMC_itrans_MASK 		0x7fffffff 	/* bit 31 */
+    #define TMC_itrans_disable 		0x0 		
+    #define TMC_itrans_enable 		0x80000000 	
+
+#define MGAREG_TEXCTL2 			0x2c3c
+
+    #define TMC_decalblend_MASK 	0xfffffffe 	/* bit 0 */
+    #define TMC_decalblend_disable 	0x0 		
+    #define TMC_decalblend_enable 	0x1 		
+    #define TMC_idecal_MASK 		0xfffffffd 	/* bit 1 */
+    #define TMC_idecal_disable 		0x0 		
+    #define TMC_idecal_enable 		0x2 		
+    #define TMC_decaldis_MASK 		0xfffffffb 	/* bit 2 */
+    #define TMC_decaldis_disable 	0x0 		
+    #define TMC_decaldis_enable 	0x4 		
+    #define TMC_ckstransdis_MASK 	0xffffffef 	/* bit 4 */
+    #define TMC_ckstransdis_disable 	0x0 		
+    #define TMC_ckstransdis_enable 	0x10 		
+    #define TMC_borderen_MASK 		0xffffffdf 	/* bit 5 */
+    #define TMC_borderen_disable 	0x0 		
+    #define TMC_borderen_enable 	0x20 		
+    #define TMC_specen_MASK 		0xffffffbf 	/* bit 6 */
+    #define TMC_specen_disable 		0x0 		
+    #define TMC_specen_enable 		0x40 		
+    #define TMC_dualtex_MASK 		0xffffff7f 	/* bit 7 */
+    #define TMC_dualtex_disable 	0x0 		
+    #define TMC_dualtex_enable 		0x80 		
+    #define TMC_tablefog_MASK 		0xfffffeff 	/* bit 8 */
+    #define TMC_tablefog_disable 	0x0 		
+    #define TMC_tablefog_enable 	0x100 		
+    #define TMC_bumpmap_MASK 		0xfffffdff 	/* bit 9 */
+    #define TMC_bumpmap_disable 	0x0 		
+    #define TMC_bumpmap_enable 		0x200 		
+    #define TMC_map1_MASK 		0x7fffffff 	/* bit 31 */
+    #define TMC_map1_disable 		0x0 		
+    #define TMC_map1_enable 		0x80000000 	
+
+#define MGAREG_TEXFILTER 			0x2c58
+
+    #define TF_minfilter_MASK 		0xfffffff0 	/* bits 0-3 */
+    #define TF_minfilter_nrst 		0x0 		/* val 0, shift 0 */
+    #define TF_minfilter_bilin 		0x2 		/* val 2, shift 0 */
+    #define TF_minfilter_cnst 		0x3 		/* val 3, shift 0 */
+    #define TF_minfilter_mm1s 		0x8 		/* val 8, shift 0 */
+    #define TF_minfilter_mm2s 		0x9 		/* val 9, shift 0 */
+    #define TF_minfilter_mm4s 		0xa 		/* val 10, shift 0 */
+    #define TF_minfilter_mm8s 		0xc 		/* val 12, shift 0 */
+    #define TF_magfilter_MASK 		0xffffff0f 	/* bits 4-7 */
+    #define TF_magfilter_nrst 		0x0 		/* val 0, shift 4 */
+    #define TF_magfilter_bilin 		0x20 		/* val 2, shift 4 */
+    #define TF_magfilter_cnst 		0x30 		/* val 3, shift 4 */
+    #define TF_avgstride_MASK 		0xfff7ffff 	/* bit 19 */
+    #define TF_avgstride_disable 	0x0 		
+    #define TF_avgstride_enable 	0x80000 	
+    #define TF_filteralpha_MASK 	0xffefffff 	/* bit 20 */
+    #define TF_filteralpha_disable 	0x0 		
+    #define TF_filteralpha_enable 	0x100000 	
+    #define TF_fthres_MASK 		0xe01fffff 	/* bits 21-28 */
+    #define TF_fthres_SHIFT 		21 		
+    #define TF_mapnb_MASK 		0x1fffffff 	/* bits 29-31 */
+    #define TF_mapnb_SHIFT 		29 		
+
+#define MGAREG_TEXHEIGHT 			0x2c2c
+
+    #define TH_th_MASK 			0xffffffc0 	/* bits 0-5 */
+    #define TH_th_SHIFT 		0 		
+    #define TH_rfh_MASK 		0xffff81ff 	/* bits 9-14 */
+    #define TH_rfh_SHIFT 		9 		
+    #define TH_thmask_MASK 		0xe003ffff 	/* bits 18-28 */
+    #define TH_thmask_SHIFT 		18 		
+
+#define MGAREG_TEXORG 				0x2c24
+
+    #define TO_texorgmap_MASK 		0xfffffffe 	/* bit 0 */
+    #define TO_texorgmap_fb 		0x0 		
+    #define TO_texorgmap_sys 		0x1 		
+    #define TO_texorgacc_MASK 		0xfffffffd 	/* bit 1 */
+    #define TO_texorgacc_pci 		0x0 		
+    #define TO_texorgacc_agp 		0x2 		
+    #define TO_texorg_MASK 		0x1f 		/* bits 5-31 */
+    #define TO_texorg_SHIFT 		5 		
+
+#define MGAREG_TEXORG1 			0x2ca4
+#define MGAREG_TEXORG2 			0x2ca8
+#define MGAREG_TEXORG3 			0x2cac
+#define MGAREG_TEXORG4 			0x2cb0
+#define MGAREG_TEXTRANS 			0x2c34
+
+    #define TT_tckey_MASK 		0xffff0000 	/* bits 0-15 */
+    #define TT_tckey_SHIFT 		0 		
+    #define TT_tkmask_MASK 		0xffff 		/* bits 16-31 */
+    #define TT_tkmask_SHIFT 		16 		
+
+#define MGAREG_TEXTRANSHIGH 			0x2c38
+
+    #define TT_tckeyh_MASK 		0xffff0000 	/* bits 0-15 */
+    #define TT_tckeyh_SHIFT 		0 		
+    #define TT_tkmaskh_MASK 		0xffff 		/* bits 16-31 */
+    #define TT_tkmaskh_SHIFT 		16 		
+
+#define MGAREG_TEXWIDTH 			0x2c28
+
+    #define TW_tw_MASK 			0xffffffc0 	/* bits 0-5 */
+    #define TW_tw_SHIFT 		0 		
+    #define TW_rfw_MASK 		0xffff81ff 	/* bits 9-14 */
+    #define TW_rfw_SHIFT 		9 		
+    #define TW_twmask_MASK 		0xe003ffff 	/* bits 18-28 */
+    #define TW_twmask_SHIFT 		18 		
+
+#define MGAREG_TMR0 				0x2c00
+#define MGAREG_TMR1 				0x2c04
+#define MGAREG_TMR2 				0x2c08
+#define MGAREG_TMR3 				0x2c0c
+#define MGAREG_TMR4 				0x2c10
+#define MGAREG_TMR5 				0x2c14
+#define MGAREG_TMR6 				0x2c18
+#define MGAREG_TMR7 				0x2c1c
+#define MGAREG_TMR8 				0x2c20
+#define MGAREG_VBIADDR0 			0x3e08
+#define MGAREG_VBIADDR1 			0x3e0c
+#define MGAREG_VCOUNT 				0x1e20
+#define MGAREG_WACCEPTSEQ 			0x1dd4
+
+    #define WAS_seqdst0_MASK 		0xffffffc0 	/* bits 0-5 */
+    #define WAS_seqdst0_SHIFT 		0 		
+    #define WAS_seqdst1_MASK 		0xfffff03f 	/* bits 6-11 */
+    #define WAS_seqdst1_SHIFT 		6 		
+    #define WAS_seqdst2_MASK 		0xfffc0fff 	/* bits 12-17 */
+    #define WAS_seqdst2_SHIFT 		12 		
+    #define WAS_seqdst3_MASK 		0xff03ffff 	/* bits 18-23 */
+    #define WAS_seqdst3_SHIFT 		18 		
+    #define WAS_seqlen_MASK 		0xfcffffff 	/* bits 24-25 */
+    #define WAS_wfirsttag_MASK 		0xfbffffff 	/* bit 26 */
+    #define WAS_wfirsttag_disable 	0x0 		
+    #define WAS_wfirsttag_enable 	0x4000000 	
+    #define WAS_wsametag_MASK 		0xf7ffffff 	/* bit 27 */
+    #define WAS_wsametag_disable 	0x0 		
+    #define WAS_wsametag_enable 	0x8000000 	
+    #define WAS_seqoff_MASK 		0xefffffff 	/* bit 28 */
+    #define WAS_seqoff_disable 		0x0 		
+    #define WAS_seqoff_enable 		0x10000000 	
+
+#define MGAREG_WCODEADDR 			0x1e6c
+
+    #define WMA_wcodeaddr_MASK 		0xff 		/* bits 8-31 */
+    #define WMA_wcodeaddr_SHIFT 	8 		
+
+#define MGAREG_WFLAG 				0x1dc4
+
+    #define WF_walustsflag_MASK 	0xffffff00 	/* bits 0-7 */
+    #define WF_walustsflag_SHIFT 	0 		
+    #define WF_walucfgflag_MASK 	0xffff00ff 	/* bits 8-15 */
+    #define WF_walucfgflag_SHIFT 	8 		
+    #define WF_wprgflag_MASK 		0xffff 		/* bits 16-31 */
+    #define WF_wprgflag_SHIFT 		16 		
+
+#define MGAREG_WFLAG1 				0x1de0
+
+    #define WF1_walustsflag1_MASK 	0xffffff00 	/* bits 0-7 */
+    #define WF1_walustsflag1_SHIFT 	0 		
+    #define WF1_walucfgflag1_MASK 	0xffff00ff 	/* bits 8-15 */
+    #define WF1_walucfgflag1_SHIFT 	8 		
+    #define WF1_wprgflag1_MASK 		0xffff 		/* bits 16-31 */
+    #define WF1_wprgflag1_SHIFT 	16 		
+
+#define MGAREG_WFLAGNB 			0x1e64
+#define MGAREG_WFLAGNB1 			0x1e08
+#define MGAREG_WGETMSB 			0x1dc8
+
+    #define WGV_wgetmsbmin_MASK 	0xffffffe0 	/* bits 0-4 */
+    #define WGV_wgetmsbmin_SHIFT 	0 		
+    #define WGV_wgetmsbmax_MASK 	0xffffe0ff 	/* bits 8-12 */
+    #define WGV_wgetmsbmax_SHIFT 	8 		
+    #define WGV_wbrklefttop_MASK 	0xfffeffff 	/* bit 16 */
+    #define WGV_wbrklefttop_disable 	0x0 		
+    #define WGV_wbrklefttop_enable 	0x10000 	
+    #define WGV_wfastcrop_MASK 		0xfffdffff 	/* bit 17 */
+    #define WGV_wfastcrop_disable 	0x0 		
+    #define WGV_wfastcrop_enable 	0x20000 	
+    #define WGV_wcentersnap_MASK 	0xfffbffff 	/* bit 18 */
+    #define WGV_wcentersnap_disable 	0x0 		
+    #define WGV_wcentersnap_enable 	0x40000 	
+    #define WGV_wbrkrighttop_MASK 	0xfff7ffff 	/* bit 19 */
+    #define WGV_wbrkrighttop_disable 	0x0 		
+    #define WGV_wbrkrighttop_enable 	0x80000 	
+
+#define MGAREG_WIADDR 				0x1dc0
+
+    #define WIA_wmode_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define WIA_wmode_suspend 		0x0 		/* val 0, shift 0 */
+    #define WIA_wmode_resume 		0x1 		/* val 1, shift 0 */
+    #define WIA_wmode_jump 		0x2 		/* val 2, shift 0 */
+    #define WIA_wmode_start 		0x3 		/* val 3, shift 0 */
+    #define WIA_wagp_MASK 		0xfffffffb 	/* bit 2 */
+    #define WIA_wagp_pci 		0x0 		
+    #define WIA_wagp_agp 		0x4 		
+    #define WIA_wiaddr_MASK 		0x7 		/* bits 3-31 */
+    #define WIA_wiaddr_SHIFT 		3 		
+
+#define MGAREG_WIADDR2 			0x1dd8
+
+    #define WIA2_wmode_MASK 		0xfffffffc 	/* bits 0-1 */
+    #define WIA2_wmode_suspend 		0x0 		/* val 0, shift 0 */
+    #define WIA2_wmode_resume 		0x1 		/* val 1, shift 0 */
+    #define WIA2_wmode_jump 		0x2 		/* val 2, shift 0 */
+    #define WIA2_wmode_start 		0x3 		/* val 3, shift 0 */
+    #define WIA2_wagp_MASK 		0xfffffffb 	/* bit 2 */
+    #define WIA2_wagp_pci 		0x0 		
+    #define WIA2_wagp_agp 		0x4 		
+    #define WIA2_wiaddr_MASK 		0x7 		/* bits 3-31 */
+    #define WIA2_wiaddr_SHIFT 		3 		
+
+#define MGAREG_WIADDRNB 			0x1e60
+#define MGAREG_WIADDRNB1 			0x1e04
+#define MGAREG_WIADDRNB2 			0x1e00
+#define MGAREG_WIMEMADDR 			0x1e68
+
+    #define WIMA_wimemaddr_MASK 	0xffffff00 	/* bits 0-7 */
+    #define WIMA_wimemaddr_SHIFT 	0 		
+
+#define MGAREG_WIMEMDATA 			0x2000
+#define MGAREG_WIMEMDATA1 			0x2100
+#define MGAREG_WMISC 				0x1e70
+
+    #define WM_wucodecache_MASK 	0xfffffffe 	/* bit 0 */
+    #define WM_wucodecache_disable 	0x0 		
+    #define WM_wucodecache_enable 	0x1 		
+    #define WM_wmaster_MASK 		0xfffffffd 	/* bit 1 */
+    #define WM_wmaster_disable 		0x0 		
+    #define WM_wmaster_enable 		0x2 		
+    #define WM_wcacheflush_MASK 	0xfffffff7 	/* bit 3 */
+    #define WM_wcacheflush_disable 	0x0 		
+    #define WM_wcacheflush_enable 	0x8 		
+
+#define MGAREG_WR 				0x2d00
+#define MGAREG_WVRTXSZ 			0x1dcc
+
+    #define WVS_wvrtxsz_MASK 		0xffffffc0 	/* bits 0-5 */
+    #define WVS_wvrtxsz_SHIFT 		0 		
+    #define WVS_primsz_MASK 		0xffffc0ff 	/* bits 8-13 */
+    #define WVS_primsz_SHIFT 		8 		
+
+#define MGAREG_XDST 				0x1cb0
+#define MGAREG_XYEND 				0x1c44
+
+    #define XYEA_x_end_MASK 		0xffff0000 	/* bits 0-15 */
+    #define XYEA_x_end_SHIFT 		0 		
+    #define XYEA_y_end_MASK 		0xffff 		/* bits 16-31 */
+    #define XYEA_y_end_SHIFT 		16 		
+
+#define MGAREG_XYSTRT 				0x1c40
+
+    #define XYSA_x_start_MASK 		0xffff0000 	/* bits 0-15 */
+    #define XYSA_x_start_SHIFT 		0 		
+    #define XYSA_y_start_MASK 		0xffff 		/* bits 16-31 */
+    #define XYSA_y_start_SHIFT 		16 		
+
+#define MGAREG_YBOT 				0x1c9c
+#define MGAREG_YDST 				0x1c90
+
+    #define YA_ydst_MASK 		0xff800000 	/* bits 0-22 */
+    #define YA_ydst_SHIFT 		0 		
+    #define YA_sellin_MASK 		0x1fffffff 	/* bits 29-31 */
+    #define YA_sellin_SHIFT 		29 		
+
+#define MGAREG_YDSTLEN 			0x1c88
+
+    #define YDL_length_MASK 		0xffff0000 	/* bits 0-15 */
+    #define YDL_length_SHIFT 		0 		
+    #define YDL_yval_MASK 		0xffff 		/* bits 16-31 */
+    #define YDL_yval_SHIFT 		16 		
+
+#define MGAREG_YDSTORG 			0x1c94
+#define MGAREG_YTOP 				0x1c98
+#define MGAREG_ZORG 				0x1c0c
+
+    #define ZO_zorgmap_MASK 		0xfffffffe 	/* bit 0 */
+    #define ZO_zorgmap_fb 		0x0 		
+    #define ZO_zorgmap_sys 		0x1 		
+    #define ZO_zorgacc_MASK 		0xfffffffd 	/* bit 1 */
+    #define ZO_zorgacc_pci 		0x0 		
+    #define ZO_zorgacc_agp 		0x2 		
+    #define ZO_zorg_MASK 		0x3 		/* bits 2-31 */
+    #define ZO_zorg_SHIFT 		2 		
+
+
+
+
+/**************** (END) AUTOMATICLY GENERATED REGISTER FILE ******************/
+
+#endif 	/* _MGAREGS_H_ */
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgarender.c b/xc/lib/GL/mesa/src/drv/mga/mgarender.c
new file mode 100644
index 000000000..6f406db2d
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgarender.c
@@ -0,0 +1,334 @@
+#include <stdio.h>
+#include "mgadd.h"
+#include "mgavb.h"
+#include "mgadma.h"
+#include "mgalib.h"
+#include "mgatris.h"
+#include "mgastate.h"
+#include "xsmesaP.h"
+#include "enums.h"
+
+#define POINT(x) mga_draw_point(&gWin[x], psize)
+#define LINE(x,y) mga_draw_line(&gWin[x], &gWin[y], lwidth)
+#define TRI(x,y,z) mga_draw_triangle(&gWin[x], &gWin[y], &gWin[z])
+
+
+/* Direct, and no clipping required.  I haven't written the clip funcs
+ * yet, so this is only useful for the fast path, which does its own
+ * clipping.
+ */
+#define RENDER_POINTS( start, count )		\
+do {						\
+   GLuint e;					\
+   for(e=start;e<=count;e++)			\
+     POINT(elt[e]);				\
+} while (0)
+
+#define RENDER_LINE( i1, i )			\
+do {						\
+   GLuint e1 = elt[i1], e = elt[i];		\
+   LINE( e1, e );				\
+} while (0)
+
+
+#define RENDER_TRI( i2, i1, i, pv, parity)		\
+do {							\
+{  GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  if (parity) {GLuint tmp = e2; e2 = e1; e1 = tmp;}	\
+  TRI(e2, e1, e);					\
+}} while (0)
+
+
+#define RENDER_QUAD( i3, i2, i1, i, pv)				\
+do {								\
+  GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  TRI(e3, e2, e);						\
+  TRI(e2, e1, e);						\
+} while (0)
+
+#define LOCAL_VARS					\
+   mgaVertexPtr gWin = MGA_DRIVER_DATA(VB)->verts;	\
+   const GLuint *elt = VB->EltPtr->data;		\
+   const GLfloat lwidth = VB->ctx->Line.Width;		\
+   const GLfloat psize = VB->ctx->Point.Size;		\
+   GLcontext *ctx = VB->ctx; \
+   (void) lwidth; (void)psize; (void)ctx; (void) gWin;
+
+
+#define TAG(x) x##_mga_smooth_indirect
+#include "render_tmp.h"
+
+
+
+
+#define RENDER_POINTS( start, count )		\
+do {						\
+   GLuint e;					\
+   for(e=start;e<=count;e++)			\
+     POINT(e);					\
+} while (0)
+
+#define RENDER_LINE( i1, i )			\
+do {						\
+   LINE( i1, i );				\
+} while (0)
+
+
+#define RENDER_TRI( i2, i1, i, pv, parity)		\
+do {							\
+  GLuint e2 = i2, e1 = i1;				\
+  if (parity) {GLuint tmp = e2; e2 = e1; e1 = tmp;}	\
+  TRI(e2, e1, i);					\
+} while (0)
+
+
+#define RENDER_QUAD( i3, i2, i1, i, pv)		\
+do {						\
+  TRI(i3, i2, i);				\
+  TRI(i2, i1, i);				\
+} while (0)
+
+#define LOCAL_VARS					\
+   mgaVertexPtr gWin = MGA_DRIVER_DATA(VB)->verts;	\
+   const GLfloat lwidth = VB->ctx->Line.Width;		\
+   const GLfloat psize = VB->ctx->Point.Size;		\
+   GLcontext *ctx = VB->ctx; \
+   (void) lwidth; (void)psize; (void)ctx; (void) gWin;
+
+#define TAG(x) x##_mga_smooth_direct
+#include "render_tmp.h"
+
+
+
+
+
+/* Vertex array rendering via. the SetupDma function - no clipping required. 
+ */
+#define RENDER_POINTS( start, count )		\
+do {						\
+    FatalError("Dead code in mgarender.c\n");	\
+} while (0)
+
+#define RENDER_LINE( i1, i )			\
+do {						\
+    FatalError("Dead code in mgarender.c\n");	\
+} while (0)
+
+
+#define RENDER_TRI( i2, i1, i, pv, parity)		\
+do {							\
+   GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+   if (/*parity*/0) {GLuint tmp = e2; e2 = e1; e1 = tmp;}	\
+   TRI(e2, e1, e);		\
+} while (0)
+
+#define RENDER_QUAD( i3, i2, i1, i, pv)				\
+do {								\
+  GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i];	\
+  TRI(e3, e2, e);			\
+  TRI(e2, e1, e);			\
+} while (0)
+
+#define LOCAL_VARS					\
+   mgaVertexBufferPtr mgaVB = MGA_DRIVER_DATA(VB);	\
+   mgaUI32 phys = mgaVB->vert_phys_start;		\
+   const GLuint *elt = VB->EltPtr->data;		\
+   (void) phys; (void) elt;
+
+#define PRESERVE_VB_DEFS
+#undef TRI
+#define VERT_ADDR_10( phys, elt ) ( phys + elt * 48 )
+#define TRI( ee0, ee1, ee2 )				\
+{							\
+   mgaVB->elt_buf[0] = VERT_ADDR_10(phys, ee0);		\
+   mgaVB->elt_buf[1] = VERT_ADDR_10(phys, ee1);		\
+   mgaVB->elt_buf[2] = VERT_ADDR_10(phys, ee2);		\
+   mgaVB->elt_buf += 3;					\
+}
+#define TAG(x) x##_mga_elt_10
+#include "render_tmp.h"
+
+
+#define TAG(x) x##_mga_elt_8
+#undef TRI
+#define VERT_ADDR_8( phys, elt ) ( phys + elt * 32 )
+#define TRI( ee0, ee1, ee2 )			\
+{						\
+   mgaVB->elt_buf[0] = VERT_ADDR_8(phys, ee0);	\
+   mgaVB->elt_buf[1] = VERT_ADDR_8(phys, ee1);	\
+   mgaVB->elt_buf[2] = VERT_ADDR_8(phys, ee2);	\
+   mgaVB->elt_buf += 3;				\
+}
+#include "render_tmp.h"
+
+
+
+
+/* Currently only used on the fast path - need a set of render funcs
+ * for clipped primitives.
+ */
+void mgaDDRenderElementsDirect( struct vertex_buffer *VB )
+{
+   mgaVertexBufferPtr mgaVB = MGA_DRIVER_DATA(VB);
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLenum prim = ctx->CVA.elt_mode;
+   GLuint nr = VB->EltPtr->count;
+   render_func func = render_tab_mga_smooth_indirect[prim];
+   GLuint p = 0;
+   mgaUI32 *start = mgaVB->elt_buf;
+   
+   struct vertex_buffer *saved_vb = ctx->VB;
+
+   if (mmesa->new_state)
+      mgaDDUpdateHwState( ctx );
+
+   /* Are we using Setup DMA?
+    */
+   if (start) {
+      switch (MGA_CONTEXT(ctx)->vertsize) {
+      case 10:
+	 func = render_tab_mga_elt_10[prim];
+	 break;
+      case 8:
+	 func = render_tab_mga_elt_8[prim];
+	 break;
+      default:
+      }
+   }
+
+   ctx->VB = VB;
+
+   do {
+      func( VB, 0, nr, 0 );
+   } while (ctx->Driver.MultipassFunc &&
+	    ctx->Driver.MultipassFunc( VB, ++p ));
+
+   ctx->VB = saved_vb;
+
+
+   if (start && nr) {
+      if (0)
+	 fprintf(stderr, "%d/%d elts\n", nr, mgaVB->elt_buf-start);
+      mgaSetupDma( start, mgaVB->elt_buf - start );
+      mgaVB->elt_buf = mgaVB->vert_buf = 0;
+   }
+}
+
+
+void mgaDDRenderElementsImmediate( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint nr = VB->EltPtr->count;
+   render_func *tab = render_tab_mga_smooth_indirect;
+   GLuint parity = VB->Parity;
+   GLuint p = 0;
+   GLuint i, next;
+
+   if (mmesa->new_state)
+      mgaDDUpdateHwState( ctx );
+
+   do {
+      for ( i= VB->CopyStart ; i < nr ; parity = 0, i = next ) 
+      {
+	 GLenum prim = VB->Primitive[i];
+	 next = VB->NextPrimitive[i];
+	 tab[prim]( VB, i, next, parity );
+      }
+   } while (ctx->Driver.MultipassFunc &&
+	    ctx->Driver.MultipassFunc( VB, ++p ));
+}
+
+
+void mgaDDRenderDirect( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint nr = VB->Count;
+   render_func *tab = render_tab_mga_smooth_direct;
+   GLuint parity = VB->Parity;
+   GLuint p = 0;
+   GLuint i, next;
+
+   if (mmesa->new_state)
+      mgaDDUpdateHwState( ctx );
+
+   do {
+      for ( i= VB->CopyStart ; i < nr ; parity = 0, i = next ) 
+      {
+	 GLenum prim = VB->Primitive[i];
+	 next = VB->NextPrimitive[i];
+	 tab[prim]( VB, i, next, parity );
+      }
+   } while (ctx->Driver.MultipassFunc &&
+	    ctx->Driver.MultipassFunc( VB, ++p ));
+}
+
+
+static void optimized_render_vb_triangle_mga_smooth_indirect(struct vertex_buffer *VB,
+							    GLuint start,
+							    GLuint count,
+							    GLuint parity)
+{
+   mgaVertexPtr gWin = MGA_DRIVER_DATA(VB)->verts;
+   const GLuint *elt = VB->EltPtr->data;
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+
+   mgaUI32 vertsize = mmesa->vertsize;
+
+   /* We know how many dwords we need so we can allocate all of it
+    * in one call */
+   mgaUI32 *wv = mgaAllocSecondaryBuffer( count * vertsize );
+
+   int vertex;
+
+   (void)ctx; (void) gWin; (void) parity;
+
+
+   for(vertex=start+2;vertex<count;vertex+=3){
+      GLuint e2=elt[vertex-2],e1=elt[vertex-1],e=elt[vertex];
+      mgaUI32 *src;
+
+      int j;
+
+      if(parity){
+         GLuint tmp=e2;
+         e2=e1;
+	 e1=tmp;
+      }
+
+      src=&gWin[e2].ui[0];
+      
+      for(j=vertsize;j;j--){
+	 *wv++=*src++;
+      }
+      
+      src=&gWin[e1].ui[0];
+      for(j=vertsize;j;j--){
+	 *wv++=*src++;
+      }
+      
+      src=&gWin[e].ui[0];
+      for(j=vertsize;j;j--){
+	 *wv++=*src++;
+      }
+   }
+   
+}
+
+
+void mgaDDRenderInit()
+{
+
+   render_init_mga_smooth_indirect();
+   render_init_mga_smooth_direct();
+   render_init_mga_elt_10();
+   render_init_mga_elt_8();
+   
+   render_tab_mga_smooth_indirect[GL_TRIANGLES] =
+      optimized_render_vb_triangle_mga_smooth_indirect; 
+}
+
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgarender.h b/xc/lib/GL/mesa/src/drv/mga/mgarender.h
new file mode 100644
index 000000000..c772ac459
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgarender.h
@@ -0,0 +1,10 @@
+
+#ifndef _MGA_RENDER_H
+#define _MGA_RENDER_H
+
+extern void mgaDDRenderElementsDirect( struct vertex_buffer *VB );
+extern void mgaDDRenderElementsImmediate( struct vertex_buffer *VB );
+extern void mgaDDRenderDirect( struct vertex_buffer *VB );
+extern void mgaDDRenderInit();
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaspan.c b/xc/lib/GL/mesa/src/drv/mga/mgaspan.c
new file mode 100644
index 000000000..38e3cdde8
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaspan.c
@@ -0,0 +1,153 @@
+#include "types.h"
+#include "mgadd.h"
+#include "mgalib.h"
+#include "mgadma.h"
+#include "mgalog.h"
+#include "mgaspan.h"
+
+
+#define LOCAL_VARS					\
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );		\
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;	\
+   __DRIscreenPrivate *sPriv = mmesa->driScreen;	\
+   mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;	\
+   GLuint pitch = mgaScreen->backPitch;			\
+   GLuint height = dPriv->h;				\
+   char *buf = (char *)(sPriv->pFB +			\
+			mmesa->drawOffset +		\
+			dPriv->x * 2 +			\
+			dPriv->y * pitch)
+
+#define INIT_MONO_PIXEL(p) \
+   GLushort p = MGA_CONTEXT( ctx )->MonoColor;
+
+#define CLIPPIXEL(_x,_y) (_x >= minx && _x <= maxx && \
+			  _y >= miny && _y <= maxy)
+
+
+#define CLIPSPAN(_x,_y,_n,_x1,_n1)				\
+	 if (_y < miny || _y >= maxy) _n1 = 0, _x1 = x;		\
+         else {							\
+            _n1 = _n;						\
+	    _x1 = _x;						\
+	    if (_x1 < minx) _n1 -= (minx - _x1), _x1 = minx;	\
+	    if (_x1 + _n1 > maxx) n1 -= (_x1 + n1 - maxx);	\
+         }
+
+
+
+
+
+#define HW_CLIPLOOP()						\
+  do {								\
+    int _nc = mmesa->numClipRects;				\
+    LOCK_HARDWARE_QUIESCENT(mmesa);				\
+    while (_nc--) {						\
+       int minx = mmesa->pClipRects[_nc].x1 - mmesa->drawX;		\
+       int miny = mmesa->pClipRects[_nc].y1 - mmesa->drawY; 	\
+       int maxx = mmesa->pClipRects[_nc].x2 - mmesa->drawX;		\
+       int maxy = mmesa->pClipRects[_nc].y2 - mmesa->drawY;
+
+
+#define HW_ENDCLIPLOOP()			\
+    }						\
+    UNLOCK_HARDWARE(mmesa);			\
+  } while (0)
+
+
+#define Y_FLIP(_y) (height - _y)
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = ( ((r & 0x1f) << 11) |	\
+		                             ((g & 0x3f) << 5) |	\
+		                             ((b & 0x1f)))
+#define WRITE_PIXEL( _x, _y, p )  \
+   *(GLushort *)(buf + _x*2 + _y*pitch) = p
+
+#define READ_RGBA( rgba, _x, _y )			\
+do {							\
+   GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch);	\
+   rgba[0] = (p >> 11) & 0x1f;				\
+   rgba[1] = (p >> 5) & 0x3f;				\
+   rgba[2] = (p >> 0) & 0x1f;				\
+   rgba[3] = 0;			/* or 255? */		\
+} while(0)
+
+#define TAG(x) mga##x##_565
+#include "spantmp.h"
+
+
+
+
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = ( ((r & 0x1f) << 10) |	\
+		                            ((g & 0x1f) << 5) |		\
+                         		    ((b & 0x1f)))
+
+#define WRITE_PIXEL( _x, _y, p )  \
+   *(GLushort *)(buf + _x*2 + _y*pitch)  = p
+
+#define READ_RGBA( rgba, _x, _y )			\
+do {							\
+   GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch);	\
+   rgba[0] = (p >> 10) & 0x1f;				\
+   rgba[1] = (p >> 5) & 0x1f;				\
+   rgba[2] = (p >> 0) & 0x1f;				\
+   rgba[3] = 0;			/* or 255? */		\
+} while(0)
+
+#define TAG(x) mga##x##_555
+#include "spantmp.h"
+
+
+
+#if 0
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   *(GLuint *)(buf + _x*4 + _y*pitch)  = ( ((r) << 16) |	\
+		                           ((g) << 8) |		\
+                         		   ((b)))
+
+#define WRITE_PIXEL( _x, _y, p )  \
+   *(GLuint *)(buf + _x*4 + _y*pitch)  = p
+
+#define READ_RGBA( rgba, _x, _y )			\
+do {							\
+   GLuint p = *(GLuint *)(buf + _x*4 + _y*pitch);	\
+   rgba[0] = (p >> 16) & 0xff;				\
+   rgba[1] = (p >> 8) & 0xff;				\
+   rgba[2] = (p >> 0) & 0xff;				\
+   rgba[3] = 0;			/* or 255? */		\
+} while(0)
+
+#define TAG(x) mga##x##_888
+#include "spantmp.h"
+#endif
+
+void mgaDDInitSpanFuncs( GLcontext *ctx )
+{
+   if (1) {
+      ctx->Driver.WriteRGBASpan = mgaWriteRGBASpan_565;
+      ctx->Driver.WriteRGBSpan = mgaWriteRGBSpan_565;
+      ctx->Driver.WriteMonoRGBASpan = mgaWriteMonoRGBASpan_565;
+      ctx->Driver.WriteRGBAPixels = mgaWriteRGBAPixels_565;
+      ctx->Driver.WriteMonoRGBAPixels = mgaWriteMonoRGBAPixels_565;
+      ctx->Driver.ReadRGBASpan = mgaReadRGBASpan_565;
+      ctx->Driver.ReadRGBAPixels = mgaReadRGBAPixels_565;
+   } else {
+      ctx->Driver.WriteRGBASpan = mgaWriteRGBASpan_555;
+      ctx->Driver.WriteRGBSpan = mgaWriteRGBSpan_555;
+      ctx->Driver.WriteMonoRGBASpan = mgaWriteMonoRGBASpan_555;
+      ctx->Driver.WriteRGBAPixels = mgaWriteRGBAPixels_555;
+      ctx->Driver.WriteMonoRGBAPixels = mgaWriteMonoRGBAPixels_555;
+      ctx->Driver.ReadRGBASpan = mgaReadRGBASpan_555;
+      ctx->Driver.ReadRGBAPixels = mgaReadRGBAPixels_555;
+   }
+
+   ctx->Driver.WriteCI8Span        =NULL;
+   ctx->Driver.WriteCI32Span       =NULL;
+   ctx->Driver.WriteMonoCISpan     =NULL;
+   ctx->Driver.WriteCI32Pixels     =NULL;
+   ctx->Driver.WriteMonoCIPixels   =NULL;
+   ctx->Driver.ReadCI32Span        =NULL;
+   ctx->Driver.ReadCI32Pixels      =NULL;
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaspan.h b/xc/lib/GL/mesa/src/drv/mga/mgaspan.h
new file mode 100644
index 000000000..5db0fb976
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgaspan.h
@@ -0,0 +1,6 @@
+#ifndef _MGA_SPAN_H
+#define _MGA_SPAN_H
+
+extern void mgaDDInitSpanFuncs( GLcontext *ctx );
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgastate.c b/xc/lib/GL/mesa/src/drv/mga/mgastate.c
new file mode 100644
index 000000000..ff9063e0b
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgastate.c
@@ -0,0 +1,723 @@
+
+#include <stdio.h>
+
+
+#include "types.h"
+#include "pb.h"
+#include "dd.h"
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgadd.h"
+#include "mgastate.h"
+#include "mgadepth.h"
+#include "mgatex.h"
+#include "mgalog.h"
+#include "mgavb.h"
+#include "mgatris.h"
+#include "mgaregs.h"
+#include "mga_drm_public.h"
+
+static void mgaUpdateZMode(const GLcontext *ctx)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int zmode = 0;
+
+   if (ctx->Depth.Test) {
+      switch(ctx->Depth.Func)  { 
+      case GL_NEVER:
+	 zmode = DC_zmode_nozcmp; break;
+      case GL_ALWAYS:  
+	 zmode = DC_zmode_nozcmp; break;
+      case GL_LESS:
+	 zmode = DC_zmode_zlt; break; 
+      case GL_LEQUAL:
+	 zmode = DC_zmode_zlte; break;
+      case GL_EQUAL:
+	 zmode = DC_zmode_ze; break;
+      case GL_GREATER:
+	 zmode = DC_zmode_zgt; break;
+      case GL_GEQUAL:
+	 zmode = DC_zmode_zgte; break;
+      case GL_NOTEQUAL:
+	 zmode = DC_zmode_zne; break;
+      default:
+	 break;
+      }
+      if (ctx->Depth.Mask)
+	 zmode |= DC_atype_zi;
+      else
+	 zmode |= DC_atype_i;
+   } else {
+      zmode |= DC_zmode_nozcmp | DC_atype_i;
+   }
+
+   mmesa->Setup[MGA_CTXREG_DWGCTL] &= DC_zmode_MASK & DC_atype_MASK;
+   mmesa->Setup[MGA_CTXREG_DWGCTL] |= zmode;
+   mmesa->dirty |= MGA_UPLOAD_CTX;
+}
+
+
+static void mgaDDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+}
+
+
+static void mgaDDBlendEquation(GLcontext *ctx, GLenum mode) 
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+}
+
+static void mgaDDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+}
+
+static void mgaDDBlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB, 
+				    GLenum dfactorRGB, GLenum sfactorA,
+				    GLenum dfactorA )
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+}
+
+
+
+static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname, 
+			      const GLfloat *param)
+{
+   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+   }
+}
+
+
+static void mgaDDShadeModel(GLcontext *ctx, GLenum mode)
+{
+   if (1) {
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; 
+      mgaMsg(8, "mgaDDShadeModel: %x\n", mode);
+   }
+}
+
+
+static void mgaDDDepthFunc(GLcontext *ctx, GLenum func)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
+}
+
+static void mgaDDDepthMask(GLcontext *ctx, GLboolean flag)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
+}
+
+
+
+
+static void mgaUpdateFogAttrib( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   mgaUI32 color = MGAPACKCOLOR888((mgaUI8)(ctx->Fog.Color[0]*255.0F), 
+				   (mgaUI8)(ctx->Fog.Color[1]*255.0F), 
+				   (mgaUI8)(ctx->Fog.Color[2]*255.0F));
+
+   if (color != mmesa->Setup[MGA_CTXREG_FOGCOLOR]) 
+      mmesa->Setup[MGA_CTXREG_FOGCOLOR] = color;
+
+   mmesa->Setup[MGA_CTXREG_MACCESS] &= ~MA_fogen_enable;
+   if (ctx->FogMode == FOG_FRAGMENT) 
+      mmesa->Setup[MGA_CTXREG_MACCESS] |= MA_fogen_enable;
+
+   mmesa->dirty |= MGA_UPLOAD_CTX;
+}
+
+static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_FOG;
+}
+
+
+
+
+/* =============================================================
+ * Alpha blending
+ */
+
+
+static void mgaUpdateAlphaMode(GLcontext *ctx)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int a = 0;
+
+   /* determine source of alpha for blending and testing */
+   if ( !ctx->Texture.Enabled || (mmesa->Fallback & MGA_FALLBACK_TEXTURE)) 
+      a |= AC_alphasel_diffused;
+   else {
+      switch (ctx->Texture.Unit[0].EnvMode) {
+      case GL_DECAL:
+      case GL_REPLACE:
+	 a |= AC_alphasel_fromtex;
+	 break;
+      case GL_BLEND:
+      case GL_MODULATE:
+	 a |= AC_alphasel_modulated;
+	 break;
+      default:
+      }
+   }
+
+
+   /* alpha test control - disabled by default.
+    */
+   if (ctx->Color.AlphaEnabled) {
+      GLubyte ref = ctx->Color.AlphaRef;
+      switch (ctx->Color.AlphaFunc) {
+      case GL_NEVER:		
+	 a |= AC_atmode_alt;
+	 ref = 0;
+	 break;
+      case GL_LESS:
+	 a |= AC_atmode_alt; 
+	 break;
+      case GL_GEQUAL:
+	 a |= AC_atmode_agte; 
+	 break;
+      case GL_LEQUAL:  
+	 a |= AC_atmode_alte; 
+	 break;
+      case GL_GREATER:  
+	 a |= AC_atmode_agt; 
+	 break;
+      case GL_NOTEQUAL: 
+	 a |= AC_atmode_ane; 
+	 break;
+      case GL_EQUAL: 
+	 a |= AC_atmode_ae; 
+	 break;
+      case GL_ALWAYS:
+	 a |= AC_atmode_noacmp; 
+	 break;
+      default:
+      }
+      a |= MGA_FIELD(AC_atref,ref);
+   }
+
+   /* blending control */
+   if (ctx->Color.BlendEnabled) {
+      switch (ctx->Color.BlendSrcRGB) {
+      case GL_ZERO:
+	 a |= AC_src_zero; break;
+      case GL_SRC_ALPHA:
+	 a |= AC_src_src_alpha; break;
+      case GL_ONE:
+	 a |= AC_src_one; break;
+      case GL_DST_COLOR:
+	 a |= AC_src_dst_color; break;
+      case GL_ONE_MINUS_DST_COLOR:
+	 a |= AC_src_om_dst_color; break;
+      case GL_ONE_MINUS_SRC_ALPHA:
+	 a |= AC_src_om_src_alpha; break;
+      case GL_DST_ALPHA:
+	 if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/
+	    a |= AC_src_dst_alpha;
+	 else
+	    a |= AC_src_one;
+	 break;
+      case GL_ONE_MINUS_DST_ALPHA:
+	 if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/
+	    a |= AC_src_om_dst_alpha; 
+	 else 
+	    a |= AC_src_zero;
+	 break;
+      case GL_SRC_ALPHA_SATURATE:
+	 a |= AC_src_src_alpha_sat; 
+	 break;
+      default:		/* never happens */
+      }
+
+      switch (ctx->Color.BlendDstRGB) {
+      case GL_SRC_ALPHA:
+	 a |= AC_dst_src_alpha; break;
+      case GL_ONE_MINUS_SRC_ALPHA:
+	 a |= AC_dst_om_src_alpha; break;
+      case GL_ZERO:
+	 a |= AC_dst_zero; break;
+      case GL_ONE:
+	 a |= AC_dst_one; break;
+      case GL_SRC_COLOR:
+	 a |= AC_dst_src_color; break;
+      case GL_ONE_MINUS_SRC_COLOR:
+	 a |= AC_dst_om_src_color; break;
+      case GL_DST_ALPHA:
+	 if (0) /*(mgaDB->Attrib & MGA_PF_HASALPHA)*/
+	    a |= AC_dst_dst_alpha;
+	 else
+	    a |= AC_dst_one;
+	 break;
+      case GL_ONE_MINUS_DST_ALPHA:
+	 if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/
+	    a |= AC_dst_om_dst_alpha;
+	 else
+	    a |= AC_dst_zero;
+	 break;
+      default:		/* never happens */
+      }
+   } else {
+      a |= AC_src_one|AC_dst_zero;
+   }
+
+   mmesa->Setup[MGA_CTXREG_ALPHACTRL] = (AC_amode_alpha_channel | 
+					AC_astipple_disable | 
+					AC_aten_disable | 
+					AC_atmode_noacmp | 
+					a);
+ 
+   mmesa->dirty |= MGA_UPLOAD_CTX;
+}
+
+
+
+/* =============================================================
+ * Hardware clipping
+ */
+
+static void mgaUpdateClipping(const GLcontext *ctx)
+{
+#if 0
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;	
+   int x1,x2,y1,y2;
+
+   if ( ctx->Scissor.Enabled) {
+      x1 = ctx->Scissor.X;
+      x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
+      y1 = dPriv->Height - ctx->Scissor.Y - ctx->Scissor.Height;
+      y2 = dPriv->Height - ctx->Scissor.Y - 1;
+   } else {
+      x1 = 0;
+      y1 = 0;
+      x2 = mgaDB->Width-1;
+      y2 = mgaDB->Height-1;
+   }
+  
+   if (x1 < 0) x1 = 0;
+   if (y1 < 0) y1 = 0;
+   if (x2 >= mgaDB->Width) x2 = mgaDB->Width-1;
+   if (y2 >= mgaDB->Height) y2 = mgaDB->Height-1;
+
+   if (x1 > x2 || y1 > y2) {
+      x1 = 0; x2 = 0;
+      y2 = 0; y1 = 1;
+   }
+
+
+   mmesa->Setup[MGA_CTXREG_CXBNDRY] = (MGA_FIELD(CXB_cxright,x2) | 
+				      MGA_FIELD(CXB_cxleft,x1));
+   mmesa->Setup[MGA_CTXREG_YTOP] = y1*mgaDB->Pitch;
+   mmesa->Setup[MGA_CTXREG_YBOT] = y2*mgaDB->Pitch;
+
+
+   mmesa->dirty |= MGA_UPLOAD_CTX;
+#endif
+}
+
+
+static void mgaDDScissor( GLcontext *ctx, GLint x, GLint y, 
+			  GLsizei w, GLsizei h )
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CLIP;
+}
+
+
+/* ======================================================================
+ * New stuff for DRI state.
+ */
+
+static void mgaDDDither(GLcontext *ctx, GLboolean enable)
+{
+}
+
+
+static GLboolean mgaDDSetBuffer(GLcontext *ctx, GLenum mode )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   mmesa->Fallback &= ~MGA_FALLBACK_BUFFER;
+
+   if (mode == GL_FRONT_LEFT) 
+   {
+      mmesa->drawOffset = mmesa->mgaScreen->fbOffset;
+      mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->fbOffset;
+      mmesa->dirty |= MGA_UPLOAD_CTX;
+      mgaXMesaSetFrontClipRects( mmesa );
+      return GL_TRUE;
+   } 
+   else if (mode == GL_BACK_LEFT) 
+   {
+      mmesa->drawOffset = mmesa->mgaScreen->backOffset;
+      mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->backOffset;
+      mmesa->dirty |= MGA_UPLOAD_CTX;
+      mgaXMesaSetBackClipRects( mmesa );
+      return GL_TRUE;
+   }
+   else 
+   {
+      mmesa->Fallback |= MGA_FALLBACK_BUFFER;
+      return GL_FALSE;
+   }
+}
+
+
+
+static void mgaDDSetColor(GLcontext *ctx, 
+			   GLubyte r, GLubyte g,
+			   GLubyte b, GLubyte a )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   mmesa->MonoColor = mgaPackColor( mmesa->mgaScreen->fbFormat,
+				      r, g, b, a );
+}
+
+
+static void mgaDDClearColor(GLcontext *ctx, 
+			     GLubyte r, GLubyte g,
+			     GLubyte b, GLubyte a )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   mmesa->ClearColor = mgaPackColor( mmesa->mgaScreen->fbFormat,
+				      r, g, b, a );
+}
+
+
+/* =============================================================
+ * Culling
+ */
+
+#define _CULL_DISABLE 0
+#define _CULL_NEGATIVE ((1<<11)|(1<<5)|(1<<16))
+#define _CULL_POSITIVE (1<<11)
+
+
+static void mgaUpdateCull( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLuint mode = _CULL_DISABLE;
+   
+   if (ctx->Polygon.CullFlag && 
+       ctx->PB->primitive == GL_POLYGON &&       
+       ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) 
+   {
+      mode = _CULL_NEGATIVE;
+      if (ctx->Polygon.CullFaceMode == GL_FRONT)
+	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
+      if (ctx->Polygon.FrontFace != GL_CCW)
+	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
+      if (mmesa->multitex)
+	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE); /* why??? */
+   }
+
+   mmesa->Setup[MGA_CTXREG_WFLAG] = mode;
+   mmesa->dirty |= MGA_UPLOAD_CTX;
+}
+
+
+static void mgaDDCullFaceFrontFace(GLcontext *ctx, GLenum mode)
+{
+   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CULL;
+}
+
+
+
+
+/* =============================================================
+ * Color masks
+ */
+
+/* Mesa calls this from the wrong place:
+ */
+static GLboolean mgaDDColorMask(GLcontext *ctx, 
+				GLboolean r, GLboolean g, 
+				GLboolean b, GLboolean a )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;	
+
+
+   GLuint mask = mgaPackColor(mgaScreen->Attrib,
+			      ctx->Color.ColorMask[RCOMP],
+			      ctx->Color.ColorMask[GCOMP],
+			      ctx->Color.ColorMask[BCOMP],
+			      ctx->Color.ColorMask[ACOMP]);
+  
+   switch (mgaScreen->Attrib & MGA_PF_MASK)
+   {
+   case MGA_PF_555:
+   case MGA_PF_565:
+      mask = mask | (mask << 16);
+      break;
+   }
+
+   if (mmesa->Setup[MGA_CTXREG_PLNWT] != mask) {
+      mmesa->Setup[MGA_CTXREG_PLNWT] = mask;      
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_MASK; 
+      mmesa->dirty |= MGA_UPLOAD_CTX;
+   }
+
+   return 1;
+}
+
+/* =============================================================
+ */
+
+
+
+
+static void mgaDDPrintDirty( const char *msg, GLuint state )
+{
+   fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s\n",	   
+	   msg,
+	   (unsigned int) state,
+	   (state & MGA_REQUIRE_QUIESCENT) ? "req-quiescent, " : "",
+	   (state & MGA_UPLOAD_TEX0IMAGE)  ? "upload-tex0-img, " : "",
+	   (state & MGA_UPLOAD_TEX1IMAGE)  ? "upload-tex1-img, " : "",
+	   (state & MGA_UPLOAD_CTX)        ? "upload-ctx, " : "",
+	   (state & MGA_UPLOAD_TEX0)       ? "upload-tex0, " : "",
+	   (state & MGA_UPLOAD_TEX1)       ? "upload-tex1, " : ""
+	   );
+}
+
+
+/* Push the state into the sarea and/or texture memory.
+ */
+void mgaEmitHwStateLocked( mgaContextPtr mmesa )
+{
+   if (MGA_DEBUG & MGA_DEBUG_VERBOSE_MSG)
+      mgaDDPrintDirty( "mgaEmitHwStateLocked", mmesa->dirty );
+
+   if ((mmesa->dirty & MGA_UPLOAD_TEX0IMAGE) && mmesa->CurrentTexObj[0])
+      mgaUploadTexImages(mmesa, mmesa->CurrentTexObj[0]);
+   
+   if ((mmesa->dirty & MGA_UPLOAD_TEX1IMAGE) && mmesa->CurrentTexObj[1])
+      mgaUploadTexImages(mmesa, mmesa->CurrentTexObj[1]);
+  
+   if (mmesa->dirty & MGA_UPLOAD_CTX) {
+      memcpy( mmesa->sarea->ContextState, 
+	      mmesa->Setup,
+	      sizeof(mmesa->Setup));
+
+      if (mmesa->CurrentTexObj[0])
+	 memcpy(mmesa->sarea->TexState[0],
+		mmesa->CurrentTexObj[0]->Setup,
+		sizeof(mmesa->sarea->TexState[0]));
+
+      if (mmesa->CurrentTexObj[1])
+	 memcpy(mmesa->sarea->TexState[1],
+		mmesa->CurrentTexObj[1]->Setup,
+		sizeof(mmesa->sarea->TexState[1]));
+   }
+
+   if (mmesa->dirty & MGA_UPLOAD_PIPE) 
+      mmesa->sarea->WarpPipe = mmesa->setupindex & MGA_WARP_T2GZSAF;
+      
+   mmesa->sarea->dirty |= mmesa->dirty;
+   mmesa->dirty = 0;
+}
+
+
+
+/* =============================================================
+ */
+
+static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
+{
+   switch(cap) {
+   case GL_ALPHA_TEST:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+      break;
+   case GL_BLEND:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+      break;
+   case GL_DEPTH_TEST:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
+      break;
+   case GL_SCISSOR_TEST:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CLIP;
+      break;
+   case GL_FOG:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_FOG;
+      break;
+   case GL_CULL_FACE:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CULL;
+      break;
+   case GL_TEXTURE_1D:
+   case GL_TEXTURE_2D:
+   case GL_TEXTURE_3D:
+      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+      break;
+   default:
+      ; 
+   }    
+}
+
+
+/* =============================================================
+ */
+
+/* Just need to note that it has changed - the kernel will do the
+ * upload the next time we fire a dma buffer.
+ */
+static void mgaWarpUpdateState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int index = mmesa->setupindex;
+ 
+   index &= ~(MGA_WIN_BIT|MGA_TEX0_BIT|MGA_RGBA_BIT);
+   index |= MGA_ALPHA_BIT;
+
+   if (index != mmesa->warp_pipe)
+   {
+      mmesa->warp_pipe = index;
+      mmesa->new_state |= MGA_NEW_WARP;
+   }
+}
+
+
+
+/* =============================================================
+ */
+
+static void mgaDDPrintState( const char *msg, GLuint state )
+{
+   mgaMsg(1, "%s (0x%x): %s%s%s%s%s%s%s%s\n",
+	   msg,
+	   state,
+	   (state & MGA_NEW_DEPTH)   ? "depth, " : "",
+	   (state & MGA_NEW_ALPHA)   ? "alpha, " : "",
+	   (state & MGA_NEW_FOG)     ? "fog, " : "",
+	   (state & MGA_NEW_CLIP)    ? "clip, " : "",
+	   (state & MGA_NEW_MASK)    ? "colormask, " : "",
+	   (state & MGA_NEW_CULL)    ? "cull, " : "",
+	   (state & MGA_NEW_TEXTURE) ? "texture, " : "",
+	   (state & MGA_NEW_CONTEXT) ? "context, " : "");
+}
+
+void mgaDDUpdateHwState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int new_state = mmesa->new_state;
+
+   if (new_state) 
+   {
+      mmesa->new_state = 0;
+
+      /* Emit any vertices for the current state.  This will also
+       * push the current state into the sarea.
+       */
+/*        mgaFlushVertices( mmesa ); */
+
+      if (MESA_VERBOSE&VERBOSE_DRIVER)
+	 mgaDDPrintState("UpdateHwState", new_state);
+
+      if (new_state & MGA_NEW_DEPTH)
+      {
+	 mgaUpdateZMode(ctx);
+	 mgaDDInitDepthFuncs(ctx);
+      }
+
+      if (new_state & MGA_NEW_ALPHA)
+	 mgaUpdateAlphaMode(ctx);
+
+      if (new_state & MGA_NEW_FOG)
+	 mgaUpdateFogAttrib(ctx);
+
+      if (new_state & MGA_NEW_CLIP)
+	 mgaUpdateClipping(ctx);
+
+      if (new_state & (MGA_NEW_WARP|MGA_NEW_CULL))
+	 mgaUpdateCull(ctx);
+
+      if (new_state & (MGA_NEW_WARP|MGA_NEW_TEXTURE))
+	 mgaUpdateTextureState(ctx);
+
+      mmesa->new_state = 0; /* tex uploads scribble newstate */
+   }
+}
+
+
+
+
+
+
+
+void mgaDDReducedPrimitiveChange( GLcontext *ctx, GLenum prim )
+{
+   mgaFlushVertices( MGA_CONTEXT(ctx) );
+   mgaUpdateCull(ctx);
+}
+
+
+#define INTERESTED (~(NEW_MODELVIEW|NEW_PROJECTION|\
+                      NEW_TEXTURE_MATRIX|\
+                      NEW_USER_CLIP|NEW_CLIENT_STATE|\
+                      NEW_TEXTURE_ENABLE))
+
+void mgaDDUpdateState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   mgaglx.c_setupPointers++;
+   
+   if (ctx->NewState & INTERESTED) {
+      mgaDDChooseRenderState(ctx);  
+      mgaChooseRasterSetupFunc(ctx);
+      mgaWarpUpdateState(ctx);
+   }     
+
+   /* Have to do this here to detect texture fallbacks in time:
+    */
+   if (MGA_CONTEXT(ctx)->new_state & MGA_NEW_TEXTURE)
+      mgaDDUpdateHwState( ctx );
+
+   if (!mmesa->Fallback || mgaglx.noFallback) {
+      ctx->Driver.PointsFunc=mmesa->PointsFunc;
+      ctx->Driver.LineFunc=mmesa->LineFunc;
+      ctx->Driver.TriangleFunc=mmesa->TriangleFunc;
+      ctx->Driver.QuadFunc=mmesa->QuadFunc;
+   }
+}
+
+
+void mgaDDInitStateFuncs( GLcontext *ctx )
+{
+   ctx->Driver.UpdateState = mgaDDUpdateState;
+   ctx->Driver.Enable = mgaDDEnable;
+   ctx->Driver.LightModelfv = mgaDDLightModelfv;
+   ctx->Driver.AlphaFunc = mgaDDAlphaFunc;
+   ctx->Driver.BlendEquation = mgaDDBlendEquation;
+   ctx->Driver.BlendFunc = mgaDDBlendFunc;
+   ctx->Driver.BlendFuncSeparate = mgaDDBlendFuncSeparate;
+   ctx->Driver.DepthFunc = mgaDDDepthFunc;
+   ctx->Driver.DepthMask = mgaDDDepthMask;
+   ctx->Driver.Fogfv = mgaDDFogfv;
+   ctx->Driver.Scissor = mgaDDScissor;
+   ctx->Driver.ShadeModel = mgaDDShadeModel;
+   ctx->Driver.CullFace = mgaDDCullFaceFrontFace;
+   ctx->Driver.FrontFace = mgaDDCullFaceFrontFace;
+   ctx->Driver.ColorMask = mgaDDColorMask;
+   ctx->Driver.ReducedPrimitiveChange = mgaDDReducedPrimitiveChange;
+   ctx->Driver.RenderStart = mgaDDUpdateHwState; 
+   ctx->Driver.RenderFinish = 0; 
+
+   ctx->Driver.SetBuffer = mgaDDSetBuffer;
+   ctx->Driver.Color = mgaDDSetColor;
+   ctx->Driver.ClearColor = mgaDDClearColor;
+   ctx->Driver.Dither = mgaDDDither;
+
+   ctx->Driver.Index = 0;
+   ctx->Driver.ClearIndex = 0;
+   ctx->Driver.IndexMask = 0;
+
+}
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgastate.h b/xc/lib/GL/mesa/src/drv/mga/mgastate.h
new file mode 100644
index 000000000..5ada1b23c
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgastate.h
@@ -0,0 +1,15 @@
+#ifndef _MGA_STATE_H
+#define _MGA_STATE_H
+
+
+extern void mgaDDInitStateFuncs(GLcontext *ctx);
+extern void mgaDDUpdateHwState( GLcontext *ctx );
+extern void mgaDDUpdateState( GLcontext *ctx );
+extern void mgaDDReducedPrimitiveChange( GLcontext *ctx, GLenum prim );
+
+/* reprograms the current registers without updating them, used to
+reset state after a dma buffer overflow */
+void mgaUpdateRegs( GLuint regs );
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatex.c b/xc/lib/GL/mesa/src/drv/mga/mgatex.c
new file mode 100644
index 000000000..be7ad6018
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgatex.c
@@ -0,0 +1,1051 @@
+/* -*- mode: C; c-basic-offset:8 -*- */
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    original by Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ *	9/20/99 rewrite by John Carmack <johnc@idsoftware.com>
+ *      13/1/00 port to DRI by Keith Whitwell <keithw@precisioninsight.com>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <GL/gl.h>
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgadma.h"
+#include "mgatex.h"
+#include "mgalog.h"
+#include "mgaregs.h"
+
+#include "simple_list.h"
+
+
+/*
+ * mgaDestroyTexObj
+ * Free all memory associated with a texture and NULL any pointers
+ * to it.
+ */
+static void mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t ) {
+	int	i;
+
+ 	if ( !t ) return;
+  	  	
+	/* free the texture memory */
+	mmFreeMem( t->MemBlock );
+ 
+ 	/* free mesa's link */   
+	t->tObj->DriverData = NULL;
+
+	/* see if it was the driver's current object */
+	for ( i = 0 ; i < 2 ; i++ ) {
+		if ( mmesa->CurrentTexObj[i] == t ) {
+			mmesa->CurrentTexObj[i] = NULL;
+		}  
+	}
+	
+	remove_from_list(t);
+	free( t );
+}
+
+static void mgaSwapOutTexObj(mgaContextPtr mmesa, mgaTextureObjectPtr t)
+{
+	if (t->MemBlock) {
+		mmFreeMem(t->MemBlock);
+		t->MemBlock = 0;      
+	}
+
+	t->dirty_images = ~0;
+	move_to_tail(&(mmesa->SwappedOut), t);
+}
+
+
+void mgaResetGlobalLRU( mgaContextPtr mmesa )
+{
+   mgaTexRegion *list = mmesa->sarea->texList;
+   int sz = 1 << mmesa->mgaScreen->logTextureGranularity;
+   int i;
+
+   /* (Re)initialize the global circular LRU list.  The last element
+    * in the array (MGA_NR_TEX_REGIONS) is the sentinal.  Keeping it
+    * at the end of the array allows it to be addressed rationally
+    * when looking up objects at a particular location in texture
+    * memory.  
+    */
+   for (i = 0 ; (i+1) * sz < mmesa->mgaScreen->textureSize ; i++) {
+      list[i].prev = i-1;
+      list[i].next = i+1;
+      list[i].age = 0;
+   }
+
+   i--;
+   list[0].prev = MGA_NR_TEX_REGIONS;
+   list[i].prev = i-1;
+   list[i].next = MGA_NR_TEX_REGIONS;
+   list[MGA_NR_TEX_REGIONS].prev = i;
+   list[MGA_NR_TEX_REGIONS].next = 0;
+   mmesa->sarea->texAge = 0;
+}
+
+
+static void mgaUpdateTexLRU( mgaContextPtr mmesa, mgaTextureObjectPtr t ) 
+{
+   int i;
+   int logsz = mmesa->mgaScreen->logTextureGranularity;
+   int start = t->MemBlock->ofs >> logsz;
+   int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz;
+   mgaTexRegion *list = mmesa->sarea->texList;
+   
+   mmesa->texAge = ++mmesa->sarea->texAge;
+
+   /* Update our local LRU
+    */
+   move_to_head( &(mmesa->TexObjList), t );
+
+   /* Update the global LRU
+    */
+   for (i = start ; i <= end ; i++) {
+
+      list[i].in_use = 1;
+      list[i].age = mmesa->texAge;
+
+      /* remove_from_list(i)
+       */
+      list[(unsigned)list[i].next].prev = list[i].prev;
+      list[(unsigned)list[i].prev].next = list[i].next;
+      
+      /* insert_at_head(list, i)
+       */
+      list[i].prev = MGA_NR_TEX_REGIONS;
+      list[i].next = list[MGA_NR_TEX_REGIONS].next;
+      list[(unsigned)list[MGA_NR_TEX_REGIONS].next].prev = i;
+      list[MGA_NR_TEX_REGIONS].next = i;
+   }
+}
+
+
+/* Called for every shared texture region which has increased in age
+ * since we last held the lock.
+ *
+ * Figures out which of our textures have been ejected by other clients,
+ * and pushes a placeholder texture onto the LRU list to represent 
+ * the other client's textures.  
+ */
+void mgaTexturesGone( mgaContextPtr mmesa,
+		       GLuint offset, 
+		       GLuint size,
+		       GLuint in_use ) 
+{
+   mgaTextureObjectPtr t, tmp;
+   
+   foreach_s ( t, tmp, &mmesa->TexObjList ) {
+
+      if (t->MemBlock->ofs >= offset + size ||
+	  t->MemBlock->ofs + t->MemBlock->size <= offset)
+	 continue;
+
+      /* It overlaps - kick it off.  Need to hold onto the currently bound
+       * objects, however.
+       */
+      if (t == mmesa->CurrentTexObj[0] || t == mmesa->CurrentTexObj[1]) 
+	 mgaSwapOutTexObj( mmesa, t );
+      else
+	 mgaDestroyTexObj( mmesa, t );
+   }
+
+   
+   if (in_use) {
+      t = (mgaTextureObjectPtr) calloc(1,sizeof(*t));
+      if (!t) return;
+
+      t->MemBlock = mmAllocMem( mmesa->texHeap, size, 0, offset);      
+      insert_at_head( &mmesa->TexObjList, t );
+   }
+}
+
+
+/*
+ * mgaSetTexWrappings
+ */
+static void mgaSetTexWrapping( mgaTextureObjectPtr t,
+			       GLenum sWrap, GLenum tWrap ) {
+	if (sWrap == GL_REPEAT) {
+		t->Setup[MGA_TEXREG_CTL] &= ~TMC_clampu_enable;
+	} else {
+		t->Setup[MGA_TEXREG_CTL] |= TMC_clampu_enable;
+	}
+	if (tWrap == GL_REPEAT) {
+		t->Setup[MGA_TEXREG_CTL] &= ~TMC_clampv_enable;
+	} else {
+		t->Setup[MGA_TEXREG_CTL] |= TMC_clampv_enable;
+	}
+}
+
+/*
+ * mgaSetTexFilter
+ */
+static void mgaSetTexFilter(mgaTextureObjectPtr t, GLenum minf, GLenum magf) {
+	switch (minf) {
+	case GL_NEAREST:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_nrst);
+		break;
+	case GL_LINEAR:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_bilin);
+		break;
+	case GL_NEAREST_MIPMAP_NEAREST:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_mm1s);
+		break;
+	case GL_LINEAR_MIPMAP_NEAREST:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_mm4s);
+		break;
+	case GL_NEAREST_MIPMAP_LINEAR:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_mm2s);
+		break;
+	case GL_LINEAR_MIPMAP_LINEAR:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_minfilter_MASK, TF_minfilter_mm8s);
+		break;
+	default:
+		mgaError("mgaSetTexFilter(): not supported min. filter %d\n",
+			 (int)minf);
+		break;
+	}
+
+	switch (magf) {
+	case GL_NEAREST:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_magfilter_MASK,TF_magfilter_nrst);
+		break;
+	case GL_LINEAR:
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],
+		  TF_magfilter_MASK,TF_magfilter_bilin);
+		break;
+	default:
+		mgaError("mgaSetTexFilter(): not supported mag. filter %d\n",
+			 (int)magf);
+		break;
+	}
+  
+	/* See OpenGL 1.2 specification */
+	if (magf == GL_LINEAR && (minf == GL_NEAREST_MIPMAP_NEAREST || 
+                            minf == GL_NEAREST_MIPMAP_LINEAR)) {
+		/* c = 0.5 */
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],TF_fthres_MASK,
+		  0x20 << TF_fthres_SHIFT);
+	} else {
+		/* c = 0 */
+		MGA_SET_FIELD(t->Setup[MGA_TEXREG_FILTER],TF_fthres_MASK,
+		  0x10 << TF_fthres_SHIFT);
+	}
+
+}
+
+/*
+ * mgaSetTexBorderColor
+ */
+static void mgaSetTexBorderColor(mgaTextureObjectPtr t, GLubyte color[4]) {
+	t->Setup[MGA_TEXREG_BORDERCOL] = 
+		MGAPACKCOLOR8888(color[0],color[1],color[2],color[3]);
+
+}
+
+
+
+
+
+
+
+/*
+ * mgaUploadSubImage
+ *
+ * Perform an iload based update of a resident buffer.  This is used for
+ * both initial loading of the entire image, and texSubImage updates.
+ *
+ * Performed with the hardware lock held.
+ */
+static void mgaUploadSubImage( mgaContextPtr mmesa,
+			       mgaTextureObjectPtr t,
+			       int level,	     
+			       int x, int y, int width, int height ) {
+	int		x2;
+	int		dwords;
+        int		dstorg;
+	struct gl_texture_image *image;
+	int		texelBytes, texelsPerDword, texelMaccess;
+
+	if ( level < 0 || level >= MGA_TEX_MAXLEVELS ) {
+		mgaMsg( 1, "mgaUploadSubImage: bad level: %i\n", level );
+ 	 	return;
+	}
+
+	image = t->tObj->Image[level];
+	if ( !image ) {
+		mgaError( "mgaUploadSubImage: NULL image\n" );
+		return;
+	}
+	
+	/* find the proper destination offset for this level */
+   	dstorg = (mmesa->mgaScreen->textureOffset + t->MemBlock->ofs + 
+		  t->offsets[level]);
+
+    	/* turn on PCI/AGP if needed 
+    	if ( textureHeapPhysical ) {
+    		dstorg |= 1 | mgaglx.use_agp;
+    	}
+	*/
+
+	texelBytes = t->texelBytes;	
+	switch( texelBytes ) {
+	case 1:
+		texelsPerDword = 4;
+		texelMaccess = 0;
+		break;
+	case 2:
+		texelsPerDword = 2;
+		texelMaccess = 1;
+		break;
+	case 4:
+		texelsPerDword = 1;
+		texelMaccess = 2;
+		break;
+	default:
+		return;
+	}
+			
+		
+	/* We can't do a subimage update if pitch is < 32 texels due
+	 * to hardware XY addressing limits, so we will need to
+	 * linearly upload all modified rows.
+	 */
+	if ( image->Width < 32 ) {
+		x = 0;
+		width = image->Width * height;
+		height = 1;
+
+		/* Assume that 1x1 textures aren't going to cause a
+		 * bus error if we read up to four texels from that
+		 * location: 
+		 */
+		if ( width < texelsPerDword ) {
+			width = texelsPerDword;
+		}
+	} else {
+		/* pad the size out to dwords.  The image is a pointer
+		   to the entire image, so we can safely reference
+		   outside the x,y,width,height bounds if we need to */
+		x2 = x + width;
+		x2 = (x2 + (texelsPerDword-1)) & ~(texelsPerDword-1);	
+		x = (x + (texelsPerDword-1)) & ~(texelsPerDword-1);
+		width = x2 - x;
+	}
+    
+	/* we may not be able to upload the entire texture in one
+	   batch due to register limits or dma buffer limits.
+	   Recursively split it up. */
+	while ( 1 ) {
+		dwords = height * width / texelsPerDword;
+		if ( dwords * 4 <= MGA_DMA_BUF_SZ ) {
+			break;
+		}
+		mgaMsg(10, "mgaUploadSubImage: recursively subdividing\n" );
+
+		mgaUploadSubImage( mmesa, t, level, x, y, width, height >> 1 );
+		y += ( height >> 1 );
+		height -= ( height >> 1 );
+	}
+	
+	mgaMsg(10, "mgaUploadSubImage: %i,%i of %i,%i at %i,%i\n", 
+	       width, height, image->Width, image->Height, x, y );
+
+	/* bump the performance counter */
+	mgaglx.c_textureSwaps += ( dwords << 2 );
+	
+	
+#if 0
+
+	/* fill in the secondary buffer with properly converted texels
+	from the mesa buffer */
+	mgaConvertTexture( dest, texelBytes, image, x, y, width, height );
+		
+	/* send the secondary data */	
+	mgaSecondaryDma( TT_BLIT, dest, dwords );
+#endif
+
+}
+
+
+
+static void mgaUploadTexLevel( mgaContextPtr mmesa, 
+			       mgaTextureObjectPtr t,
+			       int l )
+{
+	mgaUploadSubImage( mmesa,
+			   t,
+			   l,
+			   0, 0,
+			   t->tObj->Image[l]->Width,
+			   t->tObj->Image[l]->Height);
+}
+
+
+
+/*
+ * mgaCreateTexObj
+ * Allocate space for and load the mesa images into the texture memory block.
+ * This will happen before drawing with a new texture, or drawing with a
+ * texture after it was swapped out or teximaged again.
+ */
+static void mgaCreateTexObj(mgaContextPtr mmesa, struct gl_texture_object *tObj) 
+{
+	mgaTextureObjectPtr		t;
+	int					i, ofs, size;
+	struct gl_texture_image *image;
+	int					LastLevel;
+	int					s, s2;
+	int					textureFormat;
+	
+	mgaMsg( 10,"mgaCreateTexObj( %p )\n", tObj );
+
+	t = malloc( sizeof( *t ) );
+	if ( !t ) {
+		mgaError( "mgaCreateTexObj: Failed to malloc mgaTextureObject\n" );
+		return;
+	}
+	memset( t, 0, sizeof( *t ) );
+	
+	image = tObj->Image[ 0 ];
+	if ( !image ) {
+		return;
+	}
+
+	if ( 0 ) {
+		/* G400 texture format options */
+
+	} else {
+		/* G200 texture format options */
+		
+		switch( image->Format ) {
+		case GL_RGB:
+	 	case GL_LUMINANCE:
+	 		if ( image->IntFormat != GL_RGB5 &&
+			     ( image->IntFormat == GL_RGB8 ||
+			       mgaglx.default32BitTextures ) ) {
+	 			t->texelBytes = 4;
+	 			textureFormat = TMC_tformat_tw32;
+	 		} else {
+				t->texelBytes = 2;
+				textureFormat = TMC_tformat_tw16;
+			}
+			break;
+		case GL_ALPHA:
+	 	case GL_LUMINANCE_ALPHA:
+		case GL_INTENSITY:
+		case GL_RGBA:
+	 		if ( image->IntFormat != GL_RGBA4 &&
+			     ( image->IntFormat == GL_RGBA8 ||
+			       mgaglx.default32BitTextures ) ) {
+	 			t->texelBytes = 4;
+	 			textureFormat = TMC_tformat_tw32;
+	 		} else {
+				t->texelBytes = 2;
+				textureFormat = TMC_tformat_tw12;
+			}
+			break;
+		case GL_COLOR_INDEX:
+			textureFormat = TMC_tformat_tw8;
+			t->texelBytes = 1;
+			break;
+		default:
+			mgaError( "mgaCreateTexObj: bad image->Format\n" );
+			free( t );
+			return;	
+		}
+	}
+		
+	/* we are going to upload all levels that are present, even if
+	   later levels wouldn't be used by the current filtering mode.  This
+	   allows the filtering mode to change without forcing another upload
+	   of the images */
+	LastLevel = MGA_TEX_MAXLEVELS-1;
+
+	ofs = 0;
+	for ( i = 0 ; i <= LastLevel ; i++ ) {
+		int levelWidth, levelHeight;
+		
+		t->offsets[i] = ofs;
+		image = tObj->Image[ i ];
+		if ( !image ) {
+			LastLevel = i - 1;
+			mgaMsg( 10, "  missing images after LastLevel: %i\n",
+				LastLevel );
+			break;
+		}
+		/* the G400 doesn't work with textures less than 8
+                   units in size */
+		levelWidth = image->Width;
+		levelHeight = image->Height;
+		if ( levelWidth < 8 ) {
+			levelWidth = 8;
+		}
+		if ( levelHeight < 8 ) {
+			levelHeight = 8;
+		}
+		size = levelWidth * levelHeight * t->texelBytes;
+		size = ( size + 31 ) & ~31;	/* 32 byte aligned */
+		ofs += size;
+		t->dirty_images |= (1<<i);
+	}
+	t->totalSize = ofs;
+	t->lastLevel = LastLevel;
+	
+
+	/* fill in our mga texture object */
+	t->tObj = tObj;
+	t->ctx = mmesa;
+
+	
+	insert_at_tail(&(mmesa->TexObjList), t);
+	
+	t->MemBlock = 0;
+
+	/* base image */	  
+	image = tObj->Image[ 0 ];
+
+	/* setup hardware register values */		
+	t->Setup[MGA_TEXREG_CTL] = (TMC_takey_1 | 
+				       TMC_tamask_0 | 
+				       textureFormat );
+
+	if (image->WidthLog2 >= 3) {
+		t->Setup[MGA_TEXREG_CTL] |= ((image->WidthLog2 - 3) << 
+						TMC_tpitch_SHIFT);
+	} else {
+		t->Setup[MGA_TEXREG_CTL] |= (TMC_tpitchlin_enable | 
+						(image->Width << 
+						 TMC_tpitchext_SHIFT));
+	}
+
+
+	t->Setup[MGA_TEXREG_CTL2] = TMC_ckstransdis_enable;
+
+	if ( mmesa->glCtx->Light.Model.ColorControl == 
+	     GL_SEPARATE_SPECULAR_COLOR ) 
+	{
+		t->Setup[MGA_TEXREG_CTL2] |= TMC_specen_enable;
+	}
+	
+	t->Setup[MGA_TEXREG_FILTER] = (TF_minfilter_nrst | 
+					  TF_magfilter_nrst |
+					  TF_filteralpha_enable | 
+					  (0x10 << TF_fthres_SHIFT) | 
+					  (LastLevel << TF_mapnb_SHIFT));
+	
+	/* warp texture registers */
+	if (MGA_IS_G200(mmesa)) {
+		ofs = 28;
+	} else {
+   		ofs = 11;
+   	}
+
+	s = image->Width;
+	s2 = image->WidthLog2;
+	t->Setup[MGA_TEXREG_WIDTH] = 
+		MGA_FIELD(TW_twmask, s - 1) |
+		MGA_FIELD(TW_rfw,    (10 - s2 - 8) & 63 ) |
+		MGA_FIELD(TW_tw,     (s2 + ofs ) | 0x40 );
+
+	
+	s = image->Height;
+	s2 = image->HeightLog2;
+	t->Setup[MGA_TEXREG_HEIGHT] = 
+		MGA_FIELD(TH_thmask, s - 1) |
+		MGA_FIELD(TH_rfh,    (10 - s2 - 8) & 63 ) | 
+		MGA_FIELD(TH_th,     (s2 + ofs ) | 0x40 );
+
+
+	/* set all the register values for filtering, border, etc */	
+	mgaSetTexWrapping( t, tObj->WrapS, tObj->WrapT );
+	mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+	mgaSetTexBorderColor( t, tObj->BorderColor );
+
+  	tObj->DriverData = t;
+}
+
+
+
+int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t )
+{
+
+	int i;
+	int ofs;
+	mgaglx.c_textureSwaps++;
+
+	/* Do we need to eject LRU texture objects?
+	 */
+	if (!t->MemBlock) {
+		while (1)
+		{
+			t->MemBlock = mmAllocMem( mmesa->texHeap, t->totalSize, 12, 0 ); 
+			if (t->MemBlock)
+				break;
+
+			if (mmesa->TexObjList.prev == &(mmesa->TexObjList)) {
+				fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize);
+				mmDumpMemInfo( mmesa->texHeap );
+				return -1;
+			}
+
+			mgaDestroyTexObj( mmesa, mmesa->TexObjList.prev );
+		}
+ 
+		ofs = t->MemBlock->ofs;
+
+		t->Setup[MGA_TEXREG_ORG]  = ofs;
+		t->Setup[MGA_TEXREG_ORG1] = ofs + t->offsets[1];
+		t->Setup[MGA_TEXREG_ORG2] = ofs + t->offsets[2];
+		t->Setup[MGA_TEXREG_ORG3] = ofs + t->offsets[3];
+		t->Setup[MGA_TEXREG_ORG4] = ofs + t->offsets[4];
+
+		mmesa->dirty |= MGA_UPLOAD_CTX;
+	}
+
+	/* Let the world know we've used this memory recently.
+	 */
+	mgaUpdateTexLRU( mmesa, t );
+
+	if (t->dirty_images) {
+		if (MGA_DEBUG & MGA_DEBUG_VERBOSE_MSG)
+			fprintf(stderr, "*");
+
+		for (i = 0 ; i <= t->lastLevel ; i++)
+			if (t->dirty_images & (1<<i)) 
+				mgaUploadTexLevel( mmesa, t, i );
+	}
+
+
+	t->dirty_images = 0;
+	return 0;
+}
+
+/*
+============================================================================
+
+PUBLIC MGA FUNCTIONS
+
+============================================================================
+*/
+
+
+
+static void mgaUpdateTextureEnvG200( GLcontext *ctx )
+{
+	struct gl_texture_object *tObj = ctx->Texture.Unit[0].Current;
+	mgaTextureObjectPtr t;
+
+	if (!tObj || !tObj->DriverData)
+		return;
+
+	t = (mgaTextureObjectPtr)tObj->DriverData;
+
+	switch (ctx->Texture.Unit[0].EnvMode) {
+	case GL_REPLACE:
+		t->Setup[MGA_TEXREG_CTL] &= ~TMC_tmodulate_enable;
+		t->Setup[MGA_TEXREG_CTL2] &= ~TMC_decaldis_enable;
+		break;
+	case GL_MODULATE:
+		t->Setup[MGA_TEXREG_CTL] |= TMC_tmodulate_enable;
+		t->Setup[MGA_TEXREG_CTL2] &= ~TMC_decaldis_enable;
+		break;
+	case GL_DECAL:
+		t->Setup[MGA_TEXREG_CTL] &= ~TMC_tmodulate_enable;
+		t->Setup[MGA_TEXREG_CTL2] &= ~TMC_decaldis_enable;
+		break;
+	case GL_BLEND:
+		t->ctx->Fallback |= MGA_FALLBACK_TEXTURE;
+		break;
+	default:
+	}
+}
+
+/* I don't have the alpha values correct yet:
+ */
+static void mgaUpdateTextureStage( GLcontext *ctx, int unit )
+{
+	mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+	mgaUI32 *reg = &mmesa->Setup[MGA_CTXREG_TDUAL0 + unit];
+	GLuint source = mmesa->tmu_source[unit];
+	struct gl_texture_object *tObj = ctx->Texture.Unit[source].Current;
+
+	*reg = 0;
+	if (unit == 1)
+		*reg = mmesa->Setup[MGA_CTXREG_TDUAL0];
+	
+	if ( tObj != ctx->Texture.Unit[source].CurrentD[2] ) 
+		return;
+	
+	if ( ((ctx->Enabled>>(source*4))&TEXTURE0_ANY) != TEXTURE0_2D ) 
+		return;
+	
+	if (!tObj || !tObj->Complete) 
+		return;
+
+	switch (ctx->Texture.Unit[source].EnvMode) {
+	case GL_REPLACE:
+		*reg = (TD0_color_sel_arg1 |
+			TD0_alpha_sel_arg1 );
+		break;
+
+	case GL_MODULATE:
+		if (unit == 0)
+			*reg = ( TD0_color_arg2_diffuse |
+				 TD0_color_sel_mul | 
+				 TD0_alpha_arg2_diffuse |
+				 TD0_alpha_sel_arg1);
+		else
+			*reg = ( TD0_color_arg2_prevstage |
+				 TD0_color_alpha_prevstage |
+				 TD0_color_sel_mul | 
+				 TD0_alpha_arg2_prevstage |
+				 TD0_alpha_sel_arg1);
+		break;
+	case GL_DECAL:
+		*reg = (TD0_color_arg2_fcol | 
+			TD0_color_alpha_currtex |
+			TD0_color_alpha2inv_enable |
+			TD0_color_arg2mul_alpha2 |
+			TD0_color_arg1mul_alpha1 |
+			TD0_color_add_add |
+			TD0_color_sel_add |
+			TD0_alpha_arg2_fcol |
+			TD0_alpha_sel_arg2 );
+		break;
+
+	case GL_ADD:
+		if (unit == 0)
+			*reg = ( TD0_color_arg2_diffuse |
+				 TD0_color_add_add |
+				 TD0_color_sel_add | 
+				 TD0_alpha_arg2_diffuse |
+				 TD0_alpha_sel_arg1);
+		else
+			*reg = ( TD0_color_arg2_prevstage |
+				 TD0_color_alpha_prevstage |
+				 TD0_color_add_add |
+				 TD0_color_sel_add | 
+				 TD0_alpha_arg2_prevstage |
+				 TD0_alpha_sel_arg1);
+		break;
+
+	case GL_BLEND:
+		/* Use a multipass mechanism to do this:
+		 */
+		mmesa->Fallback |= MGA_FALLBACK_TEXTURE;
+		break;
+	default:
+	}
+}
+
+
+
+static void mgaUpdateTextureObject( GLcontext *ctx, int unit ) {
+	mgaTextureObjectPtr t;
+	struct gl_texture_object	*tObj;
+	GLuint enabled;
+	mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+	GLuint source = mmesa->tmu_source[unit];
+
+	mgaMsg(15,"mgaUpdateTextureState %d\n", unit);
+	
+	/* disable texturing until it is known to be good */
+	mmesa->Setup[MGA_CTXREG_DWGCTL] = 
+		(( mmesa->Setup[MGA_CTXREG_DWGCTL] & DC_opcod_MASK ) | 
+		 DC_opcod_trap);
+
+	enabled = (ctx->Texture.Enabled>>(source*4))&TEXTURE0_ANY;
+	if (enabled != TEXTURE0_2D) {
+		if (enabled)
+			mmesa->Fallback |= MGA_FALLBACK_TEXTURE;
+		return;
+	}
+
+	tObj = ctx->Texture.Unit[source].Current;
+
+	if ( !tObj || tObj != ctx->Texture.Unit[source].CurrentD[2] ) 
+		return;
+	
+	/* if the texture object doesn't exist at all (never used or
+	   swapped out), create it now, uploading all texture images */
+
+	if ( !tObj->DriverData ) {
+		/* clear the current pointer so that texture object can be
+		   swapped out if necessary to make room */
+		mmesa->CurrentTexObj[source] = NULL;
+		mgaCreateTexObj( mmesa, tObj );
+
+		if ( !tObj->DriverData ) {
+			mgaMsg( 5, "mgaUpdateTextureState: create failed\n" );
+			mmesa->Fallback |= MGA_FALLBACK_TEXTURE;
+			return;		/* can't create a texture object */
+		}
+	}
+
+	/* we definately have a valid texture now */
+	mmesa->Setup[MGA_CTXREG_DWGCTL] = 
+		(( mmesa->Setup[MGA_CTXREG_DWGCTL] & DC_opcod_MASK ) | 
+		 DC_opcod_texture_trap);
+
+	t = (mgaTextureObjectPtr)tObj->DriverData;
+
+	if (t->dirty_images) 
+		mmesa->dirty |= (MGA_UPLOAD_TEX0IMAGE << unit);
+
+	mmesa->CurrentTexObj[unit] = t;
+
+	t->Setup[MGA_TEXREG_CTL2] &= ~TMC_dualtex_enable;
+	if (ctx->Texture.Enabled == (TEXTURE0_2D|TEXTURE1_2D))
+		t->Setup[MGA_TEXREG_CTL2] |= TMC_dualtex_enable;
+
+	t->Setup[MGA_TEXREG_CTL2] &= ~TMC_specen_enable;
+	if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+		t->Setup[MGA_TEXREG_CTL2] |= TMC_specen_enable;
+       
+}
+
+
+
+
+
+
+/* The G400 is now programmed quite differently wrt texture environment.
+ */
+void mgaUpdateTextureState( GLcontext *ctx )
+{
+	mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+	mmesa->Fallback &= ~MGA_FALLBACK_TEXTURE;
+
+	if (MGA_IS_G400(mmesa)) {
+		mgaUpdateTextureObject( ctx, 0 );		
+		mgaUpdateTextureStage( ctx, 0 );
+
+		mmesa->Setup[MGA_CTXREG_TDUAL1] = mmesa->Setup[MGA_CTXREG_TDUAL0];
+
+		if (mmesa->multitex) {
+			mgaUpdateTextureObject( ctx, 1 );	
+			mgaUpdateTextureStage( ctx, 1 );
+		}
+	} else {
+		mgaUpdateTextureObject( ctx, 0 );
+		mgaUpdateTextureEnvG200( ctx );
+	}
+
+	/* schedule the register writes */
+	mmesa->dirty |= MGA_UPLOAD_CTX;
+}
+
+
+
+/*
+============================================================================
+
+Driver functions called directly from mesa
+
+============================================================================
+*/
+
+/*
+ * mgaTexEnv
+ */      
+void mgaTexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ) {
+	mgaMsg( 10, "mgaTexEnv( %i )\n", pname );
+
+	if (pname == GL_TEXTURE_ENV_MODE) {
+		/* force the texture state to be updated */
+		MGA_CONTEXT(ctx)->CurrentTexObj[0] = 0;  
+		MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+	}
+}
+
+/*
+ * mgaTexImage
+ */ 
+void mgaTexImage( GLcontext *ctx, GLenum target,
+		  struct gl_texture_object *tObj, GLint level,
+		  GLint internalFormat,
+		  const struct gl_texture_image *image ) 
+{
+	mgaContextPtr mmesa = MGA_CONTEXT( ctx );	
+	mgaTextureObjectPtr t;
+
+	mgaMsg( 10,"mgaTexImage( %p, level %i )\n", tObj, level );
+  
+ 	/* just free the mga texture if it exists, it will be recreated at
+	mgaUpdateTextureState time. */  
+	t = (mgaTextureObjectPtr) tObj->DriverData;
+	if ( t ) {
+		/* if this is the current object, it will force an update */
+ 	 	mgaDestroyTexObj( mmesa, t );
+		mmesa->new_state |= MGA_NEW_TEXTURE;
+	}
+}
+
+/*
+ * mgaTexSubImage
+ */      
+void mgaTexSubImage( GLcontext *ctx, GLenum target,
+		     struct gl_texture_object *tObj, GLint level,
+		     GLint xoffset, GLint yoffset,
+		     GLsizei width, GLsizei height,
+		     GLint internalFormat,
+		     const struct gl_texture_image *image ) 
+{
+	mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+	mgaTextureObjectPtr t;
+
+	mgaMsg(10,"mgaTexSubImage() Size: %d,%d of %d,%d; Level %d\n",
+		width, height, image->Width,image->Height, level);
+
+	t = (mgaTextureObjectPtr) tObj->DriverData;
+
+
+ 	/* just free the mga texture if it exists, it will be recreated at
+	mgaUpdateTextureState time. */  
+	t = (mgaTextureObjectPtr) tObj->DriverData;
+	if ( t ) {
+		/* if this is the current object, it will force an update */
+ 	 	mgaDestroyTexObj( mmesa, t );
+		mmesa->new_state |= MGA_NEW_TEXTURE;
+	}
+
+
+
+#if 0
+	/* the texture currently exists, so directly update it */
+	mgaUploadSubImage( t, level, xoffset, yoffset, width, height );
+#endif
+}
+
+/*
+ * mgaTexParameter
+ * This just changes variables and flags for a state update, which
+ * will happen at the next mgaUpdateTextureState
+ */
+void mgaTexParameter( GLcontext *ctx, GLenum target,
+		      struct gl_texture_object *tObj,
+		      GLenum pname, const GLfloat *params ) {
+	mgaTextureObjectPtr t;
+
+	mgaMsg( 10, "mgaTexParameter( %p, %i )\n", tObj, pname );
+
+	t = (mgaTextureObjectPtr) tObj->DriverData;
+
+	/* if we don't have a hardware texture, it will be automatically
+	created with current state before it is used, so we don't have
+	to do anything now */
+	if ( !t || target != GL_TEXTURE_2D ) {
+		return;
+	}
+
+	switch (pname) {
+	case GL_TEXTURE_MIN_FILTER:
+	case GL_TEXTURE_MAG_FILTER:
+		mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+		break;
+
+	case GL_TEXTURE_WRAP_S:
+	case GL_TEXTURE_WRAP_T:
+		mgaSetTexWrapping(t,tObj->WrapS,tObj->WrapT);
+		break;
+  
+	case GL_TEXTURE_BORDER_COLOR:
+		mgaSetTexBorderColor(t,tObj->BorderColor);
+		break;
+
+	default:
+		return;
+	}
+	/* force the texture state to be updated */
+	MGA_CONTEXT(ctx)->CurrentTexObj[0] = NULL;  
+	MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+}
+
+/*
+ * mgaBindTexture
+ */      
+void mgaBindTexture( GLcontext *ctx, GLenum target,
+		     struct gl_texture_object *tObj ) {
+
+	mgaMsg( 10, "mgaBindTexture( %p )\n", tObj );
+		
+	/* force the texture state to be updated 
+	 */
+	MGA_CONTEXT(ctx)->CurrentTexObj[0] = NULL;  
+	MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+}
+
+/*
+ * mgaDeleteTexture
+ */      
+void mgaDeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) {
+
+	mgaMsg( 10, "mgaDeleteTexture( %p )\n", tObj );
+	
+	/* delete our driver data */
+	if ( tObj->DriverData ) {
+		mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+		mgaDestroyTexObj( mmesa,
+				  (mgaTextureObjectPtr)(tObj->DriverData) );
+		mmesa->new_state |= MGA_NEW_TEXTURE;
+	}
+}
+
+
+/* Have to grab the lock to find out if anyone has kicked out our
+ * textures.
+ */
+GLboolean mgaIsTextureResident( GLcontext *ctx, struct gl_texture_object *t ) 
+{
+	mgaTextureObjectPtr mt;
+
+/*  	LOCK_HARDWARE; */
+	mt = (mgaTextureObjectPtr)t->DriverData;
+/*  	UNLOCK_HARDWARE; */
+
+	return mt && mt->MemBlock;
+}
+
+void mgaDDInitTextureFuncs( GLcontext *ctx )
+{
+   ctx->Driver.TexEnv = mgaTexEnv;
+   ctx->Driver.TexImage = mgaTexImage;
+   ctx->Driver.TexSubImage = mgaTexSubImage;
+   ctx->Driver.BindTexture = mgaBindTexture;
+   ctx->Driver.DeleteTexture = mgaDeleteTexture;
+   ctx->Driver.TexParameter = mgaTexParameter;
+   ctx->Driver.UpdateTexturePalette = 0;
+   ctx->Driver.IsTextureResident = mgaIsTextureResident;
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatex.h b/xc/lib/GL/mesa/src/drv/mga/mgatex.h
new file mode 100644
index 000000000..1e8e7e86f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgatex.h
@@ -0,0 +1,119 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    John Carmack <johnc@idsoftware.com>
+ *    Keith Whitwell <keithw@precisioninsight.com>
+ */
+
+#ifndef MGATEX_INC
+#define MGATEX_INC
+
+#include "mga_drm_public.h"
+#include "types.h"
+#include "mgacommon.h"
+#include "mm.h"
+
+
+#define MGA_TEX_MAXLEVELS 5
+
+
+typedef struct mga_texture_object_s {
+	struct mga_texture_object_s *next;	
+	struct mga_texture_object_s *prev;	
+	struct gl_texture_object *tObj;
+	mgaContextPtr ctx;
+	PMemBlock	MemBlock;               
+	mgaUI32		offsets[MGA_TEX_MAXLEVELS];
+        int             lastLevel;
+        mgaUI32         dirty_images;
+	mgaUI32		totalSize;		
+	int		texelBytes;
+	mgaUI32 	age;   			
+        mgaUI32         Setup[MGA_TEX_SETUP_SIZE];
+} mgaTextureObject_t;
+
+typedef mgaTextureObject_t *mgaTextureObjectPtr;
+
+/* called to check for environment variable options */
+void mgaInitTextureSystem( void );
+
+/* called when a context is being destroyed */
+void mgaDestroyContextTextures( mgaContextPtr ctx );
+
+/* Called before a primitive is rendered to make sure the texture
+ * state is properly setup.  Texture residence is checked later
+ * when we grab the lock.
+ */
+void mgaUpdateTextureState( GLcontext *ctx );
+
+
+/* Driver functions which are called directly from mesa */
+
+void mgaTexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param );
+
+void mgaTexImage( GLcontext *ctx, GLenum target,
+		  struct gl_texture_object *tObj, GLint level,
+		  GLint internalFormat,
+		  const struct gl_texture_image *image );
+
+void mgaTexSubImage( GLcontext *ctx, GLenum target,
+		  struct gl_texture_object *tObj, GLint level,
+		  GLint xoffset, GLint yoffset,
+		  GLsizei width, GLsizei height,
+		  GLint internalFormat,
+		  const struct gl_texture_image *image );
+
+void mgaTexParameter( GLcontext *ctx, GLenum target,
+		      struct gl_texture_object *tObj,
+		      GLenum pname, const GLfloat *params );
+
+void mgaBindTexture( GLcontext *ctx, GLenum target,
+		     struct gl_texture_object *tObj );
+
+void mgaDeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj );
+
+void mgaUpdateTexturePalette( GLcontext *ctx, struct gl_texture_object *tObj );
+
+GLboolean mgaIsTextureResident( GLcontext *ctx, struct gl_texture_object *t );
+
+void mgaConvertTexture( mgaUI32 *destPtr, int texelBytes,
+			struct gl_texture_image *image,
+			int x, int y, int width, int height );
+
+
+
+int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t );
+
+
+
+
+void mgaResetGlobalLRU( mgaContextPtr mmesa );
+void mgaTexturesGone( mgaContextPtr mmesa, GLuint offset, 
+		      GLuint size, GLuint in_use );
+
+void mgaDDInitTextureFuncs( GLcontext *ctx );
+
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatris.c b/xc/lib/GL/mesa/src/drv/mga/mgatris.c
new file mode 100644
index 000000000..bd8ef083f
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgatris.c
@@ -0,0 +1,226 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+#include <stdio.h>
+#include <math.h>
+
+#include "vb.h"
+#include "pipeline.h"
+
+#include "mm.h"
+#include "mgalib.h"
+#include "mgatris.h"
+#include "mgavb.h"
+#include "mgalog.h"
+
+
+static void mga_null_quad( GLcontext *ctx, GLuint v0,
+			   GLuint v1, GLuint v2, GLuint v3, GLuint pv ) {
+}     
+static void mga_null_triangle( GLcontext *ctx, GLuint v0,
+			       GLuint v1, GLuint v2, GLuint pv ) {
+}     
+static void mga_null_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv ) {
+}
+
+static void mga_null_points( GLcontext *ctx, GLuint first, GLuint last ) {
+}
+
+
+#define MGA_COLOR(to, from) {			\
+  (to)[0] = (from)[2];				\
+  (to)[1] = (from)[1];				\
+  (to)[2] = (from)[0];				\
+  (to)[3] = (from)[3];				\
+}
+
+
+
+static triangle_func tri_tab[0x20];   
+static quad_func     quad_tab[0x20];  
+static line_func     line_tab[0x20];  
+static points_func   points_tab[0x20];
+
+static void mgaPrintRenderState( const char *msg, GLuint state )
+{
+   mgaMsg(1, "%s: (%x) %s%s%s%s%s%s\n",
+	   msg, state,
+	   (state & MGA_FLAT_BIT)       ? "flat, "       : "",
+	   (state & MGA_OFFSET_BIT)     ? "offset, "     : "",
+	   (state & MGA_TWOSIDE_BIT)    ? "twoside, "    : "",
+	   (state & MGA_ANTIALIAS_BIT)  ? "antialias, "  : "",
+	   (state & MGA_NODRAW_BIT)     ? "no-draw, "    : "",
+	   (state & MGA_FALLBACK_BIT)   ? "fallback"     : "");
+}
+
+#define IND (0)
+#define TAG(x) x
+#include "mgatritmp.h"
+
+#define IND (MGA_FLAT_BIT)
+#define TAG(x) x##_flat
+#include "mgatritmp.h"
+
+#define IND (MGA_OFFSET_BIT)
+#define TAG(x) x##_offset
+#include "mgatritmp.h"
+
+#define IND (MGA_OFFSET_BIT|MGA_FLAT_BIT)
+#define TAG(x) x##_offset_flat
+#include "mgatritmp.h"
+
+#define IND (MGA_TWOSIDE_BIT)
+#define TAG(x) x##_twoside
+#include "mgatritmp.h"
+
+#define IND (MGA_TWOSIDE_BIT|MGA_FLAT_BIT)
+#define TAG(x) x##_twoside_flat
+#include "mgatritmp.h"
+
+#define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT)
+#define TAG(x) x##_twoside_offset
+#include "mgatritmp.h"
+
+#define IND (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT|MGA_FLAT_BIT)
+#define TAG(x) x##_twoside_offset_flat
+#include "mgatritmp.h"
+
+void mgaDDTrifuncInit()
+{
+   int i;
+
+
+   init();
+   init_flat();
+   init_offset();
+   init_offset_flat();
+   init_twoside();
+   init_twoside_flat();
+   init_twoside_offset();
+   init_twoside_offset_flat();
+
+   /* Hmmm...
+    */
+   for (i = 0 ; i < 0x20 ; i++) {
+      if (i & ~MGA_FLAT_BIT) {
+	 points_tab[i] = points_tab[i&MGA_FLAT_BIT];
+	 line_tab[i] = line_tab[i&MGA_FLAT_BIT];
+      }
+   }
+
+   for (i = 0 ; i < 0x20 ; i++) 
+      if ((i & (MGA_NODRAW_BIT|MGA_FALLBACK_BIT)) == MGA_NODRAW_BIT ||
+	  mgaglx.nullprims) 
+      {
+	 quad_tab[i] = mga_null_quad; 
+	 tri_tab[i] = mga_null_triangle; 
+	 line_tab[i] = mga_null_line;
+	 points_tab[i] = mga_null_points;
+      }
+
+   if (mgaglx.noFallback) {
+      for (i = 0 ; i < 0x10 ; i++) {
+	 points_tab[i|MGA_FALLBACK_BIT] = points_tab[i];
+	 line_tab[i|MGA_FALLBACK_BIT] = line_tab[i];
+	 tri_tab[i|MGA_FALLBACK_BIT] = tri_tab[i];
+	 quad_tab[i|MGA_FALLBACK_BIT] = quad_tab[i];
+      }
+   }
+
+}
+
+
+
+
+
+
+void mgaDDChooseRenderState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint flags = ctx->TriangleCaps;
+
+   ctx->IndirectTriangles &= ~DD_SW_RASTERIZE;
+
+   if (flags) {
+      GLuint ind = 0;
+      GLuint shared = 0;
+      GLuint fallback = MGA_FALLBACK_BIT;
+
+      if (mgaglx.noFallback) fallback = 0;
+
+      if (flags & DD_Z_NEVER)                      shared |= MGA_NODRAW_BIT;
+      if (flags & DD_FLATSHADE)                    shared |= MGA_FLAT_BIT;
+      if (flags & DD_MULTIDRAW)                    shared |= fallback;
+      if (flags & (DD_SELECT|DD_FEEDBACK))         shared |= MGA_FALLBACK_BIT;
+      if (flags & DD_STENCIL)                      shared |= MGA_FALLBACK_BIT;
+
+      ind = shared;
+      if (flags & DD_POINT_SMOOTH)                 ind |= MGA_ANTIALIAS_BIT;
+      if (flags & DD_POINT_ATTEN)                  ind |= fallback;
+
+      mmesa->renderindex = ind;
+      mmesa->PointsFunc = points_tab[ind];
+      if (ind & MGA_FALLBACK_BIT) 
+	 ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE;
+
+      ind = shared;
+      if (flags & DD_LINE_SMOOTH)                   ind |= MGA_ANTIALIAS_BIT;
+      if (flags & DD_LINE_STIPPLE)                  ind |= fallback;
+
+      mmesa->renderindex |= ind;
+      mmesa->LineFunc = line_tab[ind];
+      if (ind & MGA_FALLBACK_BIT) 
+	 ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE;
+
+      ind = shared;
+      if (flags & DD_TRI_SMOOTH)                    ind |= MGA_ANTIALIAS_BIT;
+      if (flags & DD_TRI_OFFSET)                    ind |= MGA_OFFSET_BIT;
+      if (flags & DD_TRI_LIGHT_TWOSIDE)             ind |= MGA_TWOSIDE_BIT;
+      if (flags & (DD_TRI_UNFILLED|DD_TRI_STIPPLE)) ind |= fallback;	
+
+      mmesa->renderindex |= ind;
+      mmesa->TriangleFunc = tri_tab[ind];
+      mmesa->QuadFunc = quad_tab[ind];
+      if (ind & MGA_FALLBACK_BIT)
+	 ctx->IndirectTriangles |= (DD_TRI_SW_RASTERIZE | DD_QUAD_SW_RASTERIZE);
+   } 
+   else if (mmesa->renderindex)
+   {
+      mmesa->renderindex  = 0;
+      mmesa->PointsFunc   = points_tab[0];
+      mmesa->LineFunc     = line_tab[0];
+      mmesa->TriangleFunc = tri_tab[0];
+      mmesa->QuadFunc     = quad_tab[0];
+   }
+
+   if (0) {
+      gl_print_tri_caps("tricaps", ctx->TriangleCaps);
+      mgaPrintRenderState("mga: Render state", mmesa->renderindex);
+   }
+}
+
+
+
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatris.h b/xc/lib/GL/mesa/src/drv/mga/mgatris.h
new file mode 100644
index 000000000..3b41900f1
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgatris.h
@@ -0,0 +1,189 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+#ifndef MGATIS_INC
+#define MGATIS_INC
+
+#include "types.h"
+
+extern void mgaDDChooseRenderState(GLcontext *ctx);
+extern void mgaDDTrifuncInit( void );
+
+
+/* Todo: 
+ *    - multidraw, ...
+ *    - Antialiasing (?)
+ *    - line and polygon stipple
+ *    - select and feedback 
+ *    - stencil 
+ *    - point parameters
+ *    - 
+ */
+#define MGA_ANTIALIAS_BIT   0       /* ignored for now, no fallback */
+#define MGA_FLAT_BIT	0x1
+#define MGA_OFFSET_BIT	0x2	/* 3.1 only */
+#define MGA_TWOSIDE_BIT	0x4	/* 3.1 only */
+#define MGA_NODRAW_BIT	0x8
+#define MGA_FALLBACK_BIT	0x10
+
+/* Not in use:
+ */
+#define MGA_FEEDBACK_BIT    0x20
+#define MGA_SELECT_BIT      0x40
+#define MGA_POINT_PARAM_BIT 0x80	/* not needed? */
+
+
+
+
+static __inline void mga_draw_triangle( mgaContextPtr mmesa,
+				      mgaVertex *v0, 
+				      mgaVertex *v1, 
+				      mgaVertex *v2 )
+{
+   mgaUI32 vertsize = mmesa->vertsize;
+   mgaUI32 *wv = mgaAllocVertexDwords( mmesa, 3 * vertsize );
+   int j;
+
+   for (j = 0 ; j < vertsize ; j++) 
+      wv[j] = v0->ui[j];
+
+   wv += vertsize;
+   for (j = 0 ; j < vertsize ; j++) 
+      wv[j] = v1->ui[j];
+
+   wv += vertsize;
+   for (j = 0 ; j < vertsize ; j++) 
+      wv[j] = v2->ui[j];
+}
+
+
+static __inline void mga_draw_point( mgaContextPtr mmesa,
+				   mgaVertex *tmp, float sz )
+{
+   mgaUI32 vertsize = mmesa->vertsize;
+   mgaUI32 *wv = mgaAllocVertexDwords( mmesa, 6*vertsize);
+   int j;
+
+   *(float *)&wv[0] = tmp->warp1.x - sz;
+   *(float *)&wv[1] = tmp->warp1.y - sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp->warp1.x + sz;
+   *(float *)&wv[1] = tmp->warp1.y - sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp->warp1.x + sz;
+   *(float *)&wv[1] = tmp->warp1.y + sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp->warp1.x + sz;
+   *(float *)&wv[1] = tmp->warp1.y + sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp->warp1.x - sz;
+   *(float *)&wv[1] = tmp->warp1.y + sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp->warp1.x - sz;
+   *(float *)&wv[1] = tmp->warp1.y - sz;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp->ui[j];
+}
+
+
+static __inline void mga_draw_line( mgaContextPtr mmesa,
+				  const mgaVertex *tmp0, 
+				  const mgaVertex *tmp1,
+				  float width )
+{
+   mgaUI32 vertsize = mmesa->vertsize;
+   mgaUI32 *wv = mgaAllocVertexDwords( mmesa, 6 * vertsize );
+   float dx, dy, ix, iy;
+   int j;
+
+   dx = tmp0->warp1.x - tmp1->warp1.x;
+   dy = tmp0->warp1.y - tmp1->warp1.y;
+
+   ix = width * .5; iy = 0;
+  
+   if ((ix<.5) && (ix>0.1)) ix = .5; /* I want to see lines with width
+                                        0.5 also */
+  
+   if (dx * dx > dy * dy) {
+      iy = ix; ix = 0;
+   }
+  
+   *(float *)&wv[0] = tmp0->warp1.x - ix;
+   *(float *)&wv[1] = tmp0->warp1.y - iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp0->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp1->warp1.x + ix;
+   *(float *)&wv[1] = tmp1->warp1.y + iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp1->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp0->warp1.x + ix;
+   *(float *)&wv[1] = tmp0->warp1.y + iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp0->ui[j];
+   wv += vertsize;
+	 
+   *(float *)&wv[0] = tmp0->warp1.x - ix;
+   *(float *)&wv[1] = tmp0->warp1.y - iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp0->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp1->warp1.x - ix;
+   *(float *)&wv[1] = tmp1->warp1.y - iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp1->ui[j];
+   wv += vertsize;
+
+   *(float *)&wv[0] = tmp1->warp1.x + ix;
+   *(float *)&wv[1] = tmp1->warp1.y + iy;
+   for (j = 2 ; j < vertsize ; j++) 
+      wv[j] = tmp1->ui[j];
+   wv += vertsize;
+}
+
+
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h b/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h
new file mode 100644
index 000000000..ac5a545d2
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h
@@ -0,0 +1,150 @@
+
+static __inline void TAG(triangle)( GLcontext *ctx, GLuint e0,
+				  GLuint e1, GLuint e2, GLuint pv )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint vertsize = mmesa->vertsize;
+   mgaUI32 *wv = mgaAllocVertexDwords( mmesa, 3 * vertsize);
+
+   struct vertex_buffer *VB = ctx->VB;
+   mgaVertexPtr mgaVB = MGA_DRIVER_DATA(VB)->verts;
+   const mgaVertex *v[3];
+   int i, j;
+
+#if (IND & MGA_OFFSET_BIT)
+   GLfloat offset = ctx->Polygon.OffsetUnits * 1.0/0x10000;
+#endif
+
+#if (IND & (MGA_FLAT_BIT|MGA_TWOSIDE_BIT))
+   mgaUI32 c[3];
+
+   c[2] = c[1] = c[0] = *(mgaUI32 *)&mgaVB[pv].warp2.color; 
+#endif
+
+   (void) VB;
+
+   v[0] = &mgaVB[e0];  
+   v[1] = &mgaVB[e1];  
+   v[2] = &mgaVB[e2];  
+
+
+#if (IND & (MGA_TWOSIDE_BIT|MGA_OFFSET_BIT)) 
+   {
+      GLfloat ex = v[0]->warp1.x - v[2]->warp1.x;
+      GLfloat ey = v[0]->warp1.y - v[2]->warp1.y;
+      GLfloat fx = v[1]->warp1.x - v[2]->warp1.x;
+      GLfloat fy = v[1]->warp1.y - v[2]->warp1.y;
+      GLfloat cc = ex*fy-ey*fx;
+	 
+#if (IND & MGA_TWOSIDE_BIT) 
+      {
+	 GLuint facing = (cc>0.0) ^ ctx->Polygon.FrontBit;
+	 GLubyte (*vbcolor)[4] = VB->Color[facing]->data;
+	 if (IND & MGA_FLAT_BIT) {
+	    MGA_COLOR((char *)&c[0],vbcolor[pv]);
+	    c[2] = c[1] = c[0];
+	 } else {
+	    MGA_COLOR((char *)&c[0],vbcolor[e0]);
+	    MGA_COLOR((char *)&c[1],vbcolor[e1]);
+	    MGA_COLOR((char *)&c[2],vbcolor[e2]);
+	 }
+      }
+#endif
+      
+#if (IND & MGA_OFFSET_BIT) 
+      {
+	 if (cc * cc > 1e-16) {
+	    GLfloat factor = ctx->Polygon.OffsetFactor;
+	    GLfloat ez = v[0]->warp1.z - v[2]->warp1.z;
+	    GLfloat fz = v[1]->warp1.z - v[2]->warp1.z;
+	    GLfloat a = ey*fz-ez*fy;
+	    GLfloat b = ez*fx-ex*fz;
+	    GLfloat ic = 1.0 / cc;
+	    GLfloat ac = a * ic;
+	    GLfloat bc = b * ic;
+	    if (ac<0.0F)  ac = -ac;
+	    if (bc<0.0F)  bc = -bc;
+	    offset += MAX2( ac, bc ) * factor;
+	 }
+      }
+#endif
+   }
+#endif  
+
+   mgaglx.c_triangles++;
+
+   for (j = 0 ; j < 3 ; j++, wv += vertsize) {
+
+      for (i = 0 ; i < vertsize ; i++)
+	 wv[i] = v[j]->ui[i];
+
+#if (IND & (MGA_FLAT_BIT|MGA_TWOSIDE_BIT))
+      wv[4] = c[j];		/* color is the fifth element... */
+#endif
+#if (IND & MGA_OFFSET_BIT)
+      *(float *)&wv[2] = v[j]->warp1.z + offset;
+#endif
+   }
+}
+
+
+
+static void TAG(quad)( GLcontext *ctx, GLuint v0,
+		       GLuint v1, GLuint v2, GLuint v3, 
+		       GLuint pv )
+{
+   TAG(triangle)( ctx, v0, v1, v3, pv );
+   TAG(triangle)( ctx, v1, v2, v3, pv );
+}
+
+
+#if ((IND & ~MGA_FLAT_BIT) == 0)
+
+static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   mgaVertexPtr mgaVB = MGA_DRIVER_DATA(ctx->VB)->verts;
+   float width = ctx->Line.Width;
+
+   if (IND & MGA_FLAT_BIT) {
+      mgaVertex tmp0 = mgaVB[v0];
+      mgaVertex tmp1 = mgaVB[v1];
+      *(int *)&tmp0.warp1.color = *(int *)&mgaVB[pv].warp1.color;
+      *(int *)&tmp1.warp1.color = *(int *)&mgaVB[pv].warp1.color;
+      mga_draw_line( mmesa, &tmp0, &tmp1, width );
+   }
+   else
+      mga_draw_line( mmesa, &mgaVB[v0], &mgaVB[v1], width );
+}
+
+
+static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   struct vertex_buffer *VB = ctx->VB;
+   mgaVertexPtr mgaVB = MGA_DRIVER_DATA(VB)->verts;
+   GLfloat sz = ctx->Point.Size * .5;
+   int i;
+
+   for(i=first;i<=last;i++) 
+      if(VB->ClipMask[i]==0) 
+	 mga_draw_point( mmesa, &mgaVB[i], sz );
+}
+
+#endif
+
+
+static void TAG(init)( void )
+{
+   tri_tab[IND] = TAG(triangle);
+   quad_tab[IND] = TAG(quad);
+
+#if ((IND & ~MGA_FLAT_BIT) == 0) 
+   line_tab[IND] = TAG(line);
+   points_tab[IND] = TAG(points);
+#endif
+}
+
+
+#undef IND
+#undef TAG
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgavb.c b/xc/lib/GL/mesa/src/drv/mga/mgavb.c
new file mode 100644
index 000000000..f78c542c8
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgavb.c
@@ -0,0 +1,493 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+ 
+#include "mgalib.h"
+#include "mgavb.h"
+#include "mgalog.h"
+#include "stages.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TEX0 {					\
+  v->warp2.tu0 = tc0[i][0];			\
+  v->warp2.tv0 = tc0[i][1];			\
+}
+
+#define TEX1 {					\
+  v->warp2.tu1 = tc1[i][0];			\
+  v->warp2.tv1 = tc1[i][1];			\
+}
+
+#define SPC {					\
+  GLubyte *spec = &(VB->Spec[0][i][0]);		\
+  v->warp2.specular.red = spec[0];		\
+  v->warp2.specular.green = spec[1];		\
+  v->warp2.specular.blue = spec[2];		\
+}
+
+#define FOG {					\
+  GLubyte *spec = &(VB->Spec[0][i][0]);		\
+  v->warp2.specular.alpha = spec[3];		\
+}
+
+#define COL {					\
+  GLubyte *col = &(VB->Color[0]->data[i][0]);	\
+  v->warp2.color.blue  = col[2];		\
+  v->warp2.color.green = col[1];		\
+  v->warp2.color.red   = col[0];		\
+  v->warp2.color.alpha = col[3];		\
+}
+
+/* The warp2 code we have doesn't seem to support projective texturing
+ * in the multitexture case.  (Would require another 1/w value for the
+ * second set of texcoords).  This may be a problem for the g400.  
+ */
+#define TEX0_4						\
+  if (VB->TexCoordPtr[0]->size == 4)			\
+  {							\
+     GLfloat (*tc)[4] = VB->TexCoordPtr[0]->data;	\
+     v = &(MGA_DRIVER_DATA(VB)->verts[start]);		\
+     mmesa->setupdone &= ~MGA_WIN_BIT;			\
+     for (i=start; i < end; i++, v++)	{		\
+        float oow = 1.0 / tc[i][3];			\
+	v->warp2.rhw *= tc[i][3];			\
+	v->warp2.tu0 *= oow;				\
+	v->warp2.tv0 *= oow;				\
+     }							\
+  }
+
+
+#define COORD							\
+      GLfloat *win = VB->Win.data[i];				\
+      v->warp2.rhw =               win[3];			\
+      v->warp2.z = (1.0/0x10000) * win[2];			\
+      v->warp2.x =                 win[0] + xoffset;		\
+      v->warp2.y =          -      win[1] + yoffset; 
+
+#define NOP
+
+
+
+
+#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog)		\
+static void name(struct vertex_buffer *VB, GLuint start, GLuint end)	\
+{									\
+   mgaContextPtr mmesa = MGA_CONTEXT( VB->ctx );                        \
+   mgaVertexPtr v;							\
+   GLfloat (*tc0)[4];							\
+   GLfloat (*tc1)[4];							\
+   GLfloat xoffset = 0.5 + mmesa->drawX;		\
+   GLfloat yoffset = mmesa->driDrawable->h - 0.5 + mmesa->drawY;	\
+   int i;								\
+   (void) xoffset; (void) yoffset;					\
+									\
+   gl_import_client_data( VB, VB->ctx->RenderFlags,			\
+			  (VB->ClipOrMask				\
+			   ? VEC_WRITABLE|VEC_GOOD_STRIDE		\
+			   : VEC_GOOD_STRIDE));				\
+									\
+   tc0 = VB->TexCoordPtr[mmesa->tmu_source[0]]->data;			\
+   tc1 = VB->TexCoordPtr[mmesa->tmu_source[1]]->data;			\
+									\
+   v = &(MGA_DRIVER_DATA(VB)->verts[start]);				\
+									\
+   if (VB->ClipOrMask == 0)						\
+      for (i=start; i < end; i++, v++) {				\
+	 win;								\
+	 col;								\
+	 tex0;								\
+	 tex1;								\
+	 spec;								\
+	 fog;								\
+      }									\
+   else									\
+      for (i=start; i < end; i++, v++) {				\
+	 if (VB->ClipMask[i] == 0) {					\
+	    win;							\
+	    tex0;							\
+	    tex1;							\
+	    spec;							\
+	    fog;							\
+	 }								\
+	    col;							\
+      }									\
+   tex0_4;								\
+}
+
+
+
+SETUPFUNC(rs_wt0,	COORD,NOP,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wt0t1,	COORD,NOP,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wft0,	COORD,NOP,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wft0t1,	COORD,NOP,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wg,	COORD,COL,NOP,NOP,NOP,NOP,NOP)
+SETUPFUNC(rs_wgs,	COORD,COL,NOP,NOP,NOP,SPC,NOP)
+SETUPFUNC(rs_wgt0,	COORD,COL,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wgt0t1,	COORD,COL,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_wgst0,	COORD,COL,TEX0,NOP,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_wgst0t1,	COORD,COL,TEX0,TEX1,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_wgf,	COORD,COL,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_wgfs,	COORD,COL,NOP,NOP,NOP,SPC,FOG)
+SETUPFUNC(rs_wgft0,	COORD,COL,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wgft0t1,	COORD,COL,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_wgfst0,	COORD,COL,TEX0,NOP,TEX0_4,SPC,FOG)
+SETUPFUNC(rs_wgfst0t1,	COORD,COL,TEX0,TEX1,TEX0_4,SPC,FOG)
+
+SETUPFUNC(rs_t0,	NOP,NOP,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_t0t1,	NOP,NOP,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_f,		NOP,NOP,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_ft0,	NOP,NOP,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_ft0t1,	NOP,NOP,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_g,		NOP,COL,NOP,NOP,NOP,NOP,NOP)
+SETUPFUNC(rs_gs,	NOP,COL,NOP,NOP,NOP,SPC,NOP)
+SETUPFUNC(rs_gt0,	NOP,COL,TEX0,NOP,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_gt0t1,	NOP,COL,TEX0,TEX1,TEX0_4,NOP,NOP)
+SETUPFUNC(rs_gst0,	NOP,COL,TEX0,NOP,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_gst0t1,	NOP,COL,TEX0,TEX1,TEX0_4,SPC,NOP)
+SETUPFUNC(rs_gf,	NOP,COL,NOP,NOP,NOP,NOP,FOG)
+SETUPFUNC(rs_gfs,	NOP,COL,NOP,NOP,NOP,SPC,FOG)
+SETUPFUNC(rs_gft0,	NOP,COL,TEX0,NOP,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_gft0t1,	NOP,COL,TEX0,TEX1,TEX0_4,NOP,FOG)
+SETUPFUNC(rs_gfst0,	NOP,COL,TEX0,NOP,TEX0_4,SPC,FOG)
+SETUPFUNC(rs_gfst0t1,	NOP,COL,TEX0,TEX1,TEX0_4,SPC,FOG)
+
+
+static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end)
+{
+  mgaError("mgaRasterSetup(): invalid combination\n");
+}
+
+typedef void (*setupFunc)(struct vertex_buffer *,GLuint,GLuint);
+
+static setupFunc setup_func[0x80];
+
+void mgaDDSetupInit( void )
+{
+   int i;
+
+   for (i = 0 ; i < 0x80 ; i++)
+      setup_func[i] = rs_invalid;
+   
+   /* Functions to build vert's from scratch */
+   setup_func[MGA_WIN_BIT|MGA_TEX0_BIT] = rs_wt0;
+   setup_func[MGA_WIN_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wt0t1;
+   setup_func[MGA_WIN_BIT|MGA_FOG_BIT|MGA_TEX0_BIT] = rs_wft0;
+   setup_func[MGA_WIN_BIT|MGA_FOG_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wft0t1;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT] = rs_wg;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_SPEC_BIT] = rs_wgs;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_TEX0_BIT] = rs_wgt0;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wgt0t1;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT] = rs_wgst0;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wgst0t1;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT] = rs_wgf;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT] = rs_wgfs;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT|MGA_TEX0_BIT] = rs_wgft0;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wgft0t1;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT] = rs_wgfst0;
+   setup_func[MGA_WIN_BIT|MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_wgfst0t1;
+
+   /* Repair functions */
+   setup_func[MGA_TEX0_BIT] = rs_t0;
+   setup_func[MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_t0t1;
+   setup_func[MGA_FOG_BIT] = rs_f;
+   setup_func[MGA_FOG_BIT|MGA_TEX0_BIT] = rs_ft0;
+   setup_func[MGA_FOG_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_ft0t1;
+   setup_func[MGA_RGBA_BIT] = rs_g;
+   setup_func[MGA_RGBA_BIT|MGA_SPEC_BIT] = rs_gs;
+   setup_func[MGA_RGBA_BIT|MGA_TEX0_BIT] = rs_gt0;
+   setup_func[MGA_RGBA_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_gt0t1;
+   setup_func[MGA_RGBA_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT] = rs_gst0;
+   setup_func[MGA_RGBA_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_gst0t1;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT] = rs_gf;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT] = rs_gfs;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT|MGA_TEX0_BIT] = rs_gft0;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_gft0t1;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT] = rs_gfst0;
+   setup_func[MGA_RGBA_BIT|MGA_FOG_BIT|MGA_SPEC_BIT|MGA_TEX0_BIT|MGA_TEX1_BIT] = rs_gfst0t1;
+
+}
+
+
+void mgaPrintSetupFlags(char *msg, GLuint flags )
+{
+   fprintf(stderr, "%s: %d %s%s%s%s%s%s%s\n",
+	   msg,
+	   (int)flags,
+	   (flags & MGA_WIN_BIT)      ? " xyzw," : "", 
+	   (flags & MGA_RGBA_BIT)     ? " rgba," : "",
+	   (flags & MGA_SPEC_BIT)     ? " spec," : "",
+	   (flags & MGA_FOG_BIT)      ? " fog," : "",
+	   (flags & MGA_TEX0_BIT)     ? " tex-0," : "",
+	   (flags & MGA_TEX1_BIT)     ? " tex-1," : "",
+	   (flags & MGA_ALPHA_BIT)    ? " alpha," : "");
+}
+
+
+
+
+void mgaChooseRasterSetupFunc(GLcontext *ctx)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int funcindex = (MGA_WIN_BIT | MGA_RGBA_BIT);
+
+   mmesa->vertsize = 8;
+   mmesa->tmu_source[0] = 0;
+   mmesa->tmu_source[1] = 1;
+   mmesa->tex_dest[0] = MGA_TEX0_BIT;
+   mmesa->tex_dest[1] = MGA_TEX1_BIT;
+   mmesa->multitex = 0;
+
+   if (ctx->Texture.Enabled & 0xf) {
+      if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE)
+	 funcindex &= ~MGA_RGBA_BIT;
+
+      funcindex |= MGA_TEX0_BIT;
+   }
+
+   if (ctx->Texture.Enabled & 0xf0) {     
+      if (ctx->Texture.Enabled & 0xf) {
+	 mmesa->multitex = 1;
+	 mmesa->vertsize = 10;
+	 funcindex |= MGA_TEX1_BIT;
+      } else {
+	 /* Just a funny way of doing single texturing 
+	  */
+	 mmesa->tmu_source[0] = 1;
+	 mmesa->tex_dest[1] = MGA_TEX0_BIT;
+
+	 if (ctx->Texture.Unit[1].EnvMode == GL_REPLACE)
+	    funcindex &= ~MGA_RGBA_BIT;
+
+	 funcindex |= MGA_TEX0_BIT;
+      }
+   }
+
+   if (ctx->Color.BlendEnabled)
+      funcindex |= MGA_ALPHA_BIT;
+
+   if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+      funcindex |= MGA_SPEC_BIT;
+
+   if (ctx->Fog.Enabled)
+      funcindex |= MGA_FOG_BIT;
+
+   if (0)
+      mgaPrintSetupFlags("xsmesa: full setup function", funcindex); 
+
+   mmesa->setupindex = funcindex;
+
+   /* Called by mesa's clip functons:
+    */
+   ctx->Driver.RasterSetup = setup_func[funcindex & ~MGA_ALPHA_BIT];
+}
+
+
+
+
+void mgaDDCheckPartialRasterSetup( GLcontext *ctx, struct gl_pipeline_stage *d )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLuint tmp = mmesa->setupdone;
+
+   d->type = 0;
+   mmesa->setupdone = 0;	/* cleared if we return */
+
+   if ((ctx->Array.Summary & VERT_OBJ_ANY) == 0)
+      return;
+
+   if (ctx->IndirectTriangles) 
+      return;
+
+   mmesa->setupdone = tmp;
+
+   /* disabled until we have a merge&render op */
+   /*     d->inputs = available; */
+   /*     d->outputs = VERT_RAST_SETUP_PART; */
+   /*     d->type = PIPE_PRECALC; */
+}
+
+
+/* Repair existing precalculated vertices with new data.
+ */
+void mgaDDPartialRasterSetup( struct vertex_buffer *VB )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( VB->ctx );
+   GLuint new = VB->pipeline->new_outputs;
+   GLuint available = VB->pipeline->outputs;
+   GLuint ind = 0;
+
+   if (new & VERT_WIN) {
+      new = available;
+      ind |= MGA_WIN_BIT | MGA_FOG_BIT;
+   }
+
+   if (new & VERT_RGBA)
+      ind |= MGA_RGBA_BIT | MGA_SPEC_BIT;
+
+   if (new & VERT_TEX0_ANY) 
+      ind |= MGA_TEX0_BIT;
+
+   if (new & VERT_TEX1_ANY)
+      ind |= mmesa->tex_dest[1];
+
+   if (new & VERT_FOG_COORD)
+      ind |= MGA_FOG_BIT;
+
+   mmesa->setupdone &= ~ind;
+   ind &= mmesa->setupindex;
+   mmesa->setupdone |= ind;
+
+   if (0)
+      mgaPrintSetupFlags("xsmesa: partial setup function", ind);
+
+   if (ind) 
+      setup_func[ind&~MGA_ALPHA_BIT]( VB, VB->Start, VB->Count );   
+}
+
+
+void mgaDDDoRasterSetup( struct vertex_buffer *VB )
+{
+   GLcontext *ctx = VB->ctx;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+
+   /* Can't lock, won't lock
+    */
+   REFRESH_DRAWABLE_INFO( mmesa );
+
+   if (VB->Type == VB_CVA_PRECALC) 
+      mgaDDPartialRasterSetup( VB );
+   else if (ctx->Driver.RasterSetup)
+      ctx->Driver.RasterSetup( VB, VB->CopyStart, VB->Count );
+}
+
+static void FatalError( char *s )
+{
+   fprintf(stderr, s);
+   exit(1);
+}
+
+
+
+void mgaDDResizeVB( struct vertex_buffer *VB, GLuint size )
+{
+   mgaVertexBufferPtr mvb = MGA_DRIVER_DATA(VB);
+
+   while (mvb->size < size)
+      mvb->size *= 2;
+
+   free( mvb->vert_store );
+   mvb->vert_store = malloc( sizeof(mgaVertex) * mvb->size + 31);
+   if (!mvb->vert_store) 
+      FatalError("mga-glx: out of memory !\n");
+
+   mvb->verts = (mgaVertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31);
+
+   gl_vector1ui_free( &mvb->clipped_elements );
+   gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 );   
+   if (!mvb->clipped_elements.start) 
+      FatalError("mga-glx: out of memory !\n");
+
+   free( VB->ClipMask );
+   VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size);
+   if (!VB->ClipMask) 
+      FatalError("mga-glx: out of memory !\n");
+
+   if (VB->Type == VB_IMMEDIATE) {
+      free( mvb->primitive );
+      free( mvb->next_primitive );
+      mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+      mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+      if (!mvb->primitive || !mvb->next_primitive)
+	 FatalError("mga-glx: out of memory!");
+   }
+}
+
+
+void mgaDDRegisterVB( struct vertex_buffer *VB )
+{
+   mgaVertexBufferPtr mvb;
+
+   mvb = (mgaVertexBufferPtr)calloc( 1, sizeof(*mvb) );
+
+   /* This looks like it allocates a lot of memory, but it basically
+    * just sets an upper limit on how much can be used - nothing like
+    * this amount will ever be turned into 'real' memory.
+    */
+   mvb->size = VB->Size * 5;
+   mvb->vert_store = malloc( sizeof(mgaVertex) * mvb->size + 31);
+   if (!mvb->vert_store) 
+      FatalError("mga-glx: out of memory !\n");
+   
+   mvb->verts = (mgaVertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31);
+
+   gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 );
+   if (!mvb->clipped_elements.start) 
+      FatalError("mga-glx: out of memory !\n");
+
+   free( VB->ClipMask );
+   VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size);
+   if (!VB->ClipMask) 
+      FatalError("mga-glx: out of memory !\n");
+
+   mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+   mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size );
+   if (!mvb->primitive || !mvb->next_primitive)
+      FatalError("mga-glx: out of memory!");
+   
+   VB->driver_data = mvb;
+}
+
+
+void mgaDDUnregisterVB( struct vertex_buffer *VB )
+{
+   mgaVertexBufferPtr mvb = MGA_DRIVER_DATA(VB);
+   
+   if (mvb) {
+      if (mvb->vert_store) free(mvb->vert_store);
+      if (mvb->primitive) free(mvb->primitive);
+      if (mvb->next_primitive) free(mvb->next_primitive);
+      gl_vector1ui_free( &mvb->clipped_elements );
+      free(mvb);
+      VB->driver_data = 0;
+   }      
+}
+
+
+mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords )
+{
+   int bytes = dwords * 4;
+   mgaUI32 *head;
+
+   if (mmesa->dma_buffer->used + bytes > mmesa->dma_buffer->total)
+      mgaFlushVertices( mmesa );
+
+   head = (mgaUI32 *)((char *)mmesa->dma_buffer->address + 
+		      mmesa->dma_buffer->used);
+
+   mmesa->dma_buffer->used += bytes;
+   return head;
+}
diff --git a/xc/lib/GL/mesa/src/drv/mga/mgavb.h b/xc/lib/GL/mesa/src/drv/mga/mgavb.h
new file mode 100644
index 000000000..8d7c65207
--- /dev/null
+++ b/xc/lib/GL/mesa/src/drv/mga/mgavb.h
@@ -0,0 +1,132 @@
+/*
+ * GLX Hardware Device Driver for Matrox Millenium G200
+ * Copyright (C) 1999 Wittawat Yamwong
+ *
+ * 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
+ * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
+ *
+ *
+ *    Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de>
+ */
+
+#ifndef MGAVB_INC
+#define MGAVB_INC
+
+#include "vb.h"
+#include "mgacommon.h"
+
+
+/* common datatypes for the mga warp engines */
+
+/* 
+ *  color type for the vertex data
+ *  we probably want to use an internal datatype here?
+ */
+typedef struct mga_warp_color_t {
+  GLubyte	blue;
+  GLubyte       green;
+  GLubyte       red;
+  GLubyte       alpha;
+} mga_warp_color;
+
+
+/* 
+ *  vertex type used for the single-warp g200
+ */
+typedef struct mga_warp_vertex_t {
+  GLfloat		x,y,z;	        /* coordinates in screen space*/
+  GLfloat 		rhw;	        /* reciprocal homogeneous w */
+  mga_warp_color	color;		/* vertex color */
+  mga_warp_color	specular;	/* specular color, alpha is fog */
+  GLfloat		tu0,tv0;	/* texture coordinates */
+} mga_warp_vertex1;
+
+/*
+ *  vertex type used for the dual-warp g400
+ */
+typedef struct mga_warp_vertex2_t {
+  GLfloat		x,y,z;	        /* coordinates in screen space*/
+  GLfloat 		rhw;	        /* reciprocal homogeneous w */
+  mga_warp_color	color;		/* vertex color */
+  mga_warp_color	specular;	/* specular color, alpha is fog */
+  GLfloat		tu0,tv0;	/* texture coordinates */
+  GLfloat		tu1,tv1;	/* same for second stage */
+} mga_warp_vertex2;
+
+
+/* The fastpath code still expects a 16-float stride vertex.
+ */
+union mga_vertex_t {
+   mga_warp_vertex1 warp1;	
+   mga_warp_vertex2 warp2;
+   float f[16];
+   mgaUI32 ui[16];
+};
+
+typedef union mga_vertex_t mgaVertex;
+typedef union mga_vertex_t *mgaVertexPtr;
+
+struct mga_vertex_buffer_t {
+   GLvector1ui clipped_elements;
+   mgaVertexPtr verts;
+   int last_vert;
+   GLuint *primitive;
+   GLuint *next_primitive;
+   void *vert_store;
+   GLuint size;
+
+   mgaUI32 *vert_buf;
+   mgaUI32 *elt_buf;
+   mgaUI32 vert_phys_start;
+};
+   
+typedef struct mga_vertex_buffer_t *mgaVertexBufferPtr;
+
+#define MGA_CONTEXT(ctx)    ((mgaContextPtr)((ctx)->DriverCtx))
+#define MGA_DRIVER_DATA(vb) ((mgaVertexBufferPtr)((vb)->driver_data))
+
+
+#define MGA_FOG_BIT	   MGA_F
+#define MGA_ALPHA_BIT      MGA_A
+#define MGA_SPEC_BIT       MGA_S
+#define MGA_TEX1_BIT       MGA_T2
+#define MGA_TEX0_BIT       0x10	    /* non-warp parameters */
+#define MGA_RGBA_BIT       0x20
+#define MGA_WIN_BIT        0x40
+
+struct gl_pipeline_stage;
+
+extern void mgaChooseRasterSetupFunc(GLcontext *ctx);
+extern void mgaPrintSetupFlags(char *msg, GLuint flags );
+extern void mgaDDDoRasterSetup( struct vertex_buffer *VB );
+extern void mgaDDPartialRasterSetup( struct vertex_buffer *VB );
+extern void mgaDDCheckPartialRasterSetup( GLcontext *ctx, 
+					  struct gl_pipeline_stage *d );
+
+
+extern void mgaDDUnregisterVB( struct vertex_buffer *VB );
+extern void mgaDDRegisterVB( struct vertex_buffer *VB );
+extern void mgaDDResizeVB( struct vertex_buffer *VB, GLuint size );
+
+extern void mgaDDSetupInit( void );
+
+
+extern mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords );
+
+
+#endif
diff --git a/xc/lib/GL/mesa/src/drv/tdfx/Imakefile b/xc/lib/GL/mesa/src/drv/tdfx/Imakefile
index dc940bab3..d221dc5cd 100644
--- a/xc/lib/GL/mesa/src/drv/tdfx/Imakefile
+++ b/xc/lib/GL/mesa/src/drv/tdfx/Imakefile
@@ -1,4 +1,5 @@
-XCOMM $PI:$
+
+#include <Threads.tmpl>
 
 #define DoNormalLib NormalLibGlx
 #define DoSharedLib SharedLibGlx
@@ -13,6 +14,7 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
 #if BuildXF86DRI
   DRI_DEFINES = GlxDefines -DFX -DFX_GLIDE3 -DGLIDE3 -DDRIVERTS
  DRI_INCLUDES = -I../../../../dri -I../../../../glx \
+		-I../../../dri \
 		-I$(TOP)/include -I$(TOP)/include/GL \
 		-I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \
 		-I$(XF86DRIVERSRC)/tdfx \
@@ -49,18 +51,230 @@ LinkSourceFile(fxvs_tmp.h, ../../../../../../extras/Mesa/src/FX)
 
       DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES)
      INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \
-		-I/usr/include/glide
-      DRISRCS = tdfx_xmesa.c tdfx_init.c tdfx_inithw.c
-      DRIOBJS = tdfx_xmesa.o tdfx_init.o tdfx_inithw.o
-     MESASRCS = fxclip.c fxcva.c fxdd.c fxddspan.c fxddtex.c fxfastpath.c \
+		-I/usr/include/glide3
+
+      DRISRCS = ../../../dri/dri_mesa.c \
+		../../../../dri/dri_tmm.c
+
+      DRIOBJS = ../../../dri/dri_mesa.o \
+		../../../../dri/dri_tmm.o
+
+      DRMSRCS = ../../../../dri/drm/xf86drm.c \
+		../../../../dri/drm/xf86drmHash.c \
+		../../../../dri/drm/xf86drmRandom.c \
+		../../../../dri/drm/xf86drmSL.c
+
+      DRMOBJS = ../../../../dri/drm/xf86drm.o \
+		../../../../dri/drm/xf86drmHash.o \
+		../../../../dri/drm/xf86drmRandom.o \
+		../../../../dri/drm/xf86drmSL.o
+
+     TDFXSRCS = tdfx_xmesa.c tdfx_init.c tdfx_inithw.c \
+		fxclip.c fxcva.c fxdd.c fxddspan.c fxddtex.c fxfastpath.c \
 		fxglidew.c fxpipeline.c fxrender.c fxsanity.c fxsetup.c \
 		fxtexman.c fxtrifuncs.c fxvsetup.c
-     MESAOBJS = fxclip.o fxcva.o fxdd.o fxddspan.o fxddtex.o fxfastpath.o \
+
+     TDFXOBJS = tdfx_xmesa.o tdfx_init.o tdfx_inithw.o \
+		fxclip.o fxcva.o fxdd.o fxddspan.o fxddtex.o fxfastpath.o \
 		fxglidew.o fxpipeline.o fxrender.o fxsanity.o fxsetup.o \
 		fxtexman.o fxtrifuncs.o fxvsetup.o
 
-	 SRCS = $(DRISRCS) $(MESASRCS)
-	 OBJS = $(DRIOBJS) $(MESAOBJS)
+     MESASRCS = ../../accum.c \
+		../../alpha.c \
+		../../alphabuf.c \
+		../../attrib.c \
+		../../bbox.c \
+		../../bitmap.c \
+		../../blend.c \
+		../../buffers.c \
+		../../clip.c \
+		../../colortab.c \
+		../../config.c \
+		../../context.c \
+		../../copypix.c \
+		../../cva.c \
+		../../debug_xform.c \
+		../../depth.c \
+		../../dlist.c \
+		../../drawpix.c \
+		../../enable.c \
+		../../enums.c \
+		../../eval.c \
+		../../extensions.c \
+		../../feedback.c \
+		../../fog.c \
+		../../get.c \
+		../../glapi.c \
+		../../glapinoop.c \
+		../../glthread.c \
+		../../hash.c \
+		../../image.c \
+		../../imaging.o \
+		../../light.c \
+		../../lines.c \
+		../../logic.c \
+		../../masking.c \
+		../../matrix.c \
+		../../mem.c \
+		../../mmath.c \
+		../../pb.c \
+		../../pipeline.c \
+		../../pixel.c \
+		../../points.c \
+		../../polygon.c \
+		../../quads.c \
+		../../rastpos.c \
+		../../readpix.c \
+		../../rect.c \
+		../../scissor.c \
+		../../shade.c \
+		../../span.c \
+		../../stages.c \
+		../../state.c \
+		../../stencil.c \
+		../../teximage.c \
+		../../texobj.c \
+		../../texstate.c \
+		../../texture.c \
+		../../translate.c \
+		../../triangle.c \
+		../../varray.c \
+		../../vb.c \
+		../../vbcull.c \
+		../../vbfill.c \
+		../../vbindirect.c \
+		../../vbrender.c \
+		../../vbxform.c \
+		../../vector.c \
+		../../vertices.c \
+		../../winpos.c \
+		../../xform.c \
+		../../zoom.c \
+		../../X86/common_x86.c
+
+     MESAOBJS = ../../accum.o \
+		../../alpha.o \
+		../../alphabuf.o \
+		../../attrib.o \
+		../../bbox.o \
+		../../bitmap.o \
+		../../blend.o \
+		../../buffers.o \
+		../../clip.o \
+		../../colortab.o \
+		../../config.o \
+		../../context.o \
+		../../copypix.o \
+		../../cva.o \
+		../../debug_xform.o \
+		../../depth.o \
+		../../dlist.o \
+		../../drawpix.o \
+		../../enable.o \
+		../../enums.o \
+		../../eval.o \
+		../../extensions.o \
+		../../feedback.o \
+		../../fog.o \
+		../../get.o \
+		../../hash.o \
+		../../hint.o \
+		../../image.o \
+		../../imaging.o \
+		../../light.o \
+		../../lines.o \
+		../../logic.o \
+		../../masking.o \
+		../../matrix.o \
+		../../mem.o \
+		../../mmath.o \
+		../../pb.o \
+		../../pipeline.o \
+		../../pixel.o \
+		../../points.o \
+		../../polygon.o \
+		../../quads.o \
+		../../rastpos.o \
+		../../readpix.o \
+		../../rect.o \
+		../../scissor.o \
+		../../shade.o \
+		../../span.o \
+		../../stages.o \
+		../../state.o \
+		../../stencil.o \
+		../../teximage.o \
+		../../texobj.o \
+		../../texstate.o \
+		../../texture.o \
+		../../translate.o \
+		../../triangle.o \
+		../../varray.o \
+		../../vb.o \
+		../../vbcull.o \
+		../../vbfill.o \
+		../../vbindirect.o \
+		../../vbrender.o \
+		../../vbxform.o \
+		../../vector.o \
+		../../vertices.o \
+		../../winpos.o \
+		../../xform.o \
+		../../zoom.o
+
+#ifdef i386Architecture
+     X86_SRCS = ../../X86/x86.c \
+		../../X86/x86a.S \
+		../../X86/common_x86.c \
+		../../X86/common_x86asm.S \
+		../../X86/vertex.S
+
+     X86_OBJS = ../../X86/x86.o \
+		../../X86/x86a.o \
+		../../X86/common_x86.o \
+		../../X86/common_x86asm.o \
+		../../X86/vertex.o
+
+     MMX_SRCS = ../../X86/mmx_blend.S
+
+     MMX_OBJS = ../../X86/mmx_blend.o
+
+XCOMM Disabling 3Dnow code for the time being.
+#if 0
+   3DNOW_SRCS = ../../X86/3dnow.c \
+		../../X86/3dnow_norm_raw.S \
+		../../X86/3dnow_xform_masked1.S \
+		../../X86/3dnow_xform_masked2.S \
+		../../X86/3dnow_xform_masked3.S \
+		../../X86/3dnow_xform_masked4.S \
+		../../X86/3dnow_xform_raw1.S \
+		../../X86/3dnow_xform_raw2.S \
+		../../X86/3dnow_xform_raw3.S \
+		../../X86/3dnow_xform_raw4.S \
+		../../X86/vertex_3dnow.S
+
+   3DNOW_OBJS = ../../X86/3dnow.o \
+		../../X86/3dnow_norm_raw.o \
+		../../X86/3dnow_xform_masked1.o \
+		../../X86/3dnow_xform_masked2.o \
+		../../X86/3dnow_xform_masked3.o \
+		../../X86/3dnow_xform_masked4.o \
+		../../X86/3dnow_xform_raw1.o \
+		../../X86/3dnow_xform_raw2.o \
+		../../X86/3dnow_xform_raw3.o \
+		../../X86/3dnow_xform_raw4.o \
+		../../X86/vertex_3dnow.o
+#endif
+
+#endif
+
+      ASMSRCS = $(X86_SRCS) $(MMX_SRCS) $(3DNOW_SRCS)
+      ASMOBJS = $(X86_OBJS) $(MMX_OBJS) $(3DNOW_OBJS)
+
+	 SRCS = $(DRISRCS) $(DRMSRCS) $(TDFXSRCS) $(MESASRCS) $(ASMSRCS)
+	 OBJS = $(DRIOBJS) $(DRMOBJS) $(TDFXOBJS) $(MESAOBJS) $(ASMOBJS)
+
+REQUIREDLIBS += -lglide3x
 
 #if !GlxUseBuiltInDRIDriver
 #undef DoNormalLib NormalLibGlx
@@ -81,7 +295,7 @@ LIBNAME = tdfx_dri.so
 ALL_OBJS = $(OBJS)
 ALL_DEPS = DONE
 SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS))
-InstallDynamicModule($(LIBNAME),$(MODULEDIR),.)
+InstallDynamicModule($(LIBNAME),$(MODULEDIR)/dri,.)
 #endif
 
 DependTarget()
diff --git a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.c b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.c
index eb505b8a3..3fc44b59d 100644
--- a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.c
+++ b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.c
@@ -57,8 +57,8 @@ static void performMagic(__DRIscreenPrivate *driScrnPriv)
     gPriv->mem=gDRIPriv->mem;
     gPriv->cpp=gDRIPriv->cpp;
     gPriv->stride=gDRIPriv->stride;
-    gPriv->fifoOffset=gDRIPriv->priv1;
-    gPriv->fifoSize=gDRIPriv->priv2;
+    gPriv->fifoOffset=gDRIPriv->fifoOffset;
+    gPriv->fifoSize=gDRIPriv->fifoSize;
     gPriv->fbOffset=gDRIPriv->fbOffset;
     gPriv->backOffset=gDRIPriv->backOffset;
     gPriv->depthOffset=gDRIPriv->depthOffset;
diff --git a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.h b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.h
index f0b3f4131..ead84e61a 100644
--- a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.h
+++ b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_init.h
@@ -71,8 +71,8 @@ typedef struct {
 } tdfxScreenPrivate;
 
 typedef struct {
-  volatile int *fifoPtr;
-  volatile int *fifoRead;
+  volatile int fifoPtr;
+  volatile int fifoRead;
   volatile int fifoOwner;
   volatile int ctxOwner;
   volatile int texOwner;
@@ -123,8 +123,7 @@ extern void grDRIResetSAREA(void);
 extern XMesaContext gCC;
 extern tdfxContextPrivate *gCCPriv;
 
-/* 
-You can turn this on to find locking conflicts.
+/* You can turn this on to find locking conflicts.
 #define DEBUG_LOCKING 
 */
 
@@ -168,18 +167,20 @@ extern int prevLockLine;
 /* Lock the hardware using the global current context */
 #define LOCK_HARDWARE() \
   do { \
-    int stamp; \
     char __ret=0; \
     __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv; \
     __DRIscreenPrivate *sPriv = dPriv->driScreenPriv; \
     DEBUG_CHECK_LOCK(); \
-    DRM_LIGHT_LOCK_RETURN(sPriv->fd, &sPriv->pSAREA->lock, \
-		   dPriv->driContextPriv->hHWContext, __ret); \
-    if (__ret) __ret=1; \
-    stamp=dPriv->lastStamp; \
-    XMESA_VALIDATE_DRAWABLE_INFO(gCC->display, sPriv, dPriv); \
-    if (*(dPriv->pStamp)!=stamp) __ret=2; \
-    if (__ret) XMesaUpdateState(__ret==2); \
+    DRM_CAS(&sPriv->pSAREA->lock, dPriv->driContextPriv->hHWContext, \
+	    DRM_LOCK_HELD|dPriv->driContextPriv->hHWContext, __ret); \
+    if (__ret) { \
+        int stamp; \
+	drmGetLock(sPriv->fd, dPriv->driContextPriv->hHWContext, 0); \
+        stamp=dPriv->lastStamp; \
+        XMESA_VALIDATE_DRAWABLE_INFO(gCC->display, sPriv, dPriv); \
+        if (*(dPriv->pStamp)!=stamp) XMesaUpdateState(GL_TRUE); \
+	else XMesaUpdateState(GL_FALSE); \
+    } \
     DEBUG_LOCK(); \
   } while (0)
 
@@ -205,8 +206,9 @@ extern int prevLockLine;
 #define BEGIN_CLIP_LOOP()	\
   do {				\
     __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv; \
-    int _nc = dPriv->numClipRects; \
+    int _nc; \
     LOCK_HARDWARE(); \
+    _nc = dPriv->numClipRects; \
     while (_nc--) { \
       if (gCCPriv->needClip) { \
         gCCPriv->clipMinX=dPriv->pClipRects[_nc].x1; \
diff --git a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_inithw.c b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_inithw.c
index 065d33338..7b08f9766 100644
--- a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_inithw.c
+++ b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_inithw.c
@@ -94,6 +94,8 @@ GLboolean tdfxInitHW(XMesaContext c)
   if (!fxMesa->glideContext || !fxDDInitFxMesaContext( fxMesa ))
     return GL_FALSE;
 
+  fxInitPixelTables(fxMesa, GL_FALSE); /* Load tables of pixel colors */
+
   cPriv->initDone=GL_TRUE;
   return GL_TRUE;
 
diff --git a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c
index dca2d806d..38772c95d 100644
--- a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c
+++ b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c
@@ -172,7 +172,13 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list,
   c->private = (void *)cPriv;
 
   cPriv->glVis=v->gl_visual;
-  cPriv->glBuffer=gl_create_framebuffer(v->gl_visual);
+  cPriv->glBuffer=gl_create_framebuffer(v->gl_visual,
+                                        GL_FALSE,  /* software depth buffer? */
+                                        v->gl_visual->StencilBits > 0,
+                                        v->gl_visual->AccumBits > 0,
+                                        v->gl_visual->AlphaBits > 0
+                                        );
+
   cPriv->screen_width=sPriv->width;
   cPriv->screen_height=sPriv->height;
 
@@ -204,6 +210,10 @@ void XMesaDestroyContext(XMesaContext c)
     gl_destroy_context(cPriv->glCtx);
     gl_destroy_framebuffer(cPriv->glBuffer);
   }
+  if (c==gCC) {
+    gCC=0;
+    gCCPriv=0;
+  }
 }
 
 XMesaBuffer XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w,
@@ -225,6 +235,11 @@ void XMesaDestroyBuffer(XMesaBuffer b)
 void XMesaSwapBuffers(XMesaBuffer b)
 {
   FxI32 result;
+#ifdef STATS
+  int stalls;
+  extern int texSwaps;
+  static int prevStalls=0;
+#endif
   /*
   ** NOT_DONE: This assumes buffer is currently bound to a context.
   ** This needs to be able to swap buffers when not currently bound.
@@ -234,6 +249,17 @@ void XMesaSwapBuffers(XMesaBuffer b)
   FLUSH_VB( gCCPriv->glCtx, "swap buffers" );
 
   if (gCCPriv->haveDoubleBuffer) {
+#ifdef STATS
+    stalls=grFifoGetStalls();
+    if (stalls!=prevStalls) {
+      fprintf(stderr, "%d stalls occurred\n", stalls-prevStalls);
+      prevStalls=stalls;
+    }
+    if (texSwaps) {
+      fprintf(stderr, "%d texture swaps occurred\n", texSwaps);
+      texSwaps=0;
+    }
+#endif
     FX_grDRIBufferSwap(gCCPriv->swapInterval);
     do {
       result=FX_grGetInteger(FX_PENDING_BUFFERSWAPS);
@@ -244,29 +270,33 @@ void XMesaSwapBuffers(XMesaBuffer b)
   }
 }
 
+GLboolean XMesaUnbindContext(XMesaContext c)
+{
+  if (c && c==gCC && gCCPriv) FX_grGlideGetState((GrState*)gCCPriv->state);
+  return GL_TRUE;
+}
+
 GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b)
 {
   __DRIdrawablePrivate *driDrawPriv;
 
   if (c) {
     if (c==gCC) return GL_TRUE;
-    if (gCCPriv) FX_grGlideGetState((GrState*)gCCPriv->state);
     gCC     = c;
     gCCPriv = (tdfxContextPrivate *)c->private;
 
-    fprintf(stderr, "Make current\n");
     driDrawPriv = gCC->driContextPriv->driDrawablePriv;
     if (!gCCPriv->initDone) {
-      gCCPriv->width=driDrawPriv->w;
-      gCCPriv->height=driDrawPriv->h;
       if (!tdfxInitHW(c)) return GL_FALSE;
-      /* Zap the width to force XMesaWindowMoved to execute */
       gCCPriv->width=0;
+      XMesaWindowMoved();
+      FX_grGlideGetState((GrState*)gCCPriv->state);
+    } else {
+      FX_grSstSelect(gCCPriv->board);
+      FX_grGlideSetState((GrState*)gCCPriv->state);
+      XMesaWindowMoved();
     }
-    FX_grSstSelect(gCCPriv->board);
-    XMesaWindowMoved();
 
-    FX_grGlideSetState((GrState*)gCCPriv->state);
     gl_make_current(gCCPriv->glCtx, gCCPriv->glBuffer);
     fxSetupDDPointers(gCCPriv->glCtx);
     if (!gCCPriv->glCtx->Viewport.Width)
@@ -319,6 +349,7 @@ XMesaWindowMoved() {
   }
 }
 
+/* This is called from within the LOCK_HARDWARE routine */
 void XMesaUpdateState(int windowMoved) {
   __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv;
   __DRIscreenPrivate *sPriv = dPriv->driScreenPriv;
@@ -329,12 +360,18 @@ void XMesaUpdateState(int windowMoved) {
     grDRIImportFifo(saPriv->fifoPtr, saPriv->fifoRead);
   }
   if (saPriv->ctxOwner!=dPriv->driContextPriv->hHWContext) {
-    grDRIInvalidateAll();
-    /* This shouldn't be needed if the state is reset by Glide */
-    /* FX_grConstantColorValue_NoLock(FXCOLOR4(&gCCPriv->constColor)); */
+    /* This sequence looks a little odd. Glide mirrors the state, and
+       when you get the state you are forcing the mirror to be up to
+       date, and then getting a copy from the mirror. You can then force
+       that state onto the hardware when you set the state. */
+    void *state;
+    state=malloc(FX_grGetInteger_NoLock(FX_GLIDE_STATE_SIZE));
+    FX_grGlideGetState_NoLock(state);
+    FX_grGlideSetState_NoLock(state);
+    free(state);
   }
   if (saPriv->texOwner!=dPriv->driContextPriv->hHWContext) {
-    fxTMRestoreTextures(gCCPriv);
+    fxTMRestoreTextures_NoLock(gCCPriv);
   }
   if (windowMoved)
     XMesaWindowMoved();
@@ -352,4 +389,20 @@ void XMesaSetSAREA() {
   /* fprintf(stderr, "Out FifoPtr=%d FifoRead=%d\n", saPriv->fifoPtr, saPriv->fifoRead); */
 }
 
+
+extern void _register_gl_extensions(void); /* silence compiler warning */
+
+void _register_gl_extensions(void)
+{
+   /* Here is where the 3Dfx driver would register new extensions
+    * with libGL.so.
+    * This function is called as soon as the driver object is dlopened.
+    */
+#if 0
+   /* really, the return code should be checked */
+   _glapi_add_entrypoint("glFooBarEXT", _gloffset_FooBarEXT);
+#endif
+}
+
+
 #endif