Merge remote-tracking branch 'origin/released'

Conflicts:
	xorg-server/Xext/shm.c
	xorg-server/Xext/sync.c
	xorg-server/Xext/xf86bigfont.c
	xorg-server/Xi/opendev.c
	xorg-server/dix/dispatch.c
	xorg-server/include/globals.h
	xorg-server/mi/miinitext.c

101 files changed, 2750 insertions, 27269 deletions

diff --git a/xorg-server/hw/xfree86/Makefile.am b/xorg-server/hw/xfree86/Makefile.am
index 4d5d576a3..c3899b577 100644
--- a/xorg-server/hw/xfree86/Makefile.am
+++ b/xorg-server/hw/xfree86/Makefile.am
@@ -1,18 +1,18 @@
 
 if DRI
 DRI_SUBDIR = dri
+DRI_LIB = dri/libdri.la
 endif
 
 if DRI2
 DRI2_SUBDIR = dri2
+DRI2_LIB = dri2/libdri2.la
 endif
 
 if XF86UTILS
 XF86UTILS_SUBDIR = utils
 endif
 
-XAA_SUBDIR = xaa
-
 if VGAHW
 VGAHW_SUBDIR = vgahw
 endif
@@ -26,12 +26,12 @@ INT10_SUBDIR = int10
 endif
 
 SUBDIRS = common ddc x86emu $(INT10_SUBDIR) os-support parser \
-	  ramdac $(VGAHW_SUBDIR) loader modes . $(VBE_SUBDIR) \
-	  $(XAA_SUBDIR) $(DRI_SUBDIR) $(DRI2_SUBDIR) i2c dixmods \
+	  ramdac $(VGAHW_SUBDIR) loader modes $(DRI_SUBDIR) \
+	  $(DRI2_SUBDIR) . $(VBE_SUBDIR) i2c dixmods \
 	  fbdevhw shadowfb exa $(XF86UTILS_SUBDIR) doc man
 
 DIST_SUBDIRS = common ddc i2c x86emu int10 fbdevhw os-support \
-               parser ramdac shadowfb vbe vgahw xaa \
+               parser ramdac shadowfb vbe vgahw \
                loader dixmods dri dri2 exa modes \
 	       utils doc man
 
@@ -40,7 +40,8 @@ nodist_Xorg_SOURCES = sdksyms.c
 
 AM_CFLAGS = $(DIX_CFLAGS) @XORG_CFLAGS@
 INCLUDES = $(XORG_INCS) -I$(srcdir)/parser -I$(top_srcdir)/miext/cw \
-	-I$(srcdir)/ddc -I$(srcdir)/i2c -I$(srcdir)/modes -I$(srcdir)/ramdac
+	-I$(srcdir)/ddc -I$(srcdir)/i2c -I$(srcdir)/modes -I$(srcdir)/ramdac \
+	-I$(srcdir)/dri -I$(srcdir)/dri2
 
 LOCAL_LIBS = \
             $(MAIN_LIB) \
@@ -54,8 +55,10 @@ LOCAL_LIBS = \
             ramdac/libramdac.la \
             ddc/libddc.la \
             i2c/libi2c.la \
-            dixmods/libxorgxkb.la \
             $(XORG_LIBS) \
+            dixmods/libxorgxkb.la \
+            $(DRI_LIB) \
+            $(DRI2_LIB) \
             $(top_builddir)/mi/libmi.la \
             $(top_builddir)/os/libos.la
 Xorg_LDADD = \
diff --git a/xorg-server/hw/xfree86/common/Makefile.am b/xorg-server/hw/xfree86/common/Makefile.am
index 65d98e694..f8fcde956 100644
--- a/xorg-server/hw/xfree86/common/Makefile.am
+++ b/xorg-server/hw/xfree86/common/Makefile.am
@@ -20,6 +20,7 @@ endif
 
 if DGA
 DGASOURCES = xf86DGA.c
+DGA_SDK = dgaproc.h
 endif
 
 if XORG_BUS_PLATFORM
@@ -45,7 +46,8 @@ libcommon_la_SOURCES = xf86Configure.c xf86Bus.c xf86Config.c \
                       xf86Option.c xf86Init.c \
                       xf86VidMode.c xf86fbman.c xf86cmap.c \
                       xf86Helper.c xf86PM.c xf86Xinput.c xisb.c \
-                      xf86Mode.c xorgHelper.c \
+                      xf86Mode.c xorgHelper.c xf86Extensions.h \
+		      xf86Extensions.c xf86vmode.c \
                       $(XVSOURCES) $(BUSSOURCES) $(RANDRSOURCES)
 nodist_libcommon_la_SOURCES = xf86DefModeSet.c xf86Build.h
 libcommon_la_LIBADD = $(top_builddir)/config/libconfig.la
@@ -54,13 +56,14 @@ INCLUDES = $(XORG_INCS) -I$(srcdir)/../ddc -I$(srcdir)/../i2c \
 	   -I$(srcdir)/../loader -I$(srcdir)/../parser \
            -I$(srcdir)/../vbe -I$(srcdir)/../int10 \
 	   -I$(srcdir)/../vgahw -I$(srcdir)/../dixmods/extmod \
-	   -I$(srcdir)/../modes -I$(srcdir)/../ramdac
+	   -I$(srcdir)/../modes -I$(srcdir)/../ramdac -I$(srcdir)/../dri2
 
 sdk_HEADERS = compiler.h fourcc.h xf86.h xf86Module.h xf86Opt.h \
               xf86PciInfo.h xf86Priv.h xf86Privstr.h \
               xf86cmap.h xf86fbman.h xf86str.h xf86Xinput.h xisb.h \
-              $(XVSDKINCS) $(XF86VMODE_SDK) xorgVersion.h \
-              xf86sbusBus.h xf86VGAarbiter.h xf86Optionstr.h xf86platformBus.h
+              $(XVSDKINCS) $(XF86VMODE_SDK) $(DGA_SDK) xorgVersion.h \
+              xf86sbusBus.h xf86VGAarbiter.h xf86Optionstr.h xf86platformBus.h \
+	      xaarop.h
 
 DISTCLEANFILES = xf86Build.h
 CLEANFILES = $(BUILT_SOURCES)
@@ -92,7 +95,8 @@ EXTRA_DIST = \
 	modeline2c.awk \
 	xf86VGAarbiter.h \
 	xf86VGAarbiterPriv.h \
-        $(DISTKBDSOURCES)
+        $(DISTKBDSOURCES) \
+	xaarop.h
 
 if LNXACPI
 XORG_CFLAGS += -DHAVE_ACPI
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/dgaproc.h b/xorg-server/hw/xfree86/common/dgaproc.h
index b4e0ddfea..e824d3094 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/dgaproc.h
+++ b/xorg-server/hw/xfree86/common/dgaproc.h
@@ -64,6 +64,7 @@ extern _X_EXPORT void
  DGASelectInput(int Index, ClientPtr client, long mask);
 
 extern _X_EXPORT Bool DGAAvailable(int Index);
+extern _X_EXPORT Bool DGAScreenAvailable(ScreenPtr pScreen);
 extern _X_EXPORT Bool DGAActive(int Index);
 extern _X_EXPORT void DGAShutdown(void);
 extern _X_EXPORT void DGAInstallCmap(ColormapPtr cmap);
@@ -106,9 +107,4 @@ extern _X_EXPORT Bool DGAChangePixmapMode(int Index, int *x, int *y, int mode);
 extern _X_EXPORT int DGACreateColormap(int Index, ClientPtr client, int id,
                                        int mode, int alloc);
 
-extern _X_EXPORT unsigned char DGAReqCode;
-extern _X_EXPORT int DGAErrorBase;
-extern _X_EXPORT int DGAEventBase;
-extern _X_EXPORT int *XDGAEventBase;
-
 #endif                          /* __DGAPROC_H */
diff --git a/xorg-server/hw/xfree86/common/vidmodeproc.h b/xorg-server/hw/xfree86/common/vidmodeproc.h
index aa43237d4..311d35c7b 100644
--- a/xorg-server/hw/xfree86/common/vidmodeproc.h
+++ b/xorg-server/hw/xfree86/common/vidmodeproc.h
@@ -39,7 +39,7 @@ typedef union {
     float f;
 } vidMonitorValue;
 
-extern _X_EXPORT void XFree86VidModeExtensionInit(void);
+extern Bool VidModeExtensionInit(ScreenPtr pScreen);
 
 extern _X_EXPORT Bool VidModeAvailable(int scrnIndex);
 extern _X_EXPORT Bool VidModeGetCurrentModeline(int scrnIndex, pointer *mode,
diff --git a/xorg-server/hw/xfree86/xaa/xaarop.h b/xorg-server/hw/xfree86/common/xaarop.h
index f2acde075..f2acde075 100644
--- a/xorg-server/hw/xfree86/xaa/xaarop.h
+++ b/xorg-server/hw/xfree86/common/xaarop.h
diff --git a/xorg-server/hw/xfree86/common/xf86.h b/xorg-server/hw/xfree86/common/xf86.h
index 61169857f..8dc7dcccf 100644
--- a/xorg-server/hw/xfree86/common/xf86.h
+++ b/xorg-server/hw/xfree86/common/xf86.h
@@ -449,10 +449,8 @@ xf86RandRSetNewVirtualAndDimensions(ScreenPtr pScreen,
                                     Bool resetMode);
 #endif
 
-/* xf86VidModeExtentionInit.c */
-
-extern _X_EXPORT Bool
-VidModeExtensionInit(ScreenPtr pScreen);
+/* xf86Extensions.c */
+extern void xf86ExtensionInit(void);
 
 /* convert ScreenPtr to ScrnInfoPtr */
 extern _X_EXPORT ScrnInfoPtr xf86ScreenToScrn(ScreenPtr pScreen);
diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index 6b806a372..486752b07 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -109,22 +109,9 @@
 #endif
 
 static ModuleDefault ModuleDefaults[] = {
-    {.name = "extmod",.toLoad = TRUE,.load_opt = NULL},
-#ifdef DBE
-    {.name = "dbe",.toLoad = TRUE,.load_opt = NULL},
-#endif
 #ifdef GLXEXT
     {.name = "glx",.toLoad = TRUE,.load_opt = NULL},
 #endif
-#ifdef XRECORD
-    {.name = "record",.toLoad = TRUE,.load_opt = NULL},
-#endif
-#ifdef XF86DRI
-    {.name = "dri",.toLoad = TRUE,.load_opt = NULL},
-#endif
-#ifdef DRI2
-    {.name = "dri2",.toLoad = TRUE,.load_opt = NULL},
-#endif
 #ifdef __CYGWIN__
     /* load DIX modules used by drivers first */
     {.name = "fb",.toLoad = TRUE,.load_opt = NULL},
diff --git a/xorg-server/hw/xfree86/common/xf86DGA.c b/xorg-server/hw/xfree86/common/xf86DGA.c
index 64163721f..a441dee99 100644
--- a/xorg-server/hw/xfree86/common/xf86DGA.c
+++ b/xorg-server/hw/xfree86/common/xf86DGA.c
@@ -1,4 +1,6 @@
 /*
+ * Copyright (c) 1995  Jon Tombs
+ * Copyright (c) 1995, 1996, 1999  XFree86 Inc
  * Copyright (c) 1998-2002 by The XFree86 Project, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -27,10 +29,20 @@
  * Written by Mark Vojkovich
  */
 
+/*
+ * This is quite literally just two files glued together:
+ * hw/xfree86/common/xf86DGA.c is the first part, and
+ * hw/xfree86/dixmods/extmod/xf86dga2.c is the second part.  One day, if
+ * someone actually cares about DGA, it'd be nice to clean this up.  But trust
+ * me, I am not that person.
+ */
+
 #ifdef HAVE_XORG_CONFIG_H
 #include <xorg-config.h>
 #endif
 
+#include <X11/X.h>
+#include <X11/Xproto.h>
 #include "xf86.h"
 #include "xf86str.h"
 #include "xf86Priv.h"
@@ -48,9 +60,24 @@
 #include "exevents.h"
 #include "eventstr.h"
 #include "eventconvert.h"
+#include "xf86Extensions.h"
 
 #include "mi.h"
 
+#include "misc.h"
+#include "dixstruct.h"
+#include "dixevents.h"
+#include "extnsionst.h"
+#include "cursorstr.h"
+#include "scrnintstr.h"
+#include "swaprep.h"
+#include "dgaproc.h"
+#include "protocol-versions.h"
+
+#include <string.h>
+
+#define DGA_PROTOCOL_OLD_SUPPORT 1
+
 static DevPrivateKeyRec DGAScreenKeyRec;
 
 #define DGAScreenKeyRegistered dixPrivateKeyRegistered(&DGAScreenKeyRec)
@@ -66,7 +93,9 @@ static void DGAHandleEvent(int screen_num, InternalEvent *event,
 static void
  DGACopyModeInfo(DGAModePtr mode, XDGAModePtr xmode);
 
-int *XDGAEventBase = NULL;
+static unsigned char DGAReqCode = 0;
+static int DGAErrorBase;
+static int DGAEventBase;
 
 #define DGA_GET_SCREEN_PRIV(pScreen) ((DGAScreenPtr) \
     dixLookupPrivate(&(pScreen)->devPrivates, &DGAScreenKeyRec))
@@ -521,18 +550,27 @@ DGAChangePixmapMode(int index, int *x, int *y, int mode)
 }
 
 Bool
-DGAAvailable(int index)
+DGAScreenAvailable(ScreenPtr pScreen)
 {
     if (!DGAScreenKeyRegistered)
         return FALSE;
 
-    if (DGA_GET_SCREEN_PRIV(screenInfo.screens[index]))
+    if (DGA_GET_SCREEN_PRIV(pScreen))
         return TRUE;
-
     return FALSE;
 }
 
 Bool
+DGAAvailable(int index)
+{
+    ScreenPtr pScreen;
+
+    assert(index < MAXSCREENS);
+    pScreen = screenInfo.screens[index];
+    return DGAScreenAvailable(pScreen);
+}
+
+Bool
 DGAActive(int index)
 {
     DGAScreenPtr pScreenPriv;
@@ -891,15 +929,16 @@ DGAStealKeyEvent(DeviceIntPtr dev, int index, int key_code, int is_down)
     if (!pScreenPriv || !pScreenPriv->grabKeyboard)     /* no direct mode */
         return FALSE;
 
-    memset(&event, 0, sizeof(event));
-    event.header = ET_Internal;
-    event.type = ET_DGAEvent;
-    event.length = sizeof(event);
-    event.time = GetTimeInMillis();
-    event.subtype = (is_down ? ET_KeyPress : ET_KeyRelease);
-    event.detail = key_code;
-    event.dx = 0;
-    event.dy = 0;
+    event = (DGAEvent) {
+        .header = ET_Internal,
+        .type = ET_DGAEvent,
+        .length = sizeof(event),
+        .time = GetTimeInMillis(),
+        .subtype = (is_down ? ET_KeyPress : ET_KeyRelease),
+        .detail = key_code,
+        .dx = 0,
+        .dy = 0
+    };
     mieqEnqueue(dev, (InternalEvent *) &event);
 
     return TRUE;
@@ -919,15 +958,16 @@ DGAStealMotionEvent(DeviceIntPtr dev, int index, int dx, int dy)
     if (!pScreenPriv || !pScreenPriv->grabMouse)        /* no direct mode */
         return FALSE;
 
-    memset(&event, 0, sizeof(event));
-    event.header = ET_Internal;
-    event.type = ET_DGAEvent;
-    event.length = sizeof(event);
-    event.time = GetTimeInMillis();
-    event.subtype = ET_Motion;
-    event.detail = 0;
-    event.dx = dx;
-    event.dy = dy;
+    event = (DGAEvent) {
+        .header = ET_Internal,
+        .type = ET_DGAEvent,
+        .length = sizeof(event),
+        .time = GetTimeInMillis(),
+        .subtype = ET_Motion,
+        .detail = 0,
+        .dx = dx,
+        .dy = dy
+    };
     mieqEnqueue(dev, (InternalEvent *) &event);
     return TRUE;
 }
@@ -946,15 +986,16 @@ DGAStealButtonEvent(DeviceIntPtr dev, int index, int button, int is_down)
     if (!pScreenPriv || !pScreenPriv->grabMouse)
         return FALSE;
 
-    memset(&event, 0, sizeof(event));
-    event.header = ET_Internal;
-    event.type = ET_DGAEvent;
-    event.length = sizeof(event);
-    event.time = GetTimeInMillis();
-    event.subtype = (is_down ? ET_ButtonPress : ET_ButtonRelease);
-    event.detail = button;
-    event.dx = 0;
-    event.dy = 0;
+    event = (DGAEvent) {
+        .header = ET_Internal,
+        .type = ET_DGAEvent,
+        .length = sizeof(event),
+        .time = GetTimeInMillis(),
+        .subtype = (is_down ? ET_ButtonPress : ET_ButtonRelease),
+        .detail = button,
+        .dx = 0,
+        .dy = 0
+    };
     mieqEnqueue(dev, (InternalEvent *) &event);
 
     return TRUE;
@@ -979,16 +1020,15 @@ DGAProcessKeyboardEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr keybd)
     KeyClassPtr keyc = keybd->key;
     DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
     DeviceIntPtr pointer = GetMaster(keybd, POINTER_OR_FLOAT);
-    DeviceEvent ev;
-
-    memset(&ev, 0, sizeof(ev));
-    ev.header = ET_Internal;
-    ev.length = sizeof(ev);
-    ev.detail.key = event->detail;
-    ev.type = event->subtype;
-    ev.root_x = 0;
-    ev.root_y = 0;
-    ev.corestate = XkbStateFieldFromRec(&keyc->xkbInfo->state);
+    DeviceEvent ev = {
+        .header = ET_Internal,
+        .length = sizeof(ev),
+        .detail.key = event->detail,
+        .type = event->subtype,
+        .root_x = 0,
+        .root_y = 0,
+        .corestate = XkbStateFieldFromRec(&keyc->xkbInfo->state)
+    };
     ev.corestate |= pointer->button->state;
 
     UpdateDeviceState(keybd, &ev);
@@ -997,15 +1037,15 @@ DGAProcessKeyboardEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr keybd)
      * Deliver the DGA event
      */
     if (pScreenPriv->client) {
-        dgaEvent de;
-
-        de.u.u.type = *XDGAEventBase + GetCoreType(ev.type);
+        dgaEvent de = {
+            .u.event.time = event->time,
+            .u.event.dx = event->dx,
+            .u.event.dy = event->dy,
+            .u.event.screen = pScreen->myNum,
+            .u.event.state = ev.corestate
+        };
+        de.u.u.type = DGAEventBase + GetCoreType(ev.type);
         de.u.u.detail = event->detail;
-        de.u.event.time = event->time;
-        de.u.event.dx = event->dx;
-        de.u.event.dy = event->dy;
-        de.u.event.screen = pScreen->myNum;
-        de.u.event.state = ev.corestate;
 
         /* If the DGA client has selected input, then deliver based on the usual filter */
         TryClientEvents(pScreenPriv->client, keybd, (xEvent *) &de, 1,
@@ -1030,14 +1070,14 @@ DGAProcessPointerEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr mouse)
 {
     ButtonClassPtr butc = mouse->button;
     DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
-    DeviceEvent ev;
     DeviceIntPtr master = GetMaster(mouse, MASTER_KEYBOARD);
+    DeviceEvent ev = {
+        .header = ET_Internal,
+        .length = sizeof(ev),
+        .type = event->subtype,
+        .corestate = butc ? butc->state : 0
+    };
 
-    memset(&ev, 0, sizeof(ev));
-    ev.header = ET_Internal;
-    ev.length = sizeof(ev);
-    ev.type = event->subtype;
-    ev.corestate = butc ? butc->state : 0;
     if (master && master->key)
         ev.corestate |= XkbStateFieldFromRec(&master->key->xkbInfo->state);
 
@@ -1047,18 +1087,16 @@ DGAProcessPointerEvent(ScreenPtr pScreen, DGAEvent * event, DeviceIntPtr mouse)
      * Deliver the DGA event
      */
     if (pScreenPriv->client) {
-        dgaEvent de;
-        int coreEquiv;
-
-        coreEquiv = GetCoreType(ev.type);
-
-        de.u.u.type = *XDGAEventBase + coreEquiv;
+        int coreEquiv = GetCoreType(ev.type);
+        dgaEvent de = {
+            .u.event.time = event->time,
+            .u.event.dx = event->dx,
+            .u.event.dy = event->dy,
+            .u.event.screen = pScreen->myNum,
+            .u.event.state = ev.corestate
+        };
+        de.u.u.type = DGAEventBase + coreEquiv;
         de.u.u.detail = event->detail;
-        de.u.event.time = event->time;
-        de.u.event.dx = event->dx;
-        de.u.event.dy = event->dy;
-        de.u.event.screen = pScreen->myNum;
-        de.u.event.state = ev.corestate;
 
         /* If the DGA client has selected input, then deliver based on the usual filter */
         TryClientEvents(pScreenPriv->client, mouse, (xEvent *) &de, 1,
@@ -1144,8 +1182,8 @@ DGAHandleEvent(int screen_num, InternalEvent *ev, DeviceIntPtr device)
     DGAScreenPtr pScreenPriv;
 
     /* no DGA */
-    if (!DGAScreenKeyRegistered || XDGAEventBase == 0)
-        return;
+    if (!DGAScreenKeyRegistered || noXFree86DGAExtension)
+	return;
     pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
 
     /* DGA not initialized on this screen */
@@ -1169,3 +1207,989 @@ DGAHandleEvent(int screen_num, InternalEvent *ev, DeviceIntPtr device)
         break;
     }
 }
+
+static void XDGAResetProc(ExtensionEntry * extEntry);
+
+static void DGAClientStateChange(CallbackListPtr *, pointer, pointer);
+
+static DevPrivateKeyRec DGAScreenPrivateKeyRec;
+
+#define DGAScreenPrivateKey (&DGAScreenPrivateKeyRec)
+#define DGAScreenPrivateKeyRegistered (DGAScreenPrivateKeyRec.initialized)
+static DevPrivateKeyRec DGAClientPrivateKeyRec;
+
+#define DGAClientPrivateKey (&DGAClientPrivateKeyRec)
+static int DGACallbackRefCount = 0;
+
+/* This holds the client's version information */
+typedef struct {
+    int major;
+    int minor;
+} DGAPrivRec, *DGAPrivPtr;
+
+#define DGA_GETCLIENT(idx) ((ClientPtr) \
+    dixLookupPrivate(&screenInfo.screens[idx]->devPrivates, DGAScreenPrivateKey))
+#define DGA_SETCLIENT(idx,p) \
+    dixSetPrivate(&screenInfo.screens[idx]->devPrivates, DGAScreenPrivateKey, p)
+
+#define DGA_GETPRIV(c) ((DGAPrivPtr) \
+    dixLookupPrivate(&(c)->devPrivates, DGAClientPrivateKey))
+#define DGA_SETPRIV(c,p) \
+    dixSetPrivate(&(c)->devPrivates, DGAClientPrivateKey, p)
+
+static void
+XDGAResetProc(ExtensionEntry * extEntry)
+{
+    DeleteCallback(&ClientStateCallback, DGAClientStateChange, NULL);
+    DGACallbackRefCount = 0;
+}
+
+static int
+ProcXDGAQueryVersion(ClientPtr client)
+{
+    xXDGAQueryVersionReply rep;
+
+    REQUEST_SIZE_MATCH(xXDGAQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = SERVER_XDGA_MAJOR_VERSION;
+    rep.minorVersion = SERVER_XDGA_MINOR_VERSION;
+
+    WriteToClient(client, sizeof(xXDGAQueryVersionReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXDGAOpenFramebuffer(ClientPtr client)
+{
+    REQUEST(xXDGAOpenFramebufferReq);
+    xXDGAOpenFramebufferReply rep;
+    char *deviceName;
+    int nameSize;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    REQUEST_SIZE_MATCH(xXDGAOpenFramebufferReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DGAOpenFramebuffer(stuff->screen, &deviceName,
+                            (unsigned char **) (&rep.mem1),
+                            (int *) &rep.size, (int *) &rep.offset,
+                            (int *) &rep.extra)) {
+        return BadAlloc;
+    }
+
+    nameSize = deviceName ? (strlen(deviceName) + 1) : 0;
+    rep.length = bytes_to_int32(nameSize);
+
+    WriteToClient(client, sizeof(xXDGAOpenFramebufferReply), (char *) &rep);
+    if (rep.length)
+        WriteToClient(client, nameSize, deviceName);
+
+    return Success;
+}
+
+static int
+ProcXDGACloseFramebuffer(ClientPtr client)
+{
+    REQUEST(xXDGACloseFramebufferReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    REQUEST_SIZE_MATCH(xXDGACloseFramebufferReq);
+
+    DGACloseFramebuffer(stuff->screen);
+
+    return Success;
+}
+
+static int
+ProcXDGAQueryModes(ClientPtr client)
+{
+    int i, num, size;
+
+    REQUEST(xXDGAQueryModesReq);
+    xXDGAQueryModesReply rep;
+    xXDGAModeInfo info;
+    XDGAModePtr mode;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXDGAQueryModesReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.number = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DGAAvailable(stuff->screen)) {
+        rep.number = 0;
+        rep.length = 0;
+        WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
+        return Success;
+    }
+
+    if (!(num = DGAGetModes(stuff->screen))) {
+        WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
+        return Success;
+    }
+
+    if (!(mode = (XDGAModePtr) malloc(num * sizeof(XDGAModeRec))))
+        return BadAlloc;
+
+    for (i = 0; i < num; i++)
+        DGAGetModeInfo(stuff->screen, mode + i, i + 1);
+
+    size = num * sz_xXDGAModeInfo;
+    for (i = 0; i < num; i++)
+        size += pad_to_int32(strlen(mode[i].name) + 1); /* plus NULL */
+
+    rep.number = num;
+    rep.length = bytes_to_int32(size);
+
+    WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
+
+    for (i = 0; i < num; i++) {
+        size = strlen(mode[i].name) + 1;
+
+        info.byte_order = mode[i].byteOrder;
+        info.depth = mode[i].depth;
+        info.num = mode[i].num;
+        info.bpp = mode[i].bitsPerPixel;
+        info.name_size = (size + 3) & ~3L;
+        info.vsync_num = mode[i].VSync_num;
+        info.vsync_den = mode[i].VSync_den;
+        info.flags = mode[i].flags;
+        info.image_width = mode[i].imageWidth;
+        info.image_height = mode[i].imageHeight;
+        info.pixmap_width = mode[i].pixmapWidth;
+        info.pixmap_height = mode[i].pixmapHeight;
+        info.bytes_per_scanline = mode[i].bytesPerScanline;
+        info.red_mask = mode[i].red_mask;
+        info.green_mask = mode[i].green_mask;
+        info.blue_mask = mode[i].blue_mask;
+        info.visual_class = mode[i].visualClass;
+        info.viewport_width = mode[i].viewportWidth;
+        info.viewport_height = mode[i].viewportHeight;
+        info.viewport_xstep = mode[i].xViewportStep;
+        info.viewport_ystep = mode[i].yViewportStep;
+        info.viewport_xmax = mode[i].maxViewportX;
+        info.viewport_ymax = mode[i].maxViewportY;
+        info.viewport_flags = mode[i].viewportFlags;
+        info.reserved1 = mode[i].reserved1;
+        info.reserved2 = mode[i].reserved2;
+
+        WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
+        WriteToClient(client, size, mode[i].name);
+    }
+
+    free(mode);
+
+    return Success;
+}
+
+static void
+DGAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
+{
+    NewClientInfoRec *pci = (NewClientInfoRec *) calldata;
+    ClientPtr client = NULL;
+    int i;
+
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        if (DGA_GETCLIENT(i) == pci->client) {
+            client = pci->client;
+            break;
+        }
+    }
+
+    if (client &&
+        ((client->clientState == ClientStateGone) ||
+         (client->clientState == ClientStateRetained))) {
+        XDGAModeRec mode;
+        PixmapPtr pPix;
+
+        DGA_SETCLIENT(i, NULL);
+        DGASelectInput(i, NULL, 0);
+        DGASetMode(i, 0, &mode, &pPix);
+
+        if (--DGACallbackRefCount == 0)
+            DeleteCallback(&ClientStateCallback, DGAClientStateChange, NULL);
+    }
+}
+
+static int
+ProcXDGASetMode(ClientPtr client)
+{
+    REQUEST(xXDGASetModeReq);
+    xXDGASetModeReply rep;
+    XDGAModeRec mode;
+    xXDGAModeInfo info;
+    PixmapPtr pPix;
+    ClientPtr owner;
+    int size;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+    owner = DGA_GETCLIENT(stuff->screen);
+
+    REQUEST_SIZE_MATCH(xXDGASetModeReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.offset = 0;
+    rep.flags = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (owner && owner != client)
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (!stuff->mode) {
+        if (owner) {
+            if (--DGACallbackRefCount == 0)
+                DeleteCallback(&ClientStateCallback, DGAClientStateChange,
+                               NULL);
+        }
+        DGA_SETCLIENT(stuff->screen, NULL);
+        DGASelectInput(stuff->screen, NULL, 0);
+        DGASetMode(stuff->screen, 0, &mode, &pPix);
+        WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
+        return Success;
+    }
+
+    if (Success != DGASetMode(stuff->screen, stuff->mode, &mode, &pPix))
+        return BadValue;
+
+    if (!owner) {
+        if (DGACallbackRefCount++ == 0)
+            AddCallback(&ClientStateCallback, DGAClientStateChange, NULL);
+    }
+
+    DGA_SETCLIENT(stuff->screen, client);
+
+    if (pPix) {
+        if (AddResource(stuff->pid, RT_PIXMAP, (pointer) (pPix))) {
+            pPix->drawable.id = (int) stuff->pid;
+            rep.flags = DGA_PIXMAP_AVAILABLE;
+        }
+    }
+
+    size = strlen(mode.name) + 1;
+
+    info.byte_order = mode.byteOrder;
+    info.depth = mode.depth;
+    info.num = mode.num;
+    info.bpp = mode.bitsPerPixel;
+    info.name_size = (size + 3) & ~3L;
+    info.vsync_num = mode.VSync_num;
+    info.vsync_den = mode.VSync_den;
+    info.flags = mode.flags;
+    info.image_width = mode.imageWidth;
+    info.image_height = mode.imageHeight;
+    info.pixmap_width = mode.pixmapWidth;
+    info.pixmap_height = mode.pixmapHeight;
+    info.bytes_per_scanline = mode.bytesPerScanline;
+    info.red_mask = mode.red_mask;
+    info.green_mask = mode.green_mask;
+    info.blue_mask = mode.blue_mask;
+    info.visual_class = mode.visualClass;
+    info.viewport_width = mode.viewportWidth;
+    info.viewport_height = mode.viewportHeight;
+    info.viewport_xstep = mode.xViewportStep;
+    info.viewport_ystep = mode.yViewportStep;
+    info.viewport_xmax = mode.maxViewportX;
+    info.viewport_ymax = mode.maxViewportY;
+    info.viewport_flags = mode.viewportFlags;
+    info.reserved1 = mode.reserved1;
+    info.reserved2 = mode.reserved2;
+
+    rep.length = bytes_to_int32(sz_xXDGAModeInfo + info.name_size);
+
+    WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
+    WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
+    WriteToClient(client, size, mode.name);
+
+    return Success;
+}
+
+static int
+ProcXDGASetViewport(ClientPtr client)
+{
+    REQUEST(xXDGASetViewportReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGASetViewportReq);
+
+    DGASetViewport(stuff->screen, stuff->x, stuff->y, stuff->flags);
+
+    return Success;
+}
+
+static int
+ProcXDGAInstallColormap(ClientPtr client)
+{
+    ColormapPtr cmap;
+    int rc;
+
+    REQUEST(xXDGAInstallColormapReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGAInstallColormapReq);
+
+    rc = dixLookupResourceByType((pointer *) &cmap, stuff->cmap, RT_COLORMAP,
+                                 client, DixInstallAccess);
+    if (rc != Success)
+        return rc;
+    DGAInstallCmap(cmap);
+    return Success;
+}
+
+static int
+ProcXDGASelectInput(ClientPtr client)
+{
+    REQUEST(xXDGASelectInputReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGASelectInputReq);
+
+    if (DGA_GETCLIENT(stuff->screen) == client)
+        DGASelectInput(stuff->screen, client, stuff->mask);
+
+    return Success;
+}
+
+static int
+ProcXDGAFillRectangle(ClientPtr client)
+{
+    REQUEST(xXDGAFillRectangleReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGAFillRectangleReq);
+
+    if (Success != DGAFillRect(stuff->screen, stuff->x, stuff->y,
+                               stuff->width, stuff->height, stuff->color))
+        return BadMatch;
+
+    return Success;
+}
+
+static int
+ProcXDGACopyArea(ClientPtr client)
+{
+    REQUEST(xXDGACopyAreaReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGACopyAreaReq);
+
+    if (Success != DGABlitRect(stuff->screen, stuff->srcx, stuff->srcy,
+                               stuff->width, stuff->height, stuff->dstx,
+                               stuff->dsty))
+        return BadMatch;
+
+    return Success;
+}
+
+static int
+ProcXDGACopyTransparentArea(ClientPtr client)
+{
+    REQUEST(xXDGACopyTransparentAreaReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGACopyTransparentAreaReq);
+
+    if (Success != DGABlitTransRect(stuff->screen, stuff->srcx, stuff->srcy,
+                                    stuff->width, stuff->height, stuff->dstx,
+                                    stuff->dsty, stuff->key))
+        return BadMatch;
+
+    return Success;
+}
+
+static int
+ProcXDGAGetViewportStatus(ClientPtr client)
+{
+    REQUEST(xXDGAGetViewportStatusReq);
+    xXDGAGetViewportStatusReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGAGetViewportStatusReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    rep.status = DGAGetViewportStatus(stuff->screen);
+
+    WriteToClient(client, sizeof(xXDGAGetViewportStatusReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXDGASync(ClientPtr client)
+{
+    REQUEST(xXDGASyncReq);
+    xXDGASyncReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGASyncReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    DGASync(stuff->screen);
+
+    WriteToClient(client, sizeof(xXDGASyncReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXDGASetClientVersion(ClientPtr client)
+{
+    REQUEST(xXDGASetClientVersionReq);
+
+    DGAPrivPtr pPriv;
+
+    REQUEST_SIZE_MATCH(xXDGASetClientVersionReq);
+    if ((pPriv = DGA_GETPRIV(client)) == NULL) {
+        pPriv = malloc(sizeof(DGAPrivRec));
+        /* XXX Need to look into freeing this */
+        if (!pPriv)
+            return BadAlloc;
+        DGA_SETPRIV(client, pPriv);
+    }
+    pPriv->major = stuff->major;
+    pPriv->minor = stuff->minor;
+
+    return Success;
+}
+
+static int
+ProcXDGAChangePixmapMode(ClientPtr client)
+{
+    REQUEST(xXDGAChangePixmapModeReq);
+    xXDGAChangePixmapModeReply rep;
+    int x, y;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGAChangePixmapModeReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    x = stuff->x;
+    y = stuff->y;
+
+    if (!DGAChangePixmapMode(stuff->screen, &x, &y, stuff->flags))
+        return BadMatch;
+
+    rep.x = x;
+    rep.y = y;
+    WriteToClient(client, sizeof(xXDGAChangePixmapModeReply), (char *) &rep);
+
+    return Success;
+}
+
+static int
+ProcXDGACreateColormap(ClientPtr client)
+{
+    REQUEST(xXDGACreateColormapReq);
+    int result;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXDGACreateColormapReq);
+
+    if (!stuff->mode)
+        return BadValue;
+
+    result = DGACreateColormap(stuff->screen, client, stuff->id,
+                               stuff->mode, stuff->alloc);
+    if (result != Success)
+        return result;
+
+    return Success;
+}
+
+/*
+ *
+ * Support for the old DGA protocol, used to live in xf86dga.c
+ *
+ */
+
+#ifdef DGA_PROTOCOL_OLD_SUPPORT
+
+static int
+ProcXF86DGAGetVideoLL(ClientPtr client)
+{
+    REQUEST(xXF86DGAGetVideoLLReq);
+    xXF86DGAGetVideoLLReply rep;
+    XDGAModeRec mode;
+    int num, offset, flags;
+    char *name;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXF86DGAGetVideoLLReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (!(num = DGAGetOldDGAMode(stuff->screen)))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    /* get the parameters for the mode that best matches */
+    DGAGetModeInfo(stuff->screen, &mode, num);
+
+    if (!DGAOpenFramebuffer(stuff->screen, &name,
+                            (unsigned char **) (&rep.offset),
+                            (int *) (&rep.bank_size), &offset, &flags))
+        return BadAlloc;
+
+    rep.offset += mode.offset;
+    rep.width = mode.bytesPerScanline / (mode.bitsPerPixel >> 3);
+    rep.ram_size = rep.bank_size >> 10;
+
+    WriteToClient(client, SIZEOF(xXF86DGAGetVideoLLReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXF86DGADirectVideo(ClientPtr client)
+{
+    int num;
+    PixmapPtr pix;
+    XDGAModeRec mode;
+    ClientPtr owner;
+
+    REQUEST(xXF86DGADirectVideoReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+    REQUEST_SIZE_MATCH(xXF86DGADirectVideoReq);
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    owner = DGA_GETCLIENT(stuff->screen);
+
+    if (owner && owner != client)
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (stuff->enable & XF86DGADirectGraphics) {
+        if (!(num = DGAGetOldDGAMode(stuff->screen)))
+            return DGAErrorBase + XF86DGANoDirectVideoMode;
+    }
+    else
+        num = 0;
+
+    if (Success != DGASetMode(stuff->screen, num, &mode, &pix))
+        return DGAErrorBase + XF86DGAScreenNotActive;
+
+    DGASetInputMode(stuff->screen,
+                    (stuff->enable & XF86DGADirectKeyb) != 0,
+                    (stuff->enable & XF86DGADirectMouse) != 0);
+
+    /* We need to track the client and attach the teardown callback */
+    if (stuff->enable &
+        (XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse)) {
+        if (!owner) {
+            if (DGACallbackRefCount++ == 0)
+                AddCallback(&ClientStateCallback, DGAClientStateChange, NULL);
+        }
+
+        DGA_SETCLIENT(stuff->screen, client);
+    }
+    else {
+        if (owner) {
+            if (--DGACallbackRefCount == 0)
+                DeleteCallback(&ClientStateCallback, DGAClientStateChange,
+                               NULL);
+        }
+
+        DGA_SETCLIENT(stuff->screen, NULL);
+    }
+
+    return Success;
+}
+
+static int
+ProcXF86DGAGetViewPortSize(ClientPtr client)
+{
+    int num;
+    XDGAModeRec mode;
+
+    REQUEST(xXF86DGAGetViewPortSizeReq);
+    xXF86DGAGetViewPortSizeReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXF86DGAGetViewPortSizeReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (!(num = DGAGetOldDGAMode(stuff->screen)))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    DGAGetModeInfo(stuff->screen, &mode, num);
+
+    rep.width = mode.viewportWidth;
+    rep.height = mode.viewportHeight;
+
+    WriteToClient(client, SIZEOF(xXF86DGAGetViewPortSizeReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXF86DGASetViewPort(ClientPtr client)
+{
+    REQUEST(xXF86DGASetViewPortReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXF86DGASetViewPortReq);
+
+    if (!DGAAvailable(stuff->screen))
+        return DGAErrorBase + XF86DGANoDirectVideoMode;
+
+    if (!DGAActive(stuff->screen))
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    if (DGASetViewport(stuff->screen, stuff->x, stuff->y, DGA_FLIP_RETRACE)
+        != Success)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    return Success;
+}
+
+static int
+ProcXF86DGAGetVidPage(ClientPtr client)
+{
+    REQUEST(xXF86DGAGetVidPageReq);
+    xXF86DGAGetVidPageReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXF86DGAGetVidPageReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.vpage = 0;              /* silently fail */
+
+    WriteToClient(client, SIZEOF(xXF86DGAGetVidPageReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXF86DGASetVidPage(ClientPtr client)
+{
+    REQUEST(xXF86DGASetVidPageReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXF86DGASetVidPageReq);
+
+    /* silently fail */
+
+    return Success;
+}
+
+static int
+ProcXF86DGAInstallColormap(ClientPtr client)
+{
+    ColormapPtr pcmp;
+    int rc;
+
+    REQUEST(xXF86DGAInstallColormapReq);
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXF86DGAInstallColormapReq);
+
+    if (!DGAActive(stuff->screen))
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    rc = dixLookupResourceByType((pointer *) &pcmp, stuff->id, RT_COLORMAP,
+                                 client, DixInstallAccess);
+    if (rc == Success) {
+        DGAInstallCmap(pcmp);
+        return Success;
+    }
+    else {
+        return rc;
+    }
+}
+
+static int
+ProcXF86DGAQueryDirectVideo(ClientPtr client)
+{
+    REQUEST(xXF86DGAQueryDirectVideoReq);
+    xXF86DGAQueryDirectVideoReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    REQUEST_SIZE_MATCH(xXF86DGAQueryDirectVideoReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.flags = 0;
+
+    if (DGAAvailable(stuff->screen))
+        rep.flags = XF86DGADirectPresent;
+
+    WriteToClient(client, SIZEOF(xXF86DGAQueryDirectVideoReply), (char *) &rep);
+    return Success;
+}
+
+static int
+ProcXF86DGAViewPortChanged(ClientPtr client)
+{
+    REQUEST(xXF86DGAViewPortChangedReq);
+    xXF86DGAViewPortChangedReply rep;
+
+    if (stuff->screen >= screenInfo.numScreens)
+        return BadValue;
+
+    if (DGA_GETCLIENT(stuff->screen) != client)
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    REQUEST_SIZE_MATCH(xXF86DGAViewPortChangedReq);
+
+    if (!DGAActive(stuff->screen))
+        return DGAErrorBase + XF86DGADirectNotActivated;
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.result = 1;
+
+    WriteToClient(client, SIZEOF(xXF86DGAViewPortChangedReply), (char *) &rep);
+    return Success;
+}
+
+#endif                          /* DGA_PROTOCOL_OLD_SUPPORT */
+
+static int
+SProcXDGADispatch(ClientPtr client)
+{
+    return DGAErrorBase + XF86DGAClientNotLocal;
+}
+
+#if 0
+#define DGA_REQ_DEBUG
+#endif
+
+#ifdef DGA_REQ_DEBUG
+static char *dgaMinor[] = {
+    "QueryVersion",
+    "GetVideoLL",
+    "DirectVideo",
+    "GetViewPortSize",
+    "SetViewPort",
+    "GetVidPage",
+    "SetVidPage",
+    "InstallColormap",
+    "QueryDirectVideo",
+    "ViewPortChanged",
+    "10",
+    "11",
+    "QueryModes",
+    "SetMode",
+    "SetViewport",
+    "InstallColormap",
+    "SelectInput",
+    "FillRectangle",
+    "CopyArea",
+    "CopyTransparentArea",
+    "GetViewportStatus",
+    "Sync",
+    "OpenFramebuffer",
+    "CloseFramebuffer",
+    "SetClientVersion",
+    "ChangePixmapMode",
+    "CreateColormap",
+};
+#endif
+
+static int
+ProcXDGADispatch(ClientPtr client)
+{
+    REQUEST(xReq);
+
+    if (!LocalClient(client))
+        return DGAErrorBase + XF86DGAClientNotLocal;
+
+#ifdef DGA_REQ_DEBUG
+    if (stuff->data <= X_XDGACreateColormap)
+        fprintf(stderr, "    DGA %s\n", dgaMinor[stuff->data]);
+#endif
+
+    switch (stuff->data) {
+        /*
+         * DGA2 Protocol
+         */
+    case X_XDGAQueryVersion:
+        return ProcXDGAQueryVersion(client);
+    case X_XDGAQueryModes:
+        return ProcXDGAQueryModes(client);
+    case X_XDGASetMode:
+        return ProcXDGASetMode(client);
+    case X_XDGAOpenFramebuffer:
+        return ProcXDGAOpenFramebuffer(client);
+    case X_XDGACloseFramebuffer:
+        return ProcXDGACloseFramebuffer(client);
+    case X_XDGASetViewport:
+        return ProcXDGASetViewport(client);
+    case X_XDGAInstallColormap:
+        return ProcXDGAInstallColormap(client);
+    case X_XDGASelectInput:
+        return ProcXDGASelectInput(client);
+    case X_XDGAFillRectangle:
+        return ProcXDGAFillRectangle(client);
+    case X_XDGACopyArea:
+        return ProcXDGACopyArea(client);
+    case X_XDGACopyTransparentArea:
+        return ProcXDGACopyTransparentArea(client);
+    case X_XDGAGetViewportStatus:
+        return ProcXDGAGetViewportStatus(client);
+    case X_XDGASync:
+        return ProcXDGASync(client);
+    case X_XDGASetClientVersion:
+        return ProcXDGASetClientVersion(client);
+    case X_XDGAChangePixmapMode:
+        return ProcXDGAChangePixmapMode(client);
+    case X_XDGACreateColormap:
+        return ProcXDGACreateColormap(client);
+        /*
+         * Old DGA Protocol
+         */
+#ifdef DGA_PROTOCOL_OLD_SUPPORT
+    case X_XF86DGAGetVideoLL:
+        return ProcXF86DGAGetVideoLL(client);
+    case X_XF86DGADirectVideo:
+        return ProcXF86DGADirectVideo(client);
+    case X_XF86DGAGetViewPortSize:
+        return ProcXF86DGAGetViewPortSize(client);
+    case X_XF86DGASetViewPort:
+        return ProcXF86DGASetViewPort(client);
+    case X_XF86DGAGetVidPage:
+        return ProcXF86DGAGetVidPage(client);
+    case X_XF86DGASetVidPage:
+        return ProcXF86DGASetVidPage(client);
+    case X_XF86DGAInstallColormap:
+        return ProcXF86DGAInstallColormap(client);
+    case X_XF86DGAQueryDirectVideo:
+        return ProcXF86DGAQueryDirectVideo(client);
+    case X_XF86DGAViewPortChanged:
+        return ProcXF86DGAViewPortChanged(client);
+#endif                          /* DGA_PROTOCOL_OLD_SUPPORT */
+    default:
+        return BadRequest;
+    }
+}
+
+void
+XFree86DGAExtensionInit(void)
+{
+    ExtensionEntry *extEntry;
+
+    if (!dixRegisterPrivateKey(&DGAClientPrivateKeyRec, PRIVATE_CLIENT, 0))
+        return;
+
+    if (!dixRegisterPrivateKey(&DGAScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
+        return;
+
+    if ((extEntry = AddExtension(XF86DGANAME,
+                                 XF86DGANumberEvents,
+                                 XF86DGANumberErrors,
+                                 ProcXDGADispatch,
+                                 SProcXDGADispatch,
+                                 XDGAResetProc, StandardMinorOpcode))) {
+        int i;
+
+        DGAReqCode = (unsigned char) extEntry->base;
+        DGAErrorBase = extEntry->errorBase;
+        DGAEventBase = extEntry->eventBase;
+        for (i = KeyPress; i <= MotionNotify; i++)
+            SetCriticalEvent(DGAEventBase + i);
+    }
+}
diff --git a/xorg-server/hw/xfree86/common/xf86Extensions.c b/xorg-server/hw/xfree86/common/xf86Extensions.c
new file mode 100644
index 000000000..d5309d558
--- /dev/null
+++ b/xorg-server/hw/xfree86/common/xf86Extensions.c
@@ -0,0 +1,142 @@
+/*
+ * Copyright © 2011 Daniel Stone
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include "extension.h"
+#include "globals.h"
+
+#include "xf86.h"
+#include "xf86Config.h"
+#include "xf86Module.h"
+#include "xf86Extensions.h"
+#include "xf86Opt.h"
+#include "optionstr.h"
+
+#ifdef XSELINUX
+#include "xselinux.h"
+#endif
+
+#ifdef XFreeXDGA
+#include <X11/extensions/xf86dgaproto.h>
+#endif
+
+#ifdef XF86VIDMODE
+#include <X11/extensions/xf86vmproto.h>
+#include "vidmodeproc.h"
+#endif
+
+/*
+ * DDX-specific extensions.
+ */
+static ExtensionModule extensionModules[] = {
+#ifdef XF86VIDMODE
+    {
+	XFree86VidModeExtensionInit,
+	XF86VIDMODENAME,
+	&noXFree86VidModeExtension
+    },
+#endif
+#ifdef XFreeXDGA
+    {
+	XFree86DGAExtensionInit,
+	XF86DGANAME,
+	&noXFree86DGAExtension
+    },
+#endif
+#ifdef XF86DRI
+    {
+        XFree86DRIExtensionInit,
+        "XFree86-DRI",
+        &noXFree86DRIExtension
+    },
+#endif
+#ifdef DRI2
+    {
+        DRI2ExtensionInit,
+        DRI2_NAME,
+        &noDRI2Extension
+    }
+#endif
+};
+
+static void
+load_extension_config(void)
+{
+    XF86ConfModulePtr mod_con = xf86configptr->conf_modules;
+    XF86LoadPtr modp;
+    int i;
+
+    /* Only the best. */
+    if (!mod_con)
+        return;
+
+    nt_list_for_each_entry(modp, mod_con->mod_load_lst, list.next) {
+        InputOption *opt;
+
+        if (strcasecmp(modp->load_name, "extmod") != 0)
+            continue;
+
+        /* extmod options are of the form "omit <extension-name>" */
+        nt_list_for_each_entry(opt, modp->load_opt, list.next) {
+            const char *key = input_option_get_key(opt);
+            if (strncasecmp(key, "omit", 4) != 0 || strlen(key) < 5)
+                continue;
+            if (EnableDisableExtension(key + 4, FALSE))
+                xf86MarkOptionUsed(opt);
+        }
+
+#ifdef XSELINUX
+        if ((opt = xf86FindOption(modp->load_opt,
+                                  "SELinux mode disabled"))) {
+            xf86MarkOptionUsed(opt);
+            selinuxEnforcingState = SELINUX_MODE_DISABLED;
+        }
+        if ((opt = xf86FindOption(modp->load_opt,
+                                  "SELinux mode permissive"))) {
+            xf86MarkOptionUsed(opt);
+            selinuxEnforcingState = SELINUX_MODE_PERMISSIVE;
+        }
+        if ((opt = xf86FindOption(modp->load_opt,
+                                  "SELinux mode enforcing"))) {
+            xf86MarkOptionUsed(opt);
+            selinuxEnforcingState = SELINUX_MODE_ENFORCING;
+        }
+#endif
+    }
+}
+
+void
+xf86ExtensionInit(void)
+{
+    int i;
+
+    load_extension_config();
+
+    for (i = 0; i < ARRAY_SIZE(extensionModules); i++)
+	LoadExtension(&extensionModules[i], TRUE);
+}
diff --git a/xorg-server/hw/xfree86/common/xf86Extensions.h b/xorg-server/hw/xfree86/common/xf86Extensions.h
new file mode 100644
index 000000000..9b8448d64
--- /dev/null
+++ b/xorg-server/hw/xfree86/common/xf86Extensions.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright © 2011 Daniel Stone
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#ifndef XF86EXTENSIONS_H
+#define XF86EXTENSIONS_H
+
+#include "extnsionst.h"
+
+#ifdef XF86DRI
+extern Bool noXFree86DRIExtension;
+extern void XFree86DRIExtensionInit(void);
+#endif
+
+#ifdef DRI2
+#include <X11/extensions/dri2proto.h>
+extern Bool noDRI2Extension;
+extern void DRI2ExtensionInit(void);
+#endif
+
+#ifdef XF86VIDMODE
+#include <X11/extensions/xf86vmproto.h>
+extern Bool noXFree86VidModeExtension;
+extern void XFree86VidModeExtensionInit(void);
+#endif
+
+#ifdef XFreeXDGA
+#include <X11/extensions/xf86dgaproto.h>
+extern Bool noXFree86DGAExtension;
+extern void XFree86DGAExtensionInit(void);
+extern void XFree86DGARegister(void);
+#endif
+
+#endif
diff --git a/xorg-server/hw/xfree86/common/xf86Init.c b/xorg-server/hw/xfree86/common/xf86Init.c
index aa17a58fd..e4a6b8613 100644
--- a/xorg-server/hw/xfree86/common/xf86Init.c
+++ b/xorg-server/hw/xfree86/common/xf86Init.c
@@ -401,6 +401,7 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
     MessageType pix24From = X_DEFAULT;
     Bool pix24Fail = FALSE;
     Bool autoconfig = FALSE;
+    Bool sigio_blocked = FALSE;
     GDevPtr configured_device;
 
     xf86Initialising = TRUE;
@@ -471,6 +472,8 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
         xf86OSPMClose = xf86OSPMOpen();
 #endif
 
+        xf86ExtensionInit();
+
         /* Load all modules specified explicitly in the config file */
         if ((modulelist = xf86ModulelistFromConfig(&optionlist))) {
             xf86LoadModules(modulelist, optionlist);
@@ -819,6 +822,7 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 #endif
             xf86AccessEnter();
             OsBlockSIGIO();
+            sigio_blocked = TRUE;
         }
     }
 
@@ -920,8 +924,12 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char **argv)
 #endif
     }
 
+    for (i = 0; i < xf86NumGPUScreens; i++)
+        AttachUnboundGPU(xf86Screens[0]->pScreen, xf86GPUScreens[i]->pScreen);
+
     xf86VGAarbiterWrapFunctions();
-    OsReleaseSIGIO();
+    if (sigio_blocked)
+        OsReleaseSIGIO();
 
     xf86InitOrigins();
 
@@ -1006,7 +1014,6 @@ OsVendorInit(void)
     }
 #endif
 #endif
-    OsReleaseSIGIO();
 
     beenHere = TRUE;
 }
diff --git a/xorg-server/hw/xfree86/common/xf86Module.h b/xorg-server/hw/xfree86/common/xf86Module.h
index 7671cea5d..d93405e3c 100644
--- a/xorg-server/hw/xfree86/common/xf86Module.h
+++ b/xorg-server/hw/xfree86/common/xf86Module.h
@@ -42,6 +42,7 @@
 #define _XF86MODULE_H
 
 #include "misc.h"
+#include "extension.h"
 #ifndef NULL
 #define NULL ((void *)0)
 #endif
@@ -55,9 +56,6 @@ typedef enum {
 
 #define DEFAULT_LIST ((char *)-1)
 
-/* This indicates a special module that doesn't have the usual entry point */
-#define EXTERN_MODULE ((pointer)-1)
-
 /* Built-in ABI classes.  These definitions must not be changed. */
 #define ABI_CLASS_NONE		NULL
 #define ABI_CLASS_ANSIC		"X.Org ANSI C Emulation"
@@ -171,18 +169,6 @@ typedef struct {
 
 #define INITARGS void
 
-typedef void (*InitExtension) (INITARGS);
-
-typedef struct {
-    InitExtension initFunc;
-    const char *name;
-    Bool *disablePtr;
-    InitExtension setupFunc;
-    const char **initDependencies;
-} ExtensionModule;
-
-extern _X_EXPORT ExtensionModule *ExtensionModuleList;
-
 /* Prototypes for Loader functions that are exported to modules */
 extern _X_EXPORT pointer LoadSubModule(pointer, const char *, const char **,
                                        const char **, pointer,
@@ -193,7 +179,6 @@ extern _X_EXPORT pointer LoaderSymbol(const char *);
 extern _X_EXPORT char **LoaderListDirs(const char **, const char **);
 extern _X_EXPORT void LoaderFreeDirList(char **);
 extern _X_EXPORT void LoaderErrorMsg(const char *, const char *, int, int);
-extern _X_EXPORT void LoadExtension(ExtensionModule *, Bool);
 extern _X_EXPORT void LoaderGetOS(const char **name, int *major, int *minor,
                                   int *teeny);
 extern _X_EXPORT Bool LoaderShouldIgnoreABI(void);
diff --git a/xorg-server/hw/xfree86/common/xf86platformBus.c b/xorg-server/hw/xfree86/common/xf86platformBus.c
index 3bfb22e83..24b947326 100644
--- a/xorg-server/hw/xfree86/common/xf86platformBus.c
+++ b/xorg-server/hw/xfree86/common/xf86platformBus.c
@@ -432,14 +432,17 @@ xf86platformAddDevice(int index)
         xf86DeleteScreen(xf86GPUScreens[i]);
         return -1;
     }
-        
+
    scr_index = AddGPUScreen(xf86GPUScreens[i]->ScreenInit, 0, NULL);
-   
+
    dixSetPrivate(&xf86GPUScreens[i]->pScreen->devPrivates,
                  xf86ScreenKey, xf86GPUScreens[i]);
 
    CreateScratchPixmapsForScreen(xf86GPUScreens[i]->pScreen);
-  
+
+   /* attach unbound to 0 protocol screen */
+   AttachUnboundGPU(xf86Screens[0]->pScreen, xf86GPUScreens[i]->pScreen);
+
    return 0;
 }
 
diff --git a/xorg-server/hw/xfree86/common/xf86str.h b/xorg-server/hw/xfree86/common/xf86str.h
index 6bd6a6218..059026243 100644
--- a/xorg-server/hw/xfree86/common/xf86str.h
+++ b/xorg-server/hw/xfree86/common/xf86str.h
@@ -814,6 +814,7 @@ typedef struct _ScrnInfoRec {
     funcPointer reservedFuncs[NUM_RESERVED_FUNCS];
 
     Bool is_gpu;
+    uint32_t capabilities;
 } ScrnInfoRec;
 
 typedef struct {
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c b/xorg-server/hw/xfree86/common/xf86vmode.c
index 68c4b583f..7cd2eedb3 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
+++ b/xorg-server/hw/xfree86/common/xf86vmode.c
@@ -39,6 +39,7 @@ from Kaleb S. KEITHLEY
 #include "misc.h"
 #include "dixstruct.h"
 #include "extnsionst.h"
+#include "xf86Extensions.h"
 #include "scrnintstr.h"
 #include "servermd.h"
 #include <X11/extensions/xf86vmproto.h>
@@ -240,7 +241,6 @@ static void
 SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
 {
     XF86VidModeScreenPrivatePtr pPriv;
-    XF86VidModeEventPtr pEv;
     unsigned long mask;
     xXF86VidModeNotifyEvent ev;
     int kind;
@@ -253,17 +253,21 @@ SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
         return;
     kind = XF86VidModeModeChange;
     for (pEv = pPriv->events; pEv; pEv = pEv->next) {
-        if (!(pEv->mask & mask))
-            continue;
-        ev.type = XF86VidModeNotify + XF86VidModeEventBase;
-        ev.state = state;
-        ev.timestamp = currentTime.milliseconds;
-        ev.root = pScreen->root->drawable.id;
-        ev.kind = kind;
-        ev.forced = forced;
-        WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
-}} static void
+        if (pEv->mask & mask) {
+            XF86VidModeEventPtr pEv = {
+                .type = XF86VidModeNotify + XF86VidModeEventBase,
+                .state = state,
+                .timestamp = currentTime.milliseconds,
+                .root = pScreen->root->drawable.id,
+                .kind = kind,
+                .forced = forced
+            };
+            WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
+        }
+    }
+}
 
+static void
 SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from,
                         xXF86VidModeNotifyEvent * to)
 {
@@ -280,23 +284,25 @@ SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from,
 static int
 ProcXF86VidModeQueryVersion(ClientPtr client)
 {
-    xXF86VidModeQueryVersionReply rep;
+    xXF86VidModeQueryVersionReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION,
+        .minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION
+    };
 
     DEBUG_P("XF86VidModeQueryVersion");
 
     REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION;
-    rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION;
+
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swaps(&rep.majorVersion);
         swaps(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep);
     return Success;
 }
 
@@ -304,8 +310,10 @@ static int
 ProcXF86VidModeGetModeLine(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetModeLineReq);
-    xXF86VidModeGetModeLineReply rep;
-    xXF86OldVidModeGetModeLineReply oldrep;
+    xXF86VidModeGetModeLineReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence
+    };
     pointer mode;
     int dotClock;
     int ver;
@@ -314,7 +322,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
 
     ver = ClientMajorVersion(client);
     REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
-    rep.type = X_Reply;
+
     if (ver < 2) {
         rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) -
                                     SIZEOF(xGenericReply));
@@ -323,7 +331,6 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
         rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply) -
                                     SIZEOF(xGenericReply));
     }
-    rep.sequenceNumber = client->sequence;
 
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
@@ -377,26 +384,26 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
         swapl(&rep.privsize);
     }
     if (ver < 2) {
-        oldrep.type = rep.type;
-        oldrep.sequenceNumber = rep.sequenceNumber;
-        oldrep.length = rep.length;
-        oldrep.dotclock = rep.dotclock;
-        oldrep.hdisplay = rep.hdisplay;
-        oldrep.hsyncstart = rep.hsyncstart;
-        oldrep.hsyncend = rep.hsyncend;
-        oldrep.htotal = rep.htotal;
-        oldrep.vdisplay = rep.vdisplay;
-        oldrep.vsyncstart = rep.vsyncstart;
-        oldrep.vsyncend = rep.vsyncend;
-        oldrep.vtotal = rep.vtotal;
-        oldrep.flags = rep.flags;
-        oldrep.privsize = rep.privsize;
-        WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply),
-                      (char *) &oldrep);
+        xXF86OldVidModeGetModeLineReply oldrep = {
+            .type = rep.type,
+            .sequenceNumber = rep.sequenceNumber,
+            .length = rep.length,
+            .dotclock = rep.dotclock,
+            .hdisplay = rep.hdisplay,
+            .hsyncstart = rep.hsyncstart,
+            .hsyncend = rep.hsyncend,
+            .htotal = rep.htotal,
+            .vdisplay = rep.vdisplay,
+            .vsyncstart = rep.vsyncstart,
+            .vsyncend = rep.vsyncend,
+            .vtotal = rep.vtotal,
+            .flags = rep.flags,
+            .privsize = rep.privsize
+        };
+        WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep);
     }
     else {
-        WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply),
-                      (char *) &rep);
+        WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep);
     }
     return Success;
 }
@@ -406,8 +413,6 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetAllModeLinesReq);
     xXF86VidModeGetAllModeLinesReply rep;
-    xXF86VidModeModeInfo mdinf;
-    xXF86OldVidModeModeInfo oldmdinf;
     pointer mode;
     int modecount, dotClock;
     int ver;
@@ -428,37 +433,40 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
     if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
         return BadValue;
 
-    rep.type = X_Reply;
-    rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
-        SIZEOF(xGenericReply);
+    rep = (xXF86VidModeGetAllModeLinesReply) {
+        .type = X_Reply,
+        .length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
+            SIZEOF(xGenericReply),
+        .sequenceNumber = client->sequence,
+        .modecount = modecount
+    };
     if (ver < 2)
         rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
     else
         rep.length += modecount * sizeof(xXF86VidModeModeInfo);
     rep.length >>= 2;
-    rep.sequenceNumber = client->sequence;
-    rep.modecount = modecount;
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.modecount);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply),
-                  (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep);
 
     do {
-        mdinf.dotclock = dotClock;
-        mdinf.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY);
-        mdinf.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART);
-        mdinf.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND);
-        mdinf.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL);
-        mdinf.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW);
-        mdinf.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY);
-        mdinf.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART);
-        mdinf.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND);
-        mdinf.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
-        mdinf.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
-        mdinf.privsize = 0;
+        xXF86VidModeModeInfo mdinf = {
+            .dotclock = dotClock,
+            .hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
+            .hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
+            .hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
+            .htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL),
+            .hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW),
+            .vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
+            .vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
+            .vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
+            .vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
+            .flags = VidModeGetModeValue(mode, VIDMODE_FLAGS),
+            .privsize = 0
+        };
         if (client->swapped) {
             swapl(&mdinf.dotclock);
             swaps(&mdinf.hdisplay);
@@ -474,23 +482,23 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
             swapl(&mdinf.privsize);
         }
         if (ver < 2) {
-            oldmdinf.dotclock = mdinf.dotclock;
-            oldmdinf.hdisplay = mdinf.hdisplay;
-            oldmdinf.hsyncstart = mdinf.hsyncstart;
-            oldmdinf.hsyncend = mdinf.hsyncend;
-            oldmdinf.htotal = mdinf.htotal;
-            oldmdinf.vdisplay = mdinf.vdisplay;
-            oldmdinf.vsyncstart = mdinf.vsyncstart;
-            oldmdinf.vsyncend = mdinf.vsyncend;
-            oldmdinf.vtotal = mdinf.vtotal;
-            oldmdinf.flags = mdinf.flags;
-            oldmdinf.privsize = mdinf.privsize;
-            WriteToClient(client, sizeof(xXF86OldVidModeModeInfo),
-                          (char *) &oldmdinf);
+            xXF86OldVidModeModeInfo oldmdinf = {
+                .dotclock = mdinf.dotclock,
+                .hdisplay = mdinf.hdisplay,
+                .hsyncstart = mdinf.hsyncstart,
+                .hsyncend = mdinf.hsyncend,
+                .htotal = mdinf.htotal,
+                .vdisplay = mdinf.vdisplay,
+                .vsyncstart = mdinf.vsyncstart,
+                .vsyncend = mdinf.vsyncend,
+                .vtotal = mdinf.vtotal,
+                .flags = mdinf.flags,
+                .privsize = mdinf.privsize
+            };
+            WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf);
         }
         else {
-            WriteToClient(client, sizeof(xXF86VidModeModeInfo),
-                          (char *) &mdinf);
+            WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
         }
 
     } while (VidModeGetNextModeline(stuff->screen, &mode, &dotClock));
@@ -1030,18 +1038,19 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
  status_reply:
     free(modetmp);
 
-    rep.type = X_Reply;
-    rep.length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)
-                                - SIZEOF(xGenericReply));
-    rep.sequenceNumber = client->sequence;
-    rep.status = status;
+    rep = (xXF86VidModeValidateModeLineReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)
+                                 - SIZEOF(xGenericReply)),
+        .status = status
+    };
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.status);
     }
-    WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply),
-                  (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
     if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY)
         ErrorF("ValidateModeLine - Succeeded (status = %d)\n", status);
     return Success;
@@ -1190,7 +1199,10 @@ static int
 ProcXF86VidModeGetMonitor(ClientPtr client)
 {
     REQUEST(xXF86VidModeGetMonitorReq);
-    xXF86VidModeGetMonitorReply rep;
+    xXF86VidModeGetMonitorReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence
+    };
     CARD32 *hsyncdata, *vsyncdata;
     int i, nHsync, nVrefresh;
     pointer monitor;
@@ -1208,7 +1220,6 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
     nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
     nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i;
 
-    rep.type = X_Reply;
     if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr)
         rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor,
                                                                    VIDMODE_MON_VENDOR,
@@ -1227,7 +1238,6 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
                                                 nVrefresh) * sizeof(CARD32) +
                        pad_to_int32(rep.vendorLength) +
                        pad_to_int32(rep.modelLength));
-    rep.sequenceNumber = client->sequence;
     rep.nhsync = nHsync;
     rep.nvsync = nVrefresh;
     hsyncdata = malloc(nHsync * sizeof(CARD32));
@@ -1262,20 +1272,16 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
     }
-    WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), (char *) &rep);
+    WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply), &rep);
     client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
     WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata);
     WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata);
     if (rep.vendorLength)
         WriteToClient(client, rep.vendorLength,
-                      (char
-                       *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR,
-                                                  0)).ptr);
+                 (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr);
     if (rep.modelLength)
         WriteToClient(client, rep.modelLength,
-                      (char
-                       *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL,
-                                                  0)).ptr);
+                 (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr);
 
     free(hsyncdata);
     free(vsyncdata);
@@ -1297,13 +1303,15 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     VidModeGetViewPort(stuff->screen, &x, &y);
-    rep.x = x;
-    rep.y = y;
+
+    rep = (xXF86VidModeGetViewPortReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .x = x,
+        .y = y
+    };
 
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
@@ -1311,7 +1319,7 @@ ProcXF86VidModeGetViewPort(ClientPtr client)
         swapl(&rep.x);
         swapl(&rep.y);
     }
-    WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *) &rep);
+    WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), &rep);
     return Success;
 }
 
@@ -1353,16 +1361,18 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
 
     numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg);
 
-    rep.type = X_Reply;
-    rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
-                                - SIZEOF(xGenericReply) + numClocks);
-    rep.sequenceNumber = client->sequence;
-    rep.clocks = numClocks;
-    rep.maxclocks = MAXCLOCKS;
-    rep.flags = 0;
+    rep = (xXF86VidModeGetDotClocksReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
+                                 - SIZEOF(xGenericReply) + numClocks),
+        .clocks = numClocks,
+        .maxclocks = MAXCLOCKS,
+        .flags = 0
+    };
 
     if (!ClockProg) {
-        Clocks = malloc(numClocks * sizeof(int));
+        Clocks = calloc(numClocks, sizeof(int));
         if (!Clocks)
             return BadValue;
         if (!VidModeGetClocks(stuff->screen, Clocks)) {
@@ -1380,7 +1390,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
         swapl(&rep.maxclocks);
         swapl(&rep.flags);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep);
     if (!ClockProg) {
         for (n = 0; n < numClocks; n++) {
             dotclock = *Clocks++;
@@ -1388,7 +1398,7 @@ ProcXF86VidModeGetDotClocks(ClientPtr client)
                 WriteSwappedDataToClient(client, 4, (char *) &dotclock);
             }
             else {
-                WriteToClient(client, 4, (char *) &dotclock);
+                WriteToClient(client, 4, &dotclock);
             }
         }
     }
@@ -1431,14 +1441,16 @@ ProcXF86VidModeGetGamma(ClientPtr client)
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
     if (!VidModeGetGamma(stuff->screen, &red, &green, &blue))
         return BadValue;
-    rep.red = (CARD32) (red * 10000.);
-    rep.green = (CARD32) (green * 10000.);
-    rep.blue = (CARD32) (blue * 10000.);
+    rep = (xXF86VidModeGetGammaReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .red = (CARD32) (red * 10000.),
+        .green = (CARD32) (green * 10000.),
+        .blue = (CARD32) (blue * 10000.)
+    };
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
@@ -1446,7 +1458,7 @@ ProcXF86VidModeGetGamma(ClientPtr client)
         swapl(&rep.green);
         swapl(&rep.blue);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep);
 
     return Success;
 }
@@ -1489,14 +1501,14 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
 
     REQUEST(xXF86VidModeGetGammaRampReq);
 
+    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
+
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
     if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
         return BadValue;
 
-    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
-
     length = (stuff->size + 1) & ~1;
 
     if (stuff->size) {
@@ -1510,20 +1522,22 @@ ProcXF86VidModeGetGammaRamp(ClientPtr client)
             return BadValue;
         }
     }
-    rep.type = X_Reply;
-    rep.length = (length >> 1) * 3;
-    rep.sequenceNumber = client->sequence;
-    rep.size = stuff->size;
+    rep = (xXF86VidModeGetGammaRampReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = (length >> 1) * 3,
+        .size = stuff->size
+    };
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swaps(&rep.size);
         SwapShorts((short *) ramp, length * 3);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep);
 
     if (stuff->size) {
-        WriteToClient(client, ramplen, (char *) ramp);
+        WriteToClient(client, ramplen, ramp);
         free(ramp);
     }
 
@@ -1537,22 +1551,23 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
 
     REQUEST(xXF86VidModeGetGammaRampSizeReq);
 
+    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
+
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
-    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.size = VidModeGetGammaRampSize(stuff->screen);
+    rep = (xXF86VidModeGetGammaRampSizeReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .size = VidModeGetGammaRampSize(stuff->screen)
+    };
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swaps(&rep.size);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply),
-                  (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep);
 
     return Success;
 }
@@ -1560,19 +1575,20 @@ ProcXF86VidModeGetGammaRampSize(ClientPtr client)
 static int
 ProcXF86VidModeGetPermissions(ClientPtr client)
 {
-    xXF86VidModeGetPermissionsReply rep;
+    xXF86VidModeGetPermissionsReply rep =  {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .permissions = XF86VM_READ_PERMISSION
+    };
 
     REQUEST(xXF86VidModeGetPermissionsReq);
 
+    REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
+
     if (stuff->screen >= screenInfo.numScreens)
         return BadValue;
 
-    REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.permissions = XF86VM_READ_PERMISSION;
     if (xf86GetVidModeEnabled() &&
         (xf86GetVidModeAllowNonLocal() || LocalClient(client))) {
         rep.permissions |= XF86VM_WRITE_PERMISSION;
@@ -1582,8 +1598,7 @@ ProcXF86VidModeGetPermissions(ClientPtr client)
         swapl(&rep.length);
         swapl(&rep.permissions);
     }
-    WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply),
-                  (char *) &rep);
+    WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep);
 
     return Success;
 }
diff --git a/xorg-server/hw/xfree86/common/xf86xv.c b/xorg-server/hw/xfree86/common/xf86xv.c
index 1a964d270..92d0f6da2 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.c
+++ b/xorg-server/hw/xfree86/common/xf86xv.c
@@ -117,10 +117,6 @@ DevPrivateKey XF86XvScreenKey;
 
 static unsigned long PortResource = 0;
 
-DevPrivateKey (*XvGetScreenKeyProc) (void) = NULL;
-unsigned long (*XvGetRTPortProc) (void) = NULL;
-int (*XvScreenInitProc) (ScreenPtr) = NULL;
-
 #define GET_XV_SCREEN(pScreen) \
     ((XvScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XF86XvScreenKey))
 
@@ -238,19 +234,18 @@ xf86XVScreenInit(ScreenPtr pScreen, XF86VideoAdaptorPtr * adaptors, int num)
     XF86XVScreenPtr ScreenPriv;
     XvScreenPtr pxvs;
 
-    if (num <= 0 ||
-        !XvGetScreenKeyProc || !XvGetRTPortProc || !XvScreenInitProc)
+    if (num <= 0 || noXvExtension)
         return FALSE;
 
-    if (Success != (*XvScreenInitProc) (pScreen))
+    if (Success != XvScreenInit(pScreen))
         return FALSE;
 
     if (!dixRegisterPrivateKey(&XF86XVWindowKeyRec, PRIVATE_WINDOW, 0))
         return FALSE;
 
-    XF86XvScreenKey = (*XvGetScreenKeyProc) ();
+    XF86XvScreenKey = XvGetScreenKey();
 
-    PortResource = (*XvGetRTPortProc) ();
+    PortResource = XvGetRTPort();
 
     pxvs = GET_XV_SCREEN(pScreen);
 
diff --git a/xorg-server/hw/xfree86/common/xf86xv.h b/xorg-server/hw/xfree86/common/xf86xv.h
index 2db00a83f..091efcaa9 100644
--- a/xorg-server/hw/xfree86/common/xf86xv.h
+++ b/xorg-server/hw/xfree86/common/xf86xv.h
@@ -263,8 +263,4 @@ extern _X_EXPORT void
 xf86XVCopyPacked(const void *src,
                  void *dst, int srcPitch, int dstPitch, int h, int w);
 
-extern _X_EXPORT DevPrivateKey (*XvGetScreenKeyProc) (void);
-extern _X_EXPORT unsigned long (*XvGetRTPortProc) (void);
-extern _X_EXPORT int (*XvScreenInitProc) (ScreenPtr);
-
 #endif                          /* _XF86XV_H_ */
diff --git a/xorg-server/hw/xfree86/common/xf86xvmc.c b/xorg-server/hw/xfree86/common/xf86xvmc.c
index 2e529dd92..78a32bfe1 100644
--- a/xorg-server/hw/xfree86/common/xf86xvmc.c
+++ b/xorg-server/hw/xfree86/common/xf86xvmc.c
@@ -43,8 +43,6 @@
 #include "xf86xvpriv.h"
 #include "xf86xvmc.h"
 
-XvMCScreenInitProcPtr XvMCScreenInitProc = NULL;
-
 typedef struct {
     CloseScreenProcPtr CloseScreen;
     int num_adaptors;
@@ -154,7 +152,7 @@ xf86XvMCScreenInit(ScreenPtr pScreen,
                                                       XF86XvScreenKey);
     int i, j;
 
-    if (!XvMCScreenInitProc)
+    if (noXvExtension)
         return FALSE;
 
     if (!(pAdapt = malloc(sizeof(XvMCAdaptorRec) * num_adaptors)))
@@ -203,7 +201,7 @@ xf86XvMCScreenInit(ScreenPtr pScreen,
         adaptors++;
     }
 
-    if (Success != (*XvMCScreenInitProc) (pScreen, num_adaptors, pAdapt))
+    if (Success != XvMCScreenInit(pScreen, num_adaptors, pAdapt))
         return FALSE;
 
     return TRUE;
diff --git a/xorg-server/hw/xfree86/common/xf86xvmc.h b/xorg-server/hw/xfree86/common/xf86xvmc.h
index ff32379fe..2478fe344 100644
--- a/xorg-server/hw/xfree86/common/xf86xvmc.h
+++ b/xorg-server/hw/xfree86/common/xf86xvmc.h
@@ -138,7 +138,4 @@ extern _X_EXPORT Bool xf86XvMCScreenInit(ScreenPtr pScreen,
 extern _X_EXPORT XF86MCAdaptorPtr xf86XvMCCreateAdaptorRec(void);
 extern _X_EXPORT void xf86XvMCDestroyAdaptorRec(XF86MCAdaptorPtr adaptor);
 
-typedef int (*XvMCScreenInitProcPtr) (ScreenPtr, int, XvMCAdaptorPtr);
-extern _X_EXPORT XvMCScreenInitProcPtr XvMCScreenInitProc;
-
 #endif                          /* _XF86XVMC_H */
diff --git a/xorg-server/hw/xfree86/dixmods/Makefile.am b/xorg-server/hw/xfree86/dixmods/Makefile.am
index 6f4af6c2c..f161db60a 100644
--- a/xorg-server/hw/xfree86/dixmods/Makefile.am
+++ b/xorg-server/hw/xfree86/dixmods/Makefile.am
@@ -1,39 +1,22 @@
 noinst_LTLIBRARIES = libdixmods.la libxorgxkb.la
 
-SUBDIRS = extmod
-
 if GLX
 GLXMODS = libglx.la
 endif
 
-if DBE
-DBEMOD = libdbe.la
-endif
-
-if RECORD
-RECORDMOD = librecord.la
-endif
-
 module_LTLIBRARIES = libfb.la \
                      libwfb.la \
                      libshadow.la
 
 extsmoduledir = $(moduledir)/extensions
-extsmodule_LTLIBRARIES = $(RECORDMOD) \
-			 $(DBEMOD) \
-                         $(GLXMODS)
+extsmodule_LTLIBRARIES = $(GLXMODS)
 
 AM_CFLAGS = @XORG_CFLAGS@ @DIX_CFLAGS@
 INCLUDES = @XORG_INCS@ \
-           -I$(top_srcdir)/dbe \
            -I$(top_srcdir)/hw/xfree86/loader \
            -I$(top_srcdir)/miext/shadow \
            -I$(top_srcdir)/glx
 
-libdbe_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la
-libdbe_la_SOURCES = dbemodule.c
-
 libfb_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
 libfb_la_LIBADD = $(top_builddir)/fb/libfb.la
 libfb_la_SOURCES = $(top_builddir)/fb/fbcmap_mi.c fbmodule.c
@@ -54,10 +37,6 @@ endif
 endif
 libglx_la_SOURCES = glxmodule.c
 
-librecord_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-librecord_la_LIBADD = $(top_builddir)/record/librecord.la
-librecord_la_SOURCES = recordmod.c
-
 libshadow_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
 libshadow_la_LIBADD = $(top_builddir)/miext/shadow/libshadow.la
 if NO_UNDEFINED
@@ -66,6 +45,6 @@ endif
 libshadow_la_SOURCES = shmodule.c
 
 libdixmods_la_SOURCES = $(top_srcdir)/mi/miinitext.c
-libdixmods_la_CFLAGS = -DXFree86LOADER $(AM_CFLAGS)
+libdixmods_la_CFLAGS = $(AM_CFLAGS)
 
 libxorgxkb_la_SOURCES = xkbVT.c xkbPrivate.c xkbKillSrv.c
diff --git a/xorg-server/hw/xfree86/dixmods/dbemodule.c b/xorg-server/hw/xfree86/dixmods/dbemodule.c
deleted file mode 100644
index 5541eacab..000000000
--- a/xorg-server/hw/xfree86/dixmods/dbemodule.c
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Module.h"
-#include "globals.h"
-
-static MODULESETUPPROTO(dbeSetup);
-
-extern void DbeExtensionInit(INITARGS);
-
-static ExtensionModule dbeExt = {
-    DbeExtensionInit,
-    "DOUBLE-BUFFER",
-    &noDbeExtension,
-    NULL,
-    NULL
-};
-
-static XF86ModuleVersionInfo VersRec = {
-    "dbe",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 0, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_EXTENSION,
-    {0, 0, 0, 0}
-};
-
-/*
- * Data for the loader
- */
-_X_EXPORT XF86ModuleData dbeModuleData = { &VersRec, dbeSetup, NULL };
-
-static pointer
-dbeSetup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    LoadExtension(&dbeExt, FALSE);
-
-    /* Need a non-NULL return value to indicate success */
-    return (pointer) 1;
-}
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/Makefile.am b/xorg-server/hw/xfree86/dixmods/extmod/Makefile.am
deleted file mode 100644
index d08e9ad15..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/Makefile.am
+++ /dev/null
@@ -1,30 +0,0 @@
-sdk_HEADERS = dgaproc.h
-
-extsmoduledir = $(moduledir)/extensions
-extsmodule_LTLIBRARIES = libextmod.la
-
-if DGA
-DGA_SRCS = xf86dga2.c dgaproc.h
-endif
-
-if XV
-XV_SRCS = xvmod.c xvmodproc.h
-endif
-
-if XF86VIDMODE
-XF86VMODE_SRCS = xf86vmode.c
-endif
-
-AM_CFLAGS = @DIX_CFLAGS@ @XORG_CFLAGS@
-INCLUDES = @XORG_INCS@ \
-           -I$(top_srcdir)/dbe \
-           -I$(top_srcdir)/hw/xfree86/loader \
-           -I$(top_srcdir)/miext/shadow
-
-libextmod_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-libextmod_la_SOURCES = modinit.c \
-                       modinit.h \
-                       $(DGA_SRCS) \
-                       $(XF86VMODE_SRCS) \
-                       $(XV_SRCS)
-libextmod_la_LIBADD = $(top_builddir)/Xext/libXextmodule.la
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/modinit.c b/xorg-server/hw/xfree86/dixmods/extmod/modinit.c
deleted file mode 100644
index ca15ee0e7..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/modinit.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 1997 Matthieu Herrb
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Matthieu Herrb not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Matthieu Herrb makes no
- * representations about the suitability of this software for any purpose.
- *  It is provided "as is" without express or implied warranty.
- *
- * MATTHIEU HERRB DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL MATTHIEU HERRB BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Module.h"
-#include "xf86Opt.h"
-
-#include <X11/Xproto.h>
-
-#include "modinit.h"
-#include "globals.h"
-
-static MODULESETUPPROTO(extmodSetup);
-
-/*
- * Array describing extensions to be initialized
- */
-static ExtensionModule extensionModules[] = {
-#ifdef XSELINUX
-    {
-     SELinuxExtensionInit,
-     SELINUX_EXTENSION_NAME,
-     &noSELinuxExtension,
-     NULL,
-     NULL},
-#endif
-#ifdef SCREENSAVER
-    {
-     ScreenSaverExtensionInit,
-     ScreenSaverName,
-     &noScreenSaverExtension,
-     NULL,
-     NULL},
-#endif
-#ifdef XF86VIDMODE
-    {
-     XFree86VidModeExtensionInit,
-     XF86VIDMODENAME,
-     &noXFree86VidModeExtension,
-     NULL,
-     NULL},
-#endif
-#ifdef XFreeXDGA
-    {
-     XFree86DGAExtensionInit,
-     XF86DGANAME,
-     &noXFree86DGAExtension,
-     XFree86DGARegister,
-     NULL},
-#endif
-#ifdef DPMSExtension
-    {
-     DPMSExtensionInit,
-     DPMSExtensionName,
-     &noDPMSExtension,
-     NULL,
-     NULL},
-#endif
-#ifdef XV
-    {
-     XvExtensionInit,
-     XvName,
-     &noXvExtension,
-     XvRegister,
-     NULL},
-    {
-     XvMCExtensionInit,
-     XvMCName,
-     &noXvExtension,
-     NULL,
-     NULL},
-#endif
-#ifdef RES
-    {
-     ResExtensionInit,
-     XRES_NAME,
-     &noResExtension,
-     NULL,
-     NULL},
-#endif
-    {                           /* DON'T delete this entry ! */
-     NULL,
-     NULL,
-     NULL,
-     NULL,
-     NULL}
-};
-
-static XF86ModuleVersionInfo VersRec = {
-    "extmod",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 0, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_EXTENSION,
-    {0, 0, 0, 0}
-};
-
-/*
- * Data for the loader
- */
-_X_EXPORT XF86ModuleData extmodModuleData = { &VersRec, extmodSetup, NULL };
-
-static pointer
-extmodSetup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    int i;
-
-    /* XXX the option stuff here is largely a sample/test case */
-
-    for (i = 0; extensionModules[i].name != NULL; i++) {
-        if (opts) {
-            char *s;
-
-            if (asprintf(&s, "omit%s", extensionModules[i].name) != -1) {
-                pointer o;
-
-                o = xf86FindOption(opts, s);
-                free(s);
-                if (o) {
-                    xf86MarkOptionUsed(o);
-                    continue;
-                }
-            }
-        }
-
-#ifdef XSELINUX
-        if (!strcmp(SELINUX_EXTENSION_NAME, extensionModules[i].name)) {
-            pointer o;
-
-            selinuxEnforcingState = SELINUX_MODE_DEFAULT;
-
-            if ((o = xf86FindOption(opts, "SELinux mode disabled"))) {
-                xf86MarkOptionUsed(o);
-                selinuxEnforcingState = SELINUX_MODE_DISABLED;
-            }
-            if ((o = xf86FindOption(opts, "SELinux mode permissive"))) {
-                xf86MarkOptionUsed(o);
-                selinuxEnforcingState = SELINUX_MODE_PERMISSIVE;
-            }
-            if ((o = xf86FindOption(opts, "SELinux mode enforcing"))) {
-                xf86MarkOptionUsed(o);
-                selinuxEnforcingState = SELINUX_MODE_ENFORCING;
-            }
-        }
-#endif
-
-        LoadExtension(&extensionModules[i], FALSE);
-    }
-    /* Need a non-NULL return */
-    return (pointer) 1;
-}
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/modinit.h b/xorg-server/hw/xfree86/dixmods/extmod/modinit.h
index 9753fe0fd..4c9b6e3cc 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/modinit.h
+++ b/xorg-server/hw/xfree86/dixmods/extmod/modinit.h
@@ -3,91 +3,78 @@
 #include <dix-config.h>
 #endif
 
-#ifndef INITARGS
-#define INITARGS void
-#endif
-
 #include <X11/extensions/shapeproto.h>
 
 #ifdef XTEST
-extern void XTestExtensionInit(INITARGS);
-
+extern void XTestExtensionInit(void);
 #include <X11/extensions/xtestproto.h>
 #endif
 
 #if 1
-extern void XTestExtension1Init(INITARGS);
+extern void XTestExtension1Init(void);
 #endif
 
 #if 1
-extern void XCMiscExtensionInit(INITARGS);
+extern void XCMiscExtensionInit(void);
 #endif
 
 #ifdef SCREENSAVER
-extern void ScreenSaverExtensionInit(INITARGS);
-
+extern void ScreenSaverExtensionInit(void);
 #include <X11/extensions/saver.h>
 #endif
 
 #ifdef XF86VIDMODE
-extern void XFree86VidModeExtensionInit(INITARGS);
-
+extern void XFree86VidModeExtensionInit(void);
 #include <X11/extensions/xf86vmproto.h>
 #endif
 
 #ifdef XFreeXDGA
-extern void XFree86DGAExtensionInit(INITARGS);
-extern void XFree86DGARegister(INITARGS);
-
+extern void XFree86DGAExtensionInit(void);
+extern void XFree86DGARegister(void);
 #include <X11/extensions/xf86dgaproto.h>
 #endif
 
 #ifdef DPMSExtension
-extern void DPMSExtensionInit(INITARGS);
-
+extern void DPMSExtensionInit(void);
 #include <X11/extensions/dpmsconst.h>
 #endif
 
 #ifdef XV
-extern void XvExtensionInit(INITARGS);
-extern void XvMCExtensionInit(INITARGS);
-extern void XvRegister(INITARGS);
-
+extern void XvExtensionInit(void);
+extern void XvMCExtensionInit(void);
+extern void XvRegister(void);
 #include <X11/extensions/Xv.h>
 #include <X11/extensions/XvMC.h>
 #endif
 
 #ifdef RES
-extern void ResExtensionInit(INITARGS);
-
+extern void ResExtensionInit(void);
 #include <X11/extensions/XResproto.h>
 #endif
 
 #ifdef SHM
-extern void ShmExtensionInit(INITARGS);
-
 #include <X11/extensions/shmproto.h>
+extern void ShmExtensionInit(void);
 extern void ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
 #endif
 
 #ifdef XSELINUX
-extern void SELinuxExtensionInit(INITARGS);
-
+extern void SELinuxExtensionInit(void);
 #include "xselinux.h"
 #endif
 
 #ifdef XEVIE
-extern void XevieExtensionInit(INITARGS);
+extern void XevieExtensionInit(void);
 #endif
 
 #if 1
-extern void SecurityExtensionInit(INITARGS);
+extern void SecurityExtensionInit(void);
 #endif
 
 #if 1
-extern void PanoramiXExtensionInit(int argc, char *argv[]);
+extern void PanoramiXExtensionInit(void);
 #endif
 
 #if 1
-extern void XkbExtensionInit(INITARGS);
+extern void XkbExtensionInit(void);
 #endif
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c b/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c
deleted file mode 100644
index 6b33941ef..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/xf86dga2.c
+++ /dev/null
@@ -1,1029 +0,0 @@
-/*
- * Copyright (c) 1995  Jon Tombs
- * Copyright (c) 1995, 1996, 1999  XFree86 Inc
- * Copyright (c) 1999 - The XFree86 Project Inc.
- *
- * Written by Mark Vojkovich
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "misc.h"
-#include "dixstruct.h"
-#include "dixevents.h"
-#include "pixmapstr.h"
-#include "extnsionst.h"
-#include "colormapst.h"
-#include "cursorstr.h"
-#include "scrnintstr.h"
-#include "servermd.h"
-#include <X11/extensions/xf86dgaproto.h>
-#include "swaprep.h"
-#include "dgaproc.h"
-#include "protocol-versions.h"
-
-#include <string.h>
-
-#include "modinit.h"
-
-#define DGA_PROTOCOL_OLD_SUPPORT 1
-
-static void XDGAResetProc(ExtensionEntry * extEntry);
-
-static void DGAClientStateChange(CallbackListPtr *, pointer, pointer);
-
-unsigned char DGAReqCode = 0;
-int DGAErrorBase;
-int DGAEventBase;
-
-static DevPrivateKeyRec DGAScreenPrivateKeyRec;
-
-#define DGAScreenPrivateKey (&DGAScreenPrivateKeyRec)
-#define DGAScreenPrivateKeyRegistered (DGAScreenPrivateKeyRec.initialized)
-static DevPrivateKeyRec DGAClientPrivateKeyRec;
-
-#define DGAClientPrivateKey (&DGAClientPrivateKeyRec)
-static int DGACallbackRefCount = 0;
-
-/* This holds the client's version information */
-typedef struct {
-    int major;
-    int minor;
-} DGAPrivRec, *DGAPrivPtr;
-
-#define DGA_GETCLIENT(idx) ((ClientPtr) \
-    dixLookupPrivate(&screenInfo.screens[idx]->devPrivates, DGAScreenPrivateKey))
-#define DGA_SETCLIENT(idx,p) \
-    dixSetPrivate(&screenInfo.screens[idx]->devPrivates, DGAScreenPrivateKey, p)
-
-#define DGA_GETPRIV(c) ((DGAPrivPtr) \
-    dixLookupPrivate(&(c)->devPrivates, DGAClientPrivateKey))
-#define DGA_SETPRIV(c,p) \
-    dixSetPrivate(&(c)->devPrivates, DGAClientPrivateKey, p)
-
-static void
-XDGAResetProc(ExtensionEntry * extEntry)
-{
-    DeleteCallback(&ClientStateCallback, DGAClientStateChange, NULL);
-    DGACallbackRefCount = 0;
-}
-
-static int
-ProcXDGAQueryVersion(ClientPtr client)
-{
-    xXDGAQueryVersionReply rep;
-
-    REQUEST_SIZE_MATCH(xXDGAQueryVersionReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.majorVersion = SERVER_XDGA_MAJOR_VERSION;
-    rep.minorVersion = SERVER_XDGA_MINOR_VERSION;
-
-    WriteToClient(client, sizeof(xXDGAQueryVersionReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXDGAOpenFramebuffer(ClientPtr client)
-{
-    REQUEST(xXDGAOpenFramebufferReq);
-    xXDGAOpenFramebufferReply rep;
-    char *deviceName;
-    int nameSize;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    REQUEST_SIZE_MATCH(xXDGAOpenFramebufferReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    if (!DGAOpenFramebuffer(stuff->screen, &deviceName,
-                            (unsigned char **) (&rep.mem1),
-                            (int *) &rep.size, (int *) &rep.offset,
-                            (int *) &rep.extra)) {
-        return BadAlloc;
-    }
-
-    nameSize = deviceName ? (strlen(deviceName) + 1) : 0;
-    rep.length = bytes_to_int32(nameSize);
-
-    WriteToClient(client, sizeof(xXDGAOpenFramebufferReply), (char *) &rep);
-    if (rep.length)
-        WriteToClient(client, nameSize, deviceName);
-
-    return Success;
-}
-
-static int
-ProcXDGACloseFramebuffer(ClientPtr client)
-{
-    REQUEST(xXDGACloseFramebufferReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    REQUEST_SIZE_MATCH(xXDGACloseFramebufferReq);
-
-    DGACloseFramebuffer(stuff->screen);
-
-    return Success;
-}
-
-static int
-ProcXDGAQueryModes(ClientPtr client)
-{
-    int i, num, size;
-
-    REQUEST(xXDGAQueryModesReq);
-    xXDGAQueryModesReply rep;
-    xXDGAModeInfo info;
-    XDGAModePtr mode;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXDGAQueryModesReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.number = 0;
-    rep.sequenceNumber = client->sequence;
-
-    if (!DGAAvailable(stuff->screen)) {
-        rep.number = 0;
-        rep.length = 0;
-        WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
-        return Success;
-    }
-
-    if (!(num = DGAGetModes(stuff->screen))) {
-        WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
-        return Success;
-    }
-
-    if (!(mode = (XDGAModePtr) malloc(num * sizeof(XDGAModeRec))))
-        return BadAlloc;
-
-    for (i = 0; i < num; i++)
-        DGAGetModeInfo(stuff->screen, mode + i, i + 1);
-
-    size = num * sz_xXDGAModeInfo;
-    for (i = 0; i < num; i++)
-        size += pad_to_int32(strlen(mode[i].name) + 1); /* plus NULL */
-
-    rep.number = num;
-    rep.length = bytes_to_int32(size);
-
-    WriteToClient(client, sz_xXDGAQueryModesReply, (char *) &rep);
-
-    for (i = 0; i < num; i++) {
-        size = strlen(mode[i].name) + 1;
-
-        info.byte_order = mode[i].byteOrder;
-        info.depth = mode[i].depth;
-        info.num = mode[i].num;
-        info.bpp = mode[i].bitsPerPixel;
-        info.name_size = (size + 3) & ~3L;
-        info.vsync_num = mode[i].VSync_num;
-        info.vsync_den = mode[i].VSync_den;
-        info.flags = mode[i].flags;
-        info.image_width = mode[i].imageWidth;
-        info.image_height = mode[i].imageHeight;
-        info.pixmap_width = mode[i].pixmapWidth;
-        info.pixmap_height = mode[i].pixmapHeight;
-        info.bytes_per_scanline = mode[i].bytesPerScanline;
-        info.red_mask = mode[i].red_mask;
-        info.green_mask = mode[i].green_mask;
-        info.blue_mask = mode[i].blue_mask;
-        info.visual_class = mode[i].visualClass;
-        info.viewport_width = mode[i].viewportWidth;
-        info.viewport_height = mode[i].viewportHeight;
-        info.viewport_xstep = mode[i].xViewportStep;
-        info.viewport_ystep = mode[i].yViewportStep;
-        info.viewport_xmax = mode[i].maxViewportX;
-        info.viewport_ymax = mode[i].maxViewportY;
-        info.viewport_flags = mode[i].viewportFlags;
-        info.reserved1 = mode[i].reserved1;
-        info.reserved2 = mode[i].reserved2;
-
-        WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
-        WriteToClient(client, size, mode[i].name);
-    }
-
-    free(mode);
-
-    return Success;
-}
-
-static void
-DGAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
-{
-    NewClientInfoRec *pci = (NewClientInfoRec *) calldata;
-    ClientPtr client = NULL;
-    int i;
-
-    for (i = 0; i < screenInfo.numScreens; i++) {
-        if (DGA_GETCLIENT(i) == pci->client) {
-            client = pci->client;
-            break;
-        }
-    }
-
-    if (client &&
-        ((client->clientState == ClientStateGone) ||
-         (client->clientState == ClientStateRetained))) {
-        XDGAModeRec mode;
-        PixmapPtr pPix;
-
-        DGA_SETCLIENT(i, NULL);
-        DGASelectInput(i, NULL, 0);
-        DGASetMode(i, 0, &mode, &pPix);
-
-        if (--DGACallbackRefCount == 0)
-            DeleteCallback(&ClientStateCallback, DGAClientStateChange, NULL);
-    }
-}
-
-static int
-ProcXDGASetMode(ClientPtr client)
-{
-    REQUEST(xXDGASetModeReq);
-    xXDGASetModeReply rep;
-    XDGAModeRec mode;
-    xXDGAModeInfo info;
-    PixmapPtr pPix;
-    ClientPtr owner;
-    int size;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-    owner = DGA_GETCLIENT(stuff->screen);
-
-    REQUEST_SIZE_MATCH(xXDGASetModeReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.offset = 0;
-    rep.flags = 0;
-    rep.sequenceNumber = client->sequence;
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (owner && owner != client)
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (!stuff->mode) {
-        if (owner) {
-            if (--DGACallbackRefCount == 0)
-                DeleteCallback(&ClientStateCallback, DGAClientStateChange,
-                               NULL);
-        }
-        DGA_SETCLIENT(stuff->screen, NULL);
-        DGASelectInput(stuff->screen, NULL, 0);
-        DGASetMode(stuff->screen, 0, &mode, &pPix);
-        WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
-        return Success;
-    }
-
-    if (Success != DGASetMode(stuff->screen, stuff->mode, &mode, &pPix))
-        return BadValue;
-
-    if (!owner) {
-        if (DGACallbackRefCount++ == 0)
-            AddCallback(&ClientStateCallback, DGAClientStateChange, NULL);
-    }
-
-    DGA_SETCLIENT(stuff->screen, client);
-
-    if (pPix) {
-        if (AddResource(stuff->pid, RT_PIXMAP, (pointer) (pPix))) {
-            pPix->drawable.id = (int) stuff->pid;
-            rep.flags = DGA_PIXMAP_AVAILABLE;
-        }
-    }
-
-    size = strlen(mode.name) + 1;
-
-    info.byte_order = mode.byteOrder;
-    info.depth = mode.depth;
-    info.num = mode.num;
-    info.bpp = mode.bitsPerPixel;
-    info.name_size = (size + 3) & ~3L;
-    info.vsync_num = mode.VSync_num;
-    info.vsync_den = mode.VSync_den;
-    info.flags = mode.flags;
-    info.image_width = mode.imageWidth;
-    info.image_height = mode.imageHeight;
-    info.pixmap_width = mode.pixmapWidth;
-    info.pixmap_height = mode.pixmapHeight;
-    info.bytes_per_scanline = mode.bytesPerScanline;
-    info.red_mask = mode.red_mask;
-    info.green_mask = mode.green_mask;
-    info.blue_mask = mode.blue_mask;
-    info.visual_class = mode.visualClass;
-    info.viewport_width = mode.viewportWidth;
-    info.viewport_height = mode.viewportHeight;
-    info.viewport_xstep = mode.xViewportStep;
-    info.viewport_ystep = mode.yViewportStep;
-    info.viewport_xmax = mode.maxViewportX;
-    info.viewport_ymax = mode.maxViewportY;
-    info.viewport_flags = mode.viewportFlags;
-    info.reserved1 = mode.reserved1;
-    info.reserved2 = mode.reserved2;
-
-    rep.length = bytes_to_int32(sz_xXDGAModeInfo + info.name_size);
-
-    WriteToClient(client, sz_xXDGASetModeReply, (char *) &rep);
-    WriteToClient(client, sz_xXDGAModeInfo, (char *) (&info));
-    WriteToClient(client, size, mode.name);
-
-    return Success;
-}
-
-static int
-ProcXDGASetViewport(ClientPtr client)
-{
-    REQUEST(xXDGASetViewportReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGASetViewportReq);
-
-    DGASetViewport(stuff->screen, stuff->x, stuff->y, stuff->flags);
-
-    return Success;
-}
-
-static int
-ProcXDGAInstallColormap(ClientPtr client)
-{
-    ColormapPtr cmap;
-    int rc;
-
-    REQUEST(xXDGAInstallColormapReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGAInstallColormapReq);
-
-    rc = dixLookupResourceByType((pointer *) &cmap, stuff->cmap, RT_COLORMAP,
-                                 client, DixInstallAccess);
-    if (rc != Success)
-        return rc;
-    DGAInstallCmap(cmap);
-    return Success;
-}
-
-static int
-ProcXDGASelectInput(ClientPtr client)
-{
-    REQUEST(xXDGASelectInputReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGASelectInputReq);
-
-    if (DGA_GETCLIENT(stuff->screen) == client)
-        DGASelectInput(stuff->screen, client, stuff->mask);
-
-    return Success;
-}
-
-static int
-ProcXDGAFillRectangle(ClientPtr client)
-{
-    REQUEST(xXDGAFillRectangleReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGAFillRectangleReq);
-
-    if (Success != DGAFillRect(stuff->screen, stuff->x, stuff->y,
-                               stuff->width, stuff->height, stuff->color))
-        return BadMatch;
-
-    return Success;
-}
-
-static int
-ProcXDGACopyArea(ClientPtr client)
-{
-    REQUEST(xXDGACopyAreaReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGACopyAreaReq);
-
-    if (Success != DGABlitRect(stuff->screen, stuff->srcx, stuff->srcy,
-                               stuff->width, stuff->height, stuff->dstx,
-                               stuff->dsty))
-        return BadMatch;
-
-    return Success;
-}
-
-static int
-ProcXDGACopyTransparentArea(ClientPtr client)
-{
-    REQUEST(xXDGACopyTransparentAreaReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGACopyTransparentAreaReq);
-
-    if (Success != DGABlitTransRect(stuff->screen, stuff->srcx, stuff->srcy,
-                                    stuff->width, stuff->height, stuff->dstx,
-                                    stuff->dsty, stuff->key))
-        return BadMatch;
-
-    return Success;
-}
-
-static int
-ProcXDGAGetViewportStatus(ClientPtr client)
-{
-    REQUEST(xXDGAGetViewportStatusReq);
-    xXDGAGetViewportStatusReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGAGetViewportStatusReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    rep.status = DGAGetViewportStatus(stuff->screen);
-
-    WriteToClient(client, sizeof(xXDGAGetViewportStatusReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXDGASync(ClientPtr client)
-{
-    REQUEST(xXDGASyncReq);
-    xXDGASyncReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGASyncReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    DGASync(stuff->screen);
-
-    WriteToClient(client, sizeof(xXDGASyncReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXDGASetClientVersion(ClientPtr client)
-{
-    REQUEST(xXDGASetClientVersionReq);
-
-    DGAPrivPtr pPriv;
-
-    REQUEST_SIZE_MATCH(xXDGASetClientVersionReq);
-    if ((pPriv = DGA_GETPRIV(client)) == NULL) {
-        pPriv = malloc(sizeof(DGAPrivRec));
-        /* XXX Need to look into freeing this */
-        if (!pPriv)
-            return BadAlloc;
-        DGA_SETPRIV(client, pPriv);
-    }
-    pPriv->major = stuff->major;
-    pPriv->minor = stuff->minor;
-
-    return Success;
-}
-
-static int
-ProcXDGAChangePixmapMode(ClientPtr client)
-{
-    REQUEST(xXDGAChangePixmapModeReq);
-    xXDGAChangePixmapModeReply rep;
-    int x, y;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGAChangePixmapModeReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    x = stuff->x;
-    y = stuff->y;
-
-    if (!DGAChangePixmapMode(stuff->screen, &x, &y, stuff->flags))
-        return BadMatch;
-
-    rep.x = x;
-    rep.y = y;
-    WriteToClient(client, sizeof(xXDGAChangePixmapModeReply), (char *) &rep);
-
-    return Success;
-}
-
-static int
-ProcXDGACreateColormap(ClientPtr client)
-{
-    REQUEST(xXDGACreateColormapReq);
-    int result;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXDGACreateColormapReq);
-
-    if (!stuff->mode)
-        return BadValue;
-
-    result = DGACreateColormap(stuff->screen, client, stuff->id,
-                               stuff->mode, stuff->alloc);
-    if (result != Success)
-        return result;
-
-    return Success;
-}
-
-/*
- *
- * Support for the old DGA protocol, used to live in xf86dga.c
- *
- */
-
-#ifdef DGA_PROTOCOL_OLD_SUPPORT
-
-static int
-ProcXF86DGAGetVideoLL(ClientPtr client)
-{
-    REQUEST(xXF86DGAGetVideoLLReq);
-    xXF86DGAGetVideoLLReply rep;
-    XDGAModeRec mode;
-    int num, offset, flags;
-    char *name;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXF86DGAGetVideoLLReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (!(num = DGAGetOldDGAMode(stuff->screen)))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    /* get the parameters for the mode that best matches */
-    DGAGetModeInfo(stuff->screen, &mode, num);
-
-    if (!DGAOpenFramebuffer(stuff->screen, &name,
-                            (unsigned char **) (&rep.offset),
-                            (int *) (&rep.bank_size), &offset, &flags))
-        return BadAlloc;
-
-    rep.offset += mode.offset;
-    rep.width = mode.bytesPerScanline / (mode.bitsPerPixel >> 3);
-    rep.ram_size = rep.bank_size >> 10;
-
-    WriteToClient(client, SIZEOF(xXF86DGAGetVideoLLReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXF86DGADirectVideo(ClientPtr client)
-{
-    int num;
-    PixmapPtr pix;
-    XDGAModeRec mode;
-    ClientPtr owner;
-
-    REQUEST(xXF86DGADirectVideoReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-    REQUEST_SIZE_MATCH(xXF86DGADirectVideoReq);
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    owner = DGA_GETCLIENT(stuff->screen);
-
-    if (owner && owner != client)
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (stuff->enable & XF86DGADirectGraphics) {
-        if (!(num = DGAGetOldDGAMode(stuff->screen)))
-            return DGAErrorBase + XF86DGANoDirectVideoMode;
-    }
-    else
-        num = 0;
-
-    if (Success != DGASetMode(stuff->screen, num, &mode, &pix))
-        return DGAErrorBase + XF86DGAScreenNotActive;
-
-    DGASetInputMode(stuff->screen,
-                    (stuff->enable & XF86DGADirectKeyb) != 0,
-                    (stuff->enable & XF86DGADirectMouse) != 0);
-
-    /* We need to track the client and attach the teardown callback */
-    if (stuff->enable &
-        (XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse)) {
-        if (!owner) {
-            if (DGACallbackRefCount++ == 0)
-                AddCallback(&ClientStateCallback, DGAClientStateChange, NULL);
-        }
-
-        DGA_SETCLIENT(stuff->screen, client);
-    }
-    else {
-        if (owner) {
-            if (--DGACallbackRefCount == 0)
-                DeleteCallback(&ClientStateCallback, DGAClientStateChange,
-                               NULL);
-        }
-
-        DGA_SETCLIENT(stuff->screen, NULL);
-    }
-
-    return Success;
-}
-
-static int
-ProcXF86DGAGetViewPortSize(ClientPtr client)
-{
-    int num;
-    XDGAModeRec mode;
-
-    REQUEST(xXF86DGAGetViewPortSizeReq);
-    xXF86DGAGetViewPortSizeReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXF86DGAGetViewPortSizeReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (!(num = DGAGetOldDGAMode(stuff->screen)))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    DGAGetModeInfo(stuff->screen, &mode, num);
-
-    rep.width = mode.viewportWidth;
-    rep.height = mode.viewportHeight;
-
-    WriteToClient(client, SIZEOF(xXF86DGAGetViewPortSizeReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXF86DGASetViewPort(ClientPtr client)
-{
-    REQUEST(xXF86DGASetViewPortReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXF86DGASetViewPortReq);
-
-    if (!DGAAvailable(stuff->screen))
-        return DGAErrorBase + XF86DGANoDirectVideoMode;
-
-    if (!DGAActive(stuff->screen))
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    if (DGASetViewport(stuff->screen, stuff->x, stuff->y, DGA_FLIP_RETRACE)
-        != Success)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    return Success;
-}
-
-static int
-ProcXF86DGAGetVidPage(ClientPtr client)
-{
-    REQUEST(xXF86DGAGetVidPageReq);
-    xXF86DGAGetVidPageReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXF86DGAGetVidPageReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.vpage = 0;              /* silently fail */
-
-    WriteToClient(client, SIZEOF(xXF86DGAGetVidPageReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXF86DGASetVidPage(ClientPtr client)
-{
-    REQUEST(xXF86DGASetVidPageReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXF86DGASetVidPageReq);
-
-    /* silently fail */
-
-    return Success;
-}
-
-static int
-ProcXF86DGAInstallColormap(ClientPtr client)
-{
-    ColormapPtr pcmp;
-    int rc;
-
-    REQUEST(xXF86DGAInstallColormapReq);
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXF86DGAInstallColormapReq);
-
-    if (!DGAActive(stuff->screen))
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    rc = dixLookupResourceByType((pointer *) &pcmp, stuff->id, RT_COLORMAP,
-                                 client, DixInstallAccess);
-    if (rc == Success) {
-        DGAInstallCmap(pcmp);
-        return Success;
-    }
-    else {
-        return rc;
-    }
-}
-
-static int
-ProcXF86DGAQueryDirectVideo(ClientPtr client)
-{
-    REQUEST(xXF86DGAQueryDirectVideoReq);
-    xXF86DGAQueryDirectVideoReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    REQUEST_SIZE_MATCH(xXF86DGAQueryDirectVideoReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.flags = 0;
-
-    if (DGAAvailable(stuff->screen))
-        rep.flags = XF86DGADirectPresent;
-
-    WriteToClient(client, SIZEOF(xXF86DGAQueryDirectVideoReply), (char *) &rep);
-    return Success;
-}
-
-static int
-ProcXF86DGAViewPortChanged(ClientPtr client)
-{
-    REQUEST(xXF86DGAViewPortChangedReq);
-    xXF86DGAViewPortChangedReply rep;
-
-    if (stuff->screen >= screenInfo.numScreens)
-        return BadValue;
-
-    if (DGA_GETCLIENT(stuff->screen) != client)
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    REQUEST_SIZE_MATCH(xXF86DGAViewPortChangedReq);
-
-    if (!DGAActive(stuff->screen))
-        return DGAErrorBase + XF86DGADirectNotActivated;
-
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.result = 1;
-
-    WriteToClient(client, SIZEOF(xXF86DGAViewPortChangedReply), (char *) &rep);
-    return Success;
-}
-
-#endif                          /* DGA_PROTOCOL_OLD_SUPPORT */
-
-static int
-SProcXDGADispatch(ClientPtr client)
-{
-    return DGAErrorBase + XF86DGAClientNotLocal;
-}
-
-#if 0
-#define DGA_REQ_DEBUG
-#endif
-
-#ifdef DGA_REQ_DEBUG
-static char *dgaMinor[] = {
-    "QueryVersion",
-    "GetVideoLL",
-    "DirectVideo",
-    "GetViewPortSize",
-    "SetViewPort",
-    "GetVidPage",
-    "SetVidPage",
-    "InstallColormap",
-    "QueryDirectVideo",
-    "ViewPortChanged",
-    "10",
-    "11",
-    "QueryModes",
-    "SetMode",
-    "SetViewport",
-    "InstallColormap",
-    "SelectInput",
-    "FillRectangle",
-    "CopyArea",
-    "CopyTransparentArea",
-    "GetViewportStatus",
-    "Sync",
-    "OpenFramebuffer",
-    "CloseFramebuffer",
-    "SetClientVersion",
-    "ChangePixmapMode",
-    "CreateColormap",
-};
-#endif
-
-static int
-ProcXDGADispatch(ClientPtr client)
-{
-    REQUEST(xReq);
-
-    if (!LocalClient(client))
-        return DGAErrorBase + XF86DGAClientNotLocal;
-
-#ifdef DGA_REQ_DEBUG
-    if (stuff->data <= X_XDGACreateColormap)
-        fprintf(stderr, "    DGA %s\n", dgaMinor[stuff->data]);
-#endif
-
-    switch (stuff->data) {
-        /*
-         * DGA2 Protocol
-         */
-    case X_XDGAQueryVersion:
-        return ProcXDGAQueryVersion(client);
-    case X_XDGAQueryModes:
-        return ProcXDGAQueryModes(client);
-    case X_XDGASetMode:
-        return ProcXDGASetMode(client);
-    case X_XDGAOpenFramebuffer:
-        return ProcXDGAOpenFramebuffer(client);
-    case X_XDGACloseFramebuffer:
-        return ProcXDGACloseFramebuffer(client);
-    case X_XDGASetViewport:
-        return ProcXDGASetViewport(client);
-    case X_XDGAInstallColormap:
-        return ProcXDGAInstallColormap(client);
-    case X_XDGASelectInput:
-        return ProcXDGASelectInput(client);
-    case X_XDGAFillRectangle:
-        return ProcXDGAFillRectangle(client);
-    case X_XDGACopyArea:
-        return ProcXDGACopyArea(client);
-    case X_XDGACopyTransparentArea:
-        return ProcXDGACopyTransparentArea(client);
-    case X_XDGAGetViewportStatus:
-        return ProcXDGAGetViewportStatus(client);
-    case X_XDGASync:
-        return ProcXDGASync(client);
-    case X_XDGASetClientVersion:
-        return ProcXDGASetClientVersion(client);
-    case X_XDGAChangePixmapMode:
-        return ProcXDGAChangePixmapMode(client);
-    case X_XDGACreateColormap:
-        return ProcXDGACreateColormap(client);
-        /*
-         * Old DGA Protocol
-         */
-#ifdef DGA_PROTOCOL_OLD_SUPPORT
-    case X_XF86DGAGetVideoLL:
-        return ProcXF86DGAGetVideoLL(client);
-    case X_XF86DGADirectVideo:
-        return ProcXF86DGADirectVideo(client);
-    case X_XF86DGAGetViewPortSize:
-        return ProcXF86DGAGetViewPortSize(client);
-    case X_XF86DGASetViewPort:
-        return ProcXF86DGASetViewPort(client);
-    case X_XF86DGAGetVidPage:
-        return ProcXF86DGAGetVidPage(client);
-    case X_XF86DGASetVidPage:
-        return ProcXF86DGASetVidPage(client);
-    case X_XF86DGAInstallColormap:
-        return ProcXF86DGAInstallColormap(client);
-    case X_XF86DGAQueryDirectVideo:
-        return ProcXF86DGAQueryDirectVideo(client);
-    case X_XF86DGAViewPortChanged:
-        return ProcXF86DGAViewPortChanged(client);
-#endif                          /* DGA_PROTOCOL_OLD_SUPPORT */
-    default:
-        return BadRequest;
-    }
-}
-
-void
-XFree86DGARegister(INITARGS)
-{
-    XDGAEventBase = &DGAEventBase;
-}
-
-void
-XFree86DGAExtensionInit(INITARGS)
-{
-    ExtensionEntry *extEntry;
-
-    if (!dixRegisterPrivateKey(&DGAClientPrivateKeyRec, PRIVATE_CLIENT, 0))
-        return;
-
-    if (!dixRegisterPrivateKey(&DGAScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-        return;
-
-    if ((extEntry = AddExtension(XF86DGANAME,
-                                 XF86DGANumberEvents,
-                                 XF86DGANumberErrors,
-                                 ProcXDGADispatch,
-                                 SProcXDGADispatch,
-                                 XDGAResetProc, StandardMinorOpcode))) {
-        int i;
-
-        DGAReqCode = (unsigned char) extEntry->base;
-        DGAErrorBase = extEntry->errorBase;
-        DGAEventBase = extEntry->eventBase;
-        for (i = KeyPress; i <= MotionNotify; i++)
-            SetCriticalEvent(DGAEventBase + i);
-    }
-}
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xvmod.c b/xorg-server/hw/xfree86/dixmods/extmod/xvmod.c
deleted file mode 100644
index 97616c705..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/xvmod.c
+++ /dev/null
@@ -1,22 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "misc.h"
-#include "scrnintstr.h"
-#include "gc.h"
-#include <X11/extensions/Xv.h>
-#include <X11/extensions/Xvproto.h>
-#include "xvdix.h"
-#include "xvmodproc.h"
-
-void
-XvRegister(void)
-{
-    XvScreenInitProc = XvScreenInit;
-    XvGetScreenKeyProc = XvGetScreenKey;
-    XvGetRTPortProc = XvGetRTPort;
-    XvMCScreenInitProc = XvMCScreenInit;
-}
diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xvmodproc.h b/xorg-server/hw/xfree86/dixmods/extmod/xvmodproc.h
deleted file mode 100644
index 009054760..000000000
--- a/xorg-server/hw/xfree86/dixmods/extmod/xvmodproc.h
+++ /dev/null
@@ -1,17 +0,0 @@
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef XVMODPROC_H
-#define XVMODPROC_H
-#include "xvmcext.h"
-
-extern DevPrivateKey (*XvGetScreenKeyProc) (void);
-extern unsigned long (*XvGetRTPortProc) (void);
-extern int (*XvScreenInitProc) (ScreenPtr);
-extern int (*XvMCScreenInitProc) (ScreenPtr, int, XvMCAdaptorPtr);
-
-extern void XvRegister(void);
-
-#endif /* XVMODPROC_H */
diff --git a/xorg-server/hw/xfree86/dixmods/glxmodule.c b/xorg-server/hw/xfree86/dixmods/glxmodule.c
index e72f3821a..5a9e84529 100644
--- a/xorg-server/hw/xfree86/dixmods/glxmodule.c
+++ b/xorg-server/hw/xfree86/dixmods/glxmodule.c
@@ -42,17 +42,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "micmap.h"
 #include "globals.h"
 #include "glxserver.h"
+#include "extinit.h"
 
 static MODULESETUPPROTO(glxSetup);
 
-static const char *initdeps[] = { "DOUBLE-BUFFER", "COMPOSITE", NULL };
-
 static ExtensionModule GLXExt = {
     GlxExtensionInit,
     "GLX",
-    &noGlxExtension,
-    NULL,
-    initdeps
+    &noGlxExtension
 };
 
 static XF86ModuleVersionInfo VersRec = {
@@ -84,11 +81,6 @@ glxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 
     setupDone = TRUE;
 
-    provider = LoaderSymbol("__glXDRISWRastProvider");
-    if (provider == NULL)
-        return NULL;
-    GlxPushProvider(provider);
-
     xf86Msg(xf86Info.aiglxFrom, "AIGLX %s\n",
             xf86Info.aiglx ? "enabled" : "disabled");
     if (xf86Info.aiglx) {
diff --git a/xorg-server/hw/xfree86/dixmods/recordmod.c b/xorg-server/hw/xfree86/dixmods/recordmod.c
deleted file mode 100644
index b75cc3fdb..000000000
--- a/xorg-server/hw/xfree86/dixmods/recordmod.c
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Module.h"
-
-extern Bool noTestExtensions;
-
-static MODULESETUPPROTO(recordSetup);
-
-extern void RecordExtensionInit(INITARGS);
-
-static ExtensionModule recordExt = {
-    RecordExtensionInit,
-    "RECORD",
-    &noTestExtensions,
-    NULL,
-    NULL
-};
-
-static XF86ModuleVersionInfo VersRec = {
-    "record",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 13, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_EXTENSION,
-    {0, 0, 0, 0}
-};
-
-_X_EXPORT XF86ModuleData recordModuleData = { &VersRec, recordSetup, NULL };
-
-static pointer
-recordSetup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    LoadExtension(&recordExt, FALSE);
-
-    /* Need a non-NULL return value to indicate success */
-    return (pointer) 1;
-}
diff --git a/xorg-server/hw/xfree86/doc/README.modes b/xorg-server/hw/xfree86/doc/README.modes
index da9d41eb5..ea228e592 100644
--- a/xorg-server/hw/xfree86/doc/README.modes
+++ b/xorg-server/hw/xfree86/doc/README.modes
@@ -1,474 +1,473 @@
-		    Multi-monitor Mode Setting APIs

-	           Keith Packard, <keithp@keithp.com

-		   	   6 March 2007

-

-1. Introduction

-

-This document describes a set of mode setting APIs added in X server version

-1.3 that support multiple monitors per card. These interfaces expose the

-underlying hardware CRTC and output concepts to the xf86 DDX layer so that

-the implementation of initial server setup and mode changes through

-extensions can be shared across drivers. In addition, these new interfaces

-support a new configuration mechanism as well which allows each monitor to

-be customized separately providing a consistent cross-driver configuration

-mechanism that supports the full range of output features.

-

-All of the code implementing this interface can be found in hw/xfree86/modes

-in the X server sources.

-

-2. Overview

-

-This document describes both the driver API and the configuration data

-placed in xorg.conf; these are entirely separate as the driver has no

-interaction with the configuration information at all. Much of the structure

-here is cloned from the RandR extension version 1.2 additions which deal

-with the same kinds of information.

-

-2.1 API overview

-

-The mode setting API is expressed through two new driver-visible objects,

-the 'CRTC' (xf86CrtcRec) and the 'Output' (xf86OutputRec). A CRTC refers to

-hardware within the video system that can scan a subset of the framebuffer

-and generate a video signal. An Output receives that signal and transmits it

-to a monitor, projector or other device.

-

-The xf86CrtcRec and xf86OutputRec contain a small amount of state data

-related to the object along with a pointer to a set of functions provided by

-the driver that manipulate the object in fairly simple ways.

-

-To emulate older behaviour, one of the outputs is picked as the 'compat'

-output; this output changes over time as outputs are detected and used, the

-goal is to always have one 'special' output which is used for operations

-which need a single defined monitor (like XFree86-VidModeExtension mode

-setting, RandR 1.1 mode setting, DDC property setting, etc.).

-

-2.1.1 Output overview 

-

-As outputs are connected to monitors, they hold a list of modes supported by

-the monitor. If the monitor and output support DDC, then the list of modes

-generally comes from the EDID data in the monitor. Otherwise, the server

-uses the standard VESA modes, pruned by monitor timing. If the configuration

-file doesn't contain monitor timing data, the server uses default timing

-information which supports 640x480, 800x600 and 1024x768 all with a 60Hz

-refresh rate.

-

-As hardware often limits possible configuration combinations, each output

-knows the set of CRTCs that it can be connected to as well as the set of

-other outputs which can be simutaneously connected to a CRTC.

-

-2.1.2 CRTC overview

-

-CRTCs serve only to stream frame buffer data to outputs using a mode line.

-Ideally, they would not be presented to the user at all, and in fact the

-configuration file doesn't expose them. The RandR 1.2 protocol does, but the

-hope there is that client-side applications will hide them carefully away.

-

-Each crtc has an associated cursor, along with the current configuration.

-All of the data needed to determine valid configurations is contained within

-the Outputs.

-

-2.2 Configuration overview

-

-As outputs drive monitors, the "Monitor" section has been repurposed to

-define their configuration. This provides for a bit more syntax than

-the large list of driver-specific options that were used in the past for

-similar configuration.

-

-However, the existing "Monitor" section referenced by the active "Screen"

-section no longer has any use at all; some sensible meaning for this

-parameter is needed now that a Screen can have multiple Monitors.

-

-3. Public Functions

-

-3.1 PreInit functions

-

-These functions should be used during the driver PreInit phase, they are

-arranged in the order they should be invoked.

-

-    void

-    xf86CrtcConfigInit (ScrnInfoPtr			scrn

-			const xf86CrtcConfigFuncsRec	*funcs)

-

-This function allocates and initializes structures needed to track CRTC and

-Output state.

-

-    void

-    xf86CrtcSetSizeRange (ScrnInfoPtr scrn,

-			  int minWidth, int minHeight,

-			  int maxWidth, int maxHeight)

-

-This sets the range of screen sizes supported by the driver.

-

-    xf86CrtcPtr

-    xf86CrtcCreate (ScrnInfoPtr             scrn,

-		    const xf86CrtcFuncsRec  *funcs)

-    

-Create one CRTC object. See the discussion below for a description of the

-contents of the xf86CrtcFuncsRec. Note that this is done in PreInit, so it

-should not be re-invoked at each server generation. Create one of these for

-each CRTC present in the hardware.

-    

-    xf86OutputPtr

-    xf86OutputCreate (ScrnInfoPtr              scrn,

-		      const xf86OutputFuncsRec *funcs,

-		      const char	       *name)

-

-Create one Output object. See the discussion below for a description of the

-contents of the xf86OutputFuncsRec. This is also called from PreInit and

-need not be re-invoked at each ScreenInit time. An Output should be created

-for every Output present in the hardware, not just for outputs which have

-detected monitors.

-    

-    Bool

-    xf86OutputRename (xf86OutputPtr output, const char *name)

-

-If necessary, the name of an output can be changed after it is created using

-this function.

-    

-    Bool

-    xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)

-

-Using the resources provided, and the configuration specified by the user,

-this function computes an initial configuration for the server. It tries to

-enable as much hardware as possible using some fairly simple heuristics. 

-

-The 'canGrow' parameter indicates that the frame buffer does not have a fixed

-size (fixed size frame buffers are required by XAA). When the frame buffer

-has a fixed size, the configuration selects a 'reasonablely large' frame

-buffer so that common reconfiguration options are possible. For resizable

-frame buffers, the frame buffer is set to the smallest size that encloses

-the desired configuration.

-    

-3.2 ScreenInit functions

-

-These functions should be used during the driver ScreenInit phase.

-

-    Bool

-    xf86DiDGAInit (ScreenPtr screen, unsigned long dga_address)

-

-This function provides driver-independent accelerated DGA support for some

-of the DGA operations; using this, the driver can avoid needing to implement

-any of the rest of DGA.

-

-    Bool

-    xf86SaveScreen(ScreenPtr pScreen, int mode)

-

-Stick this in pScreen->SaveScreen and the core X screen saver will be

-implemented by disabling outputs and crtcs using their dpms functions.

-

-    void

-    xf86DPMSSet(ScrnInfoPtr scrn, int mode, int flags)

-

-Pass this function to xf86DPMSInit and all DPMS mode switching will be

-managed by using the dpms functions provided by the Outputs and CRTCs.

-

-    Bool

-    xf86CrtcScreenInit (ScreenPtr screen)

-

-This function completes the screen initialization process for the crtc and

-output objects. Call it near the end of the ScreenInit function, after the

-frame buffer and acceleration layers have been added.

-

-3.3 EnterVT functions

-

-Functions used during EnterVT, or whenever the current configuration needs

-to be applied to the hardware.

-

-    Bool

-    xf86SetDesiredModes (ScrnInfoPtr scrn)

-

-xf86InitialConfiguration selects the desired configuration at PreInit time;

-when the server finally hits ScreenInit, xf86SetDesiredModes is used by the

-driver to take that configuration and apply it to the hardware. In addition,

-successful mode selection at other times updates the configuration that will

-be used by this function, so LeaveVT/EnterVT pairs can simply invoke this

-and return to the previous configuration.

-

-3.4 SwitchMode functions

-

-Functions called from the pScrn->SwitchMode hook, which is used by the

-XFree86-VidModeExtension and the keypad mode switch commands.

-

-    Bool

-    xf86SetSingleMode (ScrnInfoPtr	scrn, 

-		       DisplayModePtr   desired,

-		       Rotation		rotation)

-

-This function applies the specified mode to all active outputs. Which is to

-say, it picks reasonable modes for all active outputs, attempting to get the

-screen to the specified size while not breaking anything that is currently

-working.

-

-3.7 get_modes functions

-

-Functions called during output->get_modes to help build lists of modes

-

-    xf86MonPtr

-    xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)

-

-This returns the EDID data structure for the 'output' using the I2C bus

-'pDDCBus'. This has no effect on 'output' itself.

-

-    void

-    xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)

-

-Once the EDID data has been fetched, this call applies the EDID data to the

-output object, setting the physical size and also various properties, like

-the DDC root window property (when output is the 'compat' output), and the

-RandR 1.2 EDID output properties.

-

-    DisplayModePtr

-    xf86OutputGetEDIDModes (xf86OutputPtr output)

-

-Given an EDID data structure, this function computes a list of suitable

-modes. This function also applies a sequence of 'quirks' during this process

-so that the returned modes may not actually match the mode data present in

-the EDID data.

-

-3.6 Other functions

-

-These remaining functions in the API can be used by the driver as needed.

-

-    Bool

-    xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,

-		     int x, int y)

-

-Applies a mode to a CRTC. All of the outputs which are currently using the

-specified CRTC are included in the mode setting process. 'x' and 'y' are the

-offset within the frame buffer that the crtc is placed at. No checking is

-done in this function to ensure that the mode is usable by the active

-outputs.

-    

-    void

-    xf86ProbeOutputModes (ScrnInfoPtr pScrn, int maxX, int maxY)

-

-This discards the mode lists for all outputs, re-detects monitor presence

-and then acquires new mode lists for all monitors which are not disconnected.

-Monitor configuration data is used to modify the mode lists returned by the

-outputs. 'maxX' and 'maxY' limit the maximum size modes that will be

-returned.

-    

-    void

-    xf86SetScrnInfoModes (ScrnInfoPtr pScrn)

-

-This copies the 'compat' output mode list into the pScrn modes list which is

-used by the XFree86-VidModeExtension and the keypad mode switching

-operations. The current 'desired' mode for the CRTC associated with the

-'compat' output is placed first in this list to indicate the current mode.

-Usually, the driver won't need to call this function as

-xf86InitialConfiguration will do so automatically, as well as any RandR

-functions which reprobe for modes. However, if the driver reprobes for modes

-at other times using xf86ProbeOutputModes, this function needs to be called.

-    

-    Bool

-    xf86DiDGAReInit (ScreenPtr pScreen)

-

-This is similar to xf86SetScrnInfoModes, but it applies the 'compat' output

-mode list to the set of modes advertised by the DGA extension; it needs to

-be called whenever xf86ProbeOutputModes is invoked.

-

-    void

-    xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)

-

-After any sequence of calls using xf86CrtcSetMode, this function cleans up

-any leftover Output and CRTC objects by disabling them, saving power. It is

-safe to call this whenever the server is running as it only disables objects

-which are not currently in use.

-    

-4. CRTC operations

-

-4.1 CRTC functions

-

-These functions provide an abstract interface for the CRTC object; most

-manipulation of the CRTC object is done through these functions.

-

-    void

-    crtc->funcs->dpms (xf86CrtcPtr crtc, int mode)

-

-Where 'mode' is one of DPMSModeOff, DPMSModeSuspend, DPMSModeStandby or

-DPMSModeOn. This requests that the crtc go to the specified power state.

-When changing power states, the output dpms functions are invoked before the

-crtc dpms functions.

-

-    void

-    crtc->funcs->save (xf86CrtcPtr crtc)

-	

-    void

-    crtc->funcs->restore (xf86CrtcPtr crtc)

-

-Preserve/restore any register contents related to the CRTC. These are

-strictly a convenience for the driver writer; if the existing driver has

-fully operation save/restore functions, you need not place any additional

-code here. In particular, the server itself never uses this function.

-

-    Bool

-    crtc->funcs->lock (xf86CrtcPtr crtc)

-	

-    void

-    crtc->funcs->unlock (xf86CrtcPtr crtc)

-

-These functions are invoked around mode setting operations; the intent is

-that DRI locking be done here to prevent DRI applications from manipulating

-the hardware while the server is busy changing the output configuration. If

-the lock function returns FALSE, the unlock function will not be invoked.

-

-    Bool

-    crtc->funcs->mode_fixup (xf86CrtcPtr crtc, 

-			     DisplayModePtr mode,

-			     DisplayModePtr adjusted_mode)

-

-This call gives the CRTC a chance to see what mode will be set and to

-comment on the mode by changing 'adjusted_mode' as needed. This function

-shall not modify the state of the crtc hardware at all. If the CRTC cannot

-accept this mode, this function may return FALSE.

-

-    void

-    crtc->funcs->prepare (xf86CrtcPtr crtc)

-

-This call is made just before the mode is set to make the hardware ready for

-the operation. A usual function to perform here is to disable the crtc so

-that mode setting can occur with clocks turned off and outputs deactivated.

-

-    void

-    crtc->funcs->mode_set (xf86CrtcPtr crtc,

-			   DisplayModePtr mode,

-			   DisplayModePtr adjusted_mode)

-

-This function applies the specified mode (possibly adjusted by the CRTC

-and/or Outputs).

-

-    void

-    crtc->funcs->commit (xf86CrtcPtr crtc)

-

-Once the mode has been applied to the CRTC and Outputs, this function is

-invoked to let the hardware turn things back on.

-

-    void

-    crtc->funcs->gamma_set (xf86CrtcPtr crtc, CARD16 *red,

-			    CARD16 *green, CARD16 *blue, int size)

-

-This function adjusts the gamma ramps for the specified crtc.

-

-    void *

-    crtc->funcs->shadow_allocate (xf86CrtcPtr crtc, int width, int height)

-

-This function allocates frame buffer space for a shadow frame buffer. When

-allocated, the crtc must scan from the shadow instead of the main frame

-buffer. This is used for rotation. The address returned is passed to the

-shadow_create function. This function should return NULL on failure.

-

-    PixmapPtr

-    crtc->funcs->shadow_create (xf86CrtcPtr crtc, void *data,

-				int width, int height)

-

-This function creates a pixmap object that will be used as a shadow of the

-main frame buffer for CRTCs which are rotated or reflected. 'data' is the

-value returned by shadow_allocate.

-

-    void

-    crtc->funcs->shadow_destroy (xf86CrtcPtr crtc, PixmapPtr pPixmap,

-				 void *data)

-

-Destroys any associated shadow objects. If pPixmap is NULL, then a pixmap

-was not created, but 'data' may still be non-NULL indicating that the shadow

-had been allocated.

-

-    void

-    crtc->funcs->destroy (xf86CrtcPtr crtc)

-

-When a CRTC is destroyed (which only happens in error cases), this function

-can clean up any driver-specific data.

-

-4.2 CRTC fields

-

-The CRTC object is not opaque; there are several fields of interest to the

-driver writer.

-

-    struct _xf86Crtc {

-	/**

-	 * Associated ScrnInfo

-	 */

-	ScrnInfoPtr     scrn;

-    

-	/**

-	 * Active state of this CRTC

-	 *

-	 * Set when this CRTC is driving one or more outputs

-	 */

-	Bool            enabled;

-    

-	/** Track whether cursor is within CRTC range  */

-	Bool            cursorInRange;

-    

-	/** Track state of cursor associated with this CRTC */

-	Bool            cursorShown;

-    

-	/**

-	 * Active mode

-	 *

-	 * This reflects the mode as set in the CRTC currently

-	 * It will be cleared when the VT is not active or

-	 * during server startup

-	 */

-	DisplayModeRec  mode;

-	Rotation        rotation;

-	PixmapPtr       rotatedPixmap;

-	void            *rotatedData;

-    

-	/**

-	 * Position on screen

-	 *

-	 * Locates this CRTC within the frame buffer

-	 */

-	int             x, y;

-    

-	/**

-	 * Desired mode

-	 *

-	 * This is set to the requested mode, independent of

-	 * whether the VT is active. In particular, it receives

-	 * the startup configured mode and saves the active mode

-	 * on VT switch.

-	 */

-	DisplayModeRec  desiredMode;

-	Rotation        desiredRotation;

-	int             desiredX, desiredY;

-    

-	/** crtc-specific functions */

-	const xf86CrtcFuncsRec *funcs;

-    

-	/**

-	 * Driver private

-	 *

-	 * Holds driver-private information

-	 */

-	void            *driver_private;

-    #ifdef RANDR_12_INTERFACE

-	/**

-	 * RandR crtc

-	 *

-	 * When RandR 1.2 is available, this

-	 * points at the associated crtc object

-	 */

-	RRCrtcPtr       randr_crtc;

-    #else

-	void            *randr_crtc;

-    #endif

-    };

-

-    

-5. Output functions.

-

-6. Configuration

-

-Because the configuration file syntax is fixed,

-this was done by creating new "Driver" section options that hook specific

-outputs to specific "Monitor" sections in the file. The option:

-section of the form:

-

-	Option	"monitor-VGA" "My VGA Monitor"

-

-connects the VGA output of this driver to the "Monitor" section with

-Identifier "My VGA Monitor". All of the usual monitor options can now be

-placed in that "Monitor" section and will be applied to the VGA output

-configuration.

+		    Multi-monitor Mode Setting APIs
+	           Keith Packard, <keithp@keithp.com
+		   	   6 March 2007
+
+1. Introduction
+
+This document describes a set of mode setting APIs added in X server version
+1.3 that support multiple monitors per card. These interfaces expose the
+underlying hardware CRTC and output concepts to the xf86 DDX layer so that
+the implementation of initial server setup and mode changes through
+extensions can be shared across drivers. In addition, these new interfaces
+support a new configuration mechanism as well which allows each monitor to
+be customized separately providing a consistent cross-driver configuration
+mechanism that supports the full range of output features.
+
+All of the code implementing this interface can be found in hw/xfree86/modes
+in the X server sources.
+
+2. Overview
+
+This document describes both the driver API and the configuration data
+placed in xorg.conf; these are entirely separate as the driver has no
+interaction with the configuration information at all. Much of the structure
+here is cloned from the RandR extension version 1.2 additions which deal
+with the same kinds of information.
+
+2.1 API overview
+
+The mode setting API is expressed through two new driver-visible objects,
+the 'CRTC' (xf86CrtcRec) and the 'Output' (xf86OutputRec). A CRTC refers to
+hardware within the video system that can scan a subset of the framebuffer
+and generate a video signal. An Output receives that signal and transmits it
+to a monitor, projector or other device.
+
+The xf86CrtcRec and xf86OutputRec contain a small amount of state data
+related to the object along with a pointer to a set of functions provided by
+the driver that manipulate the object in fairly simple ways.
+
+To emulate older behaviour, one of the outputs is picked as the 'compat'
+output; this output changes over time as outputs are detected and used, the
+goal is to always have one 'special' output which is used for operations
+which need a single defined monitor (like XFree86-VidModeExtension mode
+setting, RandR 1.1 mode setting, DDC property setting, etc.).
+
+2.1.1 Output overview 
+
+As outputs are connected to monitors, they hold a list of modes supported by
+the monitor. If the monitor and output support DDC, then the list of modes
+generally comes from the EDID data in the monitor. Otherwise, the server
+uses the standard VESA modes, pruned by monitor timing. If the configuration
+file doesn't contain monitor timing data, the server uses default timing
+information which supports 640x480, 800x600 and 1024x768 all with a 60Hz
+refresh rate.
+
+As hardware often limits possible configuration combinations, each output
+knows the set of CRTCs that it can be connected to as well as the set of
+other outputs which can be simutaneously connected to a CRTC.
+
+2.1.2 CRTC overview
+
+CRTCs serve only to stream frame buffer data to outputs using a mode line.
+Ideally, they would not be presented to the user at all, and in fact the
+configuration file doesn't expose them. The RandR 1.2 protocol does, but the
+hope there is that client-side applications will hide them carefully away.
+
+Each crtc has an associated cursor, along with the current configuration.
+All of the data needed to determine valid configurations is contained within
+the Outputs.
+
+2.2 Configuration overview
+
+As outputs drive monitors, the "Monitor" section has been repurposed to
+define their configuration. This provides for a bit more syntax than
+the large list of driver-specific options that were used in the past for
+similar configuration.
+
+However, the existing "Monitor" section referenced by the active "Screen"
+section no longer has any use at all; some sensible meaning for this
+parameter is needed now that a Screen can have multiple Monitors.
+
+3. Public Functions
+
+3.1 PreInit functions
+
+These functions should be used during the driver PreInit phase, they are
+arranged in the order they should be invoked.
+
+    void
+    xf86CrtcConfigInit (ScrnInfoPtr			scrn
+			const xf86CrtcConfigFuncsRec	*funcs)
+
+This function allocates and initializes structures needed to track CRTC and
+Output state.
+
+    void
+    xf86CrtcSetSizeRange (ScrnInfoPtr scrn,
+			  int minWidth, int minHeight,
+			  int maxWidth, int maxHeight)
+
+This sets the range of screen sizes supported by the driver.
+
+    xf86CrtcPtr
+    xf86CrtcCreate (ScrnInfoPtr             scrn,
+		    const xf86CrtcFuncsRec  *funcs)
+    
+Create one CRTC object. See the discussion below for a description of the
+contents of the xf86CrtcFuncsRec. Note that this is done in PreInit, so it
+should not be re-invoked at each server generation. Create one of these for
+each CRTC present in the hardware.
+    
+    xf86OutputPtr
+    xf86OutputCreate (ScrnInfoPtr              scrn,
+		      const xf86OutputFuncsRec *funcs,
+		      const char	       *name)
+
+Create one Output object. See the discussion below for a description of the
+contents of the xf86OutputFuncsRec. This is also called from PreInit and
+need not be re-invoked at each ScreenInit time. An Output should be created
+for every Output present in the hardware, not just for outputs which have
+detected monitors.
+    
+    Bool
+    xf86OutputRename (xf86OutputPtr output, const char *name)
+
+If necessary, the name of an output can be changed after it is created using
+this function.
+    
+    Bool
+    xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
+
+Using the resources provided, and the configuration specified by the user,
+this function computes an initial configuration for the server. It tries to
+enable as much hardware as possible using some fairly simple heuristics. 
+
+The 'canGrow' parameter indicates that the frame buffer does not have a fixed
+size. When the frame buffer has a fixed size, the configuration selects a
+'reasonablely large' frame buffer so that common reconfiguration options are
+possible. For resizable frame buffers, the frame buffer is set to the smallest
+size that encloses the desired configuration.
+    
+3.2 ScreenInit functions
+
+These functions should be used during the driver ScreenInit phase.
+
+    Bool
+    xf86DiDGAInit (ScreenPtr screen, unsigned long dga_address)
+
+This function provides driver-independent accelerated DGA support for some
+of the DGA operations; using this, the driver can avoid needing to implement
+any of the rest of DGA.
+
+    Bool
+    xf86SaveScreen(ScreenPtr pScreen, int mode)
+
+Stick this in pScreen->SaveScreen and the core X screen saver will be
+implemented by disabling outputs and crtcs using their dpms functions.
+
+    void
+    xf86DPMSSet(ScrnInfoPtr scrn, int mode, int flags)
+
+Pass this function to xf86DPMSInit and all DPMS mode switching will be
+managed by using the dpms functions provided by the Outputs and CRTCs.
+
+    Bool
+    xf86CrtcScreenInit (ScreenPtr screen)
+
+This function completes the screen initialization process for the crtc and
+output objects. Call it near the end of the ScreenInit function, after the
+frame buffer and acceleration layers have been added.
+
+3.3 EnterVT functions
+
+Functions used during EnterVT, or whenever the current configuration needs
+to be applied to the hardware.
+
+    Bool
+    xf86SetDesiredModes (ScrnInfoPtr scrn)
+
+xf86InitialConfiguration selects the desired configuration at PreInit time;
+when the server finally hits ScreenInit, xf86SetDesiredModes is used by the
+driver to take that configuration and apply it to the hardware. In addition,
+successful mode selection at other times updates the configuration that will
+be used by this function, so LeaveVT/EnterVT pairs can simply invoke this
+and return to the previous configuration.
+
+3.4 SwitchMode functions
+
+Functions called from the pScrn->SwitchMode hook, which is used by the
+XFree86-VidModeExtension and the keypad mode switch commands.
+
+    Bool
+    xf86SetSingleMode (ScrnInfoPtr	scrn, 
+		       DisplayModePtr   desired,
+		       Rotation		rotation)
+
+This function applies the specified mode to all active outputs. Which is to
+say, it picks reasonable modes for all active outputs, attempting to get the
+screen to the specified size while not breaking anything that is currently
+working.
+
+3.7 get_modes functions
+
+Functions called during output->get_modes to help build lists of modes
+
+    xf86MonPtr
+    xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)
+
+This returns the EDID data structure for the 'output' using the I2C bus
+'pDDCBus'. This has no effect on 'output' itself.
+
+    void
+    xf86OutputSetEDID (xf86OutputPtr output, xf86MonPtr edid_mon)
+
+Once the EDID data has been fetched, this call applies the EDID data to the
+output object, setting the physical size and also various properties, like
+the DDC root window property (when output is the 'compat' output), and the
+RandR 1.2 EDID output properties.
+
+    DisplayModePtr
+    xf86OutputGetEDIDModes (xf86OutputPtr output)
+
+Given an EDID data structure, this function computes a list of suitable
+modes. This function also applies a sequence of 'quirks' during this process
+so that the returned modes may not actually match the mode data present in
+the EDID data.
+
+3.6 Other functions
+
+These remaining functions in the API can be used by the driver as needed.
+
+    Bool
+    xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
+		     int x, int y)
+
+Applies a mode to a CRTC. All of the outputs which are currently using the
+specified CRTC are included in the mode setting process. 'x' and 'y' are the
+offset within the frame buffer that the crtc is placed at. No checking is
+done in this function to ensure that the mode is usable by the active
+outputs.
+    
+    void
+    xf86ProbeOutputModes (ScrnInfoPtr pScrn, int maxX, int maxY)
+
+This discards the mode lists for all outputs, re-detects monitor presence
+and then acquires new mode lists for all monitors which are not disconnected.
+Monitor configuration data is used to modify the mode lists returned by the
+outputs. 'maxX' and 'maxY' limit the maximum size modes that will be
+returned.
+    
+    void
+    xf86SetScrnInfoModes (ScrnInfoPtr pScrn)
+
+This copies the 'compat' output mode list into the pScrn modes list which is
+used by the XFree86-VidModeExtension and the keypad mode switching
+operations. The current 'desired' mode for the CRTC associated with the
+'compat' output is placed first in this list to indicate the current mode.
+Usually, the driver won't need to call this function as
+xf86InitialConfiguration will do so automatically, as well as any RandR
+functions which reprobe for modes. However, if the driver reprobes for modes
+at other times using xf86ProbeOutputModes, this function needs to be called.
+    
+    Bool
+    xf86DiDGAReInit (ScreenPtr pScreen)
+
+This is similar to xf86SetScrnInfoModes, but it applies the 'compat' output
+mode list to the set of modes advertised by the DGA extension; it needs to
+be called whenever xf86ProbeOutputModes is invoked.
+
+    void
+    xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)
+
+After any sequence of calls using xf86CrtcSetMode, this function cleans up
+any leftover Output and CRTC objects by disabling them, saving power. It is
+safe to call this whenever the server is running as it only disables objects
+which are not currently in use.
+    
+4. CRTC operations
+
+4.1 CRTC functions
+
+These functions provide an abstract interface for the CRTC object; most
+manipulation of the CRTC object is done through these functions.
+
+    void
+    crtc->funcs->dpms (xf86CrtcPtr crtc, int mode)
+
+Where 'mode' is one of DPMSModeOff, DPMSModeSuspend, DPMSModeStandby or
+DPMSModeOn. This requests that the crtc go to the specified power state.
+When changing power states, the output dpms functions are invoked before the
+crtc dpms functions.
+
+    void
+    crtc->funcs->save (xf86CrtcPtr crtc)
+	
+    void
+    crtc->funcs->restore (xf86CrtcPtr crtc)
+
+Preserve/restore any register contents related to the CRTC. These are
+strictly a convenience for the driver writer; if the existing driver has
+fully operation save/restore functions, you need not place any additional
+code here. In particular, the server itself never uses this function.
+
+    Bool
+    crtc->funcs->lock (xf86CrtcPtr crtc)
+	
+    void
+    crtc->funcs->unlock (xf86CrtcPtr crtc)
+
+These functions are invoked around mode setting operations; the intent is
+that DRI locking be done here to prevent DRI applications from manipulating
+the hardware while the server is busy changing the output configuration. If
+the lock function returns FALSE, the unlock function will not be invoked.
+
+    Bool
+    crtc->funcs->mode_fixup (xf86CrtcPtr crtc, 
+			     DisplayModePtr mode,
+			     DisplayModePtr adjusted_mode)
+
+This call gives the CRTC a chance to see what mode will be set and to
+comment on the mode by changing 'adjusted_mode' as needed. This function
+shall not modify the state of the crtc hardware at all. If the CRTC cannot
+accept this mode, this function may return FALSE.
+
+    void
+    crtc->funcs->prepare (xf86CrtcPtr crtc)
+
+This call is made just before the mode is set to make the hardware ready for
+the operation. A usual function to perform here is to disable the crtc so
+that mode setting can occur with clocks turned off and outputs deactivated.
+
+    void
+    crtc->funcs->mode_set (xf86CrtcPtr crtc,
+			   DisplayModePtr mode,
+			   DisplayModePtr adjusted_mode)
+
+This function applies the specified mode (possibly adjusted by the CRTC
+and/or Outputs).
+
+    void
+    crtc->funcs->commit (xf86CrtcPtr crtc)
+
+Once the mode has been applied to the CRTC and Outputs, this function is
+invoked to let the hardware turn things back on.
+
+    void
+    crtc->funcs->gamma_set (xf86CrtcPtr crtc, CARD16 *red,
+			    CARD16 *green, CARD16 *blue, int size)
+
+This function adjusts the gamma ramps for the specified crtc.
+
+    void *
+    crtc->funcs->shadow_allocate (xf86CrtcPtr crtc, int width, int height)
+
+This function allocates frame buffer space for a shadow frame buffer. When
+allocated, the crtc must scan from the shadow instead of the main frame
+buffer. This is used for rotation. The address returned is passed to the
+shadow_create function. This function should return NULL on failure.
+
+    PixmapPtr
+    crtc->funcs->shadow_create (xf86CrtcPtr crtc, void *data,
+				int width, int height)
+
+This function creates a pixmap object that will be used as a shadow of the
+main frame buffer for CRTCs which are rotated or reflected. 'data' is the
+value returned by shadow_allocate.
+
+    void
+    crtc->funcs->shadow_destroy (xf86CrtcPtr crtc, PixmapPtr pPixmap,
+				 void *data)
+
+Destroys any associated shadow objects. If pPixmap is NULL, then a pixmap
+was not created, but 'data' may still be non-NULL indicating that the shadow
+had been allocated.
+
+    void
+    crtc->funcs->destroy (xf86CrtcPtr crtc)
+
+When a CRTC is destroyed (which only happens in error cases), this function
+can clean up any driver-specific data.
+
+4.2 CRTC fields
+
+The CRTC object is not opaque; there are several fields of interest to the
+driver writer.
+
+    struct _xf86Crtc {
+	/**
+	 * Associated ScrnInfo
+	 */
+	ScrnInfoPtr     scrn;
+    
+	/**
+	 * Active state of this CRTC
+	 *
+	 * Set when this CRTC is driving one or more outputs
+	 */
+	Bool            enabled;
+    
+	/** Track whether cursor is within CRTC range  */
+	Bool            cursorInRange;
+    
+	/** Track state of cursor associated with this CRTC */
+	Bool            cursorShown;
+    
+	/**
+	 * Active mode
+	 *
+	 * This reflects the mode as set in the CRTC currently
+	 * It will be cleared when the VT is not active or
+	 * during server startup
+	 */
+	DisplayModeRec  mode;
+	Rotation        rotation;
+	PixmapPtr       rotatedPixmap;
+	void            *rotatedData;
+    
+	/**
+	 * Position on screen
+	 *
+	 * Locates this CRTC within the frame buffer
+	 */
+	int             x, y;
+    
+	/**
+	 * Desired mode
+	 *
+	 * This is set to the requested mode, independent of
+	 * whether the VT is active. In particular, it receives
+	 * the startup configured mode and saves the active mode
+	 * on VT switch.
+	 */
+	DisplayModeRec  desiredMode;
+	Rotation        desiredRotation;
+	int             desiredX, desiredY;
+    
+	/** crtc-specific functions */
+	const xf86CrtcFuncsRec *funcs;
+    
+	/**
+	 * Driver private
+	 *
+	 * Holds driver-private information
+	 */
+	void            *driver_private;
+    #ifdef RANDR_12_INTERFACE
+	/**
+	 * RandR crtc
+	 *
+	 * When RandR 1.2 is available, this
+	 * points at the associated crtc object
+	 */
+	RRCrtcPtr       randr_crtc;
+    #else
+	void            *randr_crtc;
+    #endif
+    };
+
+    
+5. Output functions.
+
+6. Configuration
+
+Because the configuration file syntax is fixed,
+this was done by creating new "Driver" section options that hook specific
+outputs to specific "Monitor" sections in the file. The option:
+section of the form:
+
+	Option	"monitor-VGA" "My VGA Monitor"
+
+connects the VGA output of this driver to the "Monitor" section with
+Identifier "My VGA Monitor". All of the usual monitor options can now be
+placed in that "Monitor" section and will be applied to the VGA output
+configuration.
diff --git a/xorg-server/hw/xfree86/doc/ddxDesign.xml b/xorg-server/hw/xfree86/doc/ddxDesign.xml
index 24b0c0324..4c2ca47da 100644
--- a/xorg-server/hw/xfree86/doc/ddxDesign.xml
+++ b/xorg-server/hw/xfree86/doc/ddxDesign.xml
@@ -330,8 +330,8 @@ that.  This is a significant difference compared with the old design.
 
     <para>
 The entry points for drawing operations are already taken care of by
-the framebuffer code (including, XAA).  Extensions and enhancements to
-framebuffer code are outside the scope of this document.
+the framebuffer code.  Extensions and enhancements to framebuffer code
+are outside the scope of this document.
     </para>
 
     <para>
@@ -2003,10 +2003,9 @@ also include the video card's saved state.
       </para>
 
       <para>
-Per-screen data for other modules that the driver uses (for example,
-the XAA module) that is reset for each server generation is hooked into
-the <structname>ScrnInfoRec</structname> through it's <structfield>privates</structfield>
-field.
+Per-screen data for other modules that the driver uses that is reset for each
+server generation is hooked into the <structname>ScrnInfoRec</structname>
+through its <structfield>privates</structfield> field.
       </para>
 
       <para>
@@ -3615,14 +3614,6 @@ The following include files are typically required by video drivers:
 	  </para>
 
 	  <para>
-  If a driver uses XAA, it needs these:
-	    <literallayout><filename>
-    "xaa.h"
-    "xaalocal.h"
-	      </filename></literallayout>
-	  </para>
-
-	  <para>
   If a driver uses the fb manager, it needs this:
 	    <literallayout><filename>
     "xf86fbman.h"
@@ -3840,31 +3831,6 @@ manager is allowed to manage.  This is typically a box with a width of
 can be fit within the total video memory, however, the driver can reserve
 areas at the extremities by passing a smaller area to the manager.
     </para>
-
-    <para>
-<function>xf86InitFBManager()</function> must be called before XAA is
-initialized since XAA uses the manager for it's pixmap cache.
-    </para>
-
-    <para>
-An alternative function is provided to allow the driver to initialize
-the framebuffer manager with a Region rather than a box.
-
-    <programlisting>
-    Bool xf86InitFBManagerRegion(ScreenPtr pScreen,
-                                 RegionPtr FullRegion);
-    </programlisting>
-
-<function>xf86InitFBManagerRegion()</function>, unlike
-<function>xf86InitFBManager()</function>, does not remove the area used for
-the visible screen so that area should not be included in the region
-passed to the function.  <function>xf86InitFBManagerRegion()</function> is
-useful when non-contiguous areas are available to be managed, and is
-required when multiple framebuffers are stored in video memory (as in
-the case where an overlay of a different depth is stored as a second
-framebuffer in offscreen memory).
-    </para>
-
   </sect1>
 
   <sect1 id="cmap">
@@ -5363,15 +5329,6 @@ XFree86 common layer.
 		  way by modules loaded directly by the XFree86 common
 		  layer.  However, it may be used for application-specific
 		  parameter passing in other situations.
-		    </para>
-
-		    <para>
-		  When loading <quote>external</quote> modules (modules that don't
-		  have the standard entry point, for example a
-		  special shared library) the options parameter can be
-		  set to <constant>EXTERN_MODULE</constant> to tell the
-		  loader not to reject the module when it doesn't find
-		  the standard entry point.
 		    </para></listitem></varlistentry>
 
 
@@ -5982,7 +5939,6 @@ typedef struct {
     InitExtension       initFunc;
     char *              name;
     Bool                *disablePtr;
-    InitExtension       setupFunc;
 } ExtensionModule;
 	      </programlisting>
 	    </para>
@@ -8910,12 +8866,6 @@ ZZZPreInit(ScrnInfoPtr pScrn, int flags)
         ZZZFreeRec(pScrn);
         return FALSE;
 
-    /* Load XAA if needed */
-    if (!pZzz-&gt;noAccel || pZzz-&gt;hwCursor)
-        if (!xf86LoadSubModule(pScrn, "xaa")) {
-            ZZZFreeRec(pScrn);
-            return FALSE;
-        }
 
     /* Done */
     return TRUE;
diff --git a/xorg-server/hw/xfree86/doc/exa-driver.txt b/xorg-server/hw/xfree86/doc/exa-driver.txt
index 048307ee7..da39d3f91 100644
--- a/xorg-server/hw/xfree86/doc/exa-driver.txt
+++ b/xorg-server/hw/xfree86/doc/exa-driver.txt
@@ -8,15 +8,10 @@ from system memory, and Porter-Duff compositing and transform operations.
 
 Configuration
 -------------
-A new config file option, AccelMethod, should be added to your driver, to allow
-the user to select between the EXA and XAA acceleration APIs.
-
 Some drivers implement a per-instance useEXA flag to track whether EXA is
-active or not.  It can be helpful to also conditionalize XAA support with an
-ifdef so that it can easily be turned off/removed in the future.
+active or not.
 
-Setting the flag and checking for AccelMethod can be done in the driver's
-Options parsing routine.
+Setting the flag can be done in the driver's Options parsing routine.
 
 Loading EXA
 ------------
diff --git a/xorg-server/hw/xfree86/dri/Makefile.am b/xorg-server/hw/xfree86/dri/Makefile.am
index 9528d5370..ced04ff38 100644
--- a/xorg-server/hw/xfree86/dri/Makefile.am
+++ b/xorg-server/hw/xfree86/dri/Makefile.am
@@ -1,24 +1,18 @@
-libdri_la_LTLIBRARIES = libdri.la
-libdri_la_CFLAGS = -I$(top_srcdir)/hw/xfree86/common \
-                   -I$(top_srcdir)/hw/xfree86/os-support \
-                   -I$(top_srcdir)/hw/xfree86/modes \
-                   -I$(top_srcdir)/hw/xfree86/ddc \
-                   -I$(top_srcdir)/hw/xfree86/i2c \
-                   -I$(top_srcdir)/hw/xfree86/parser \
-                   -I$(top_srcdir)/hw/xfree86/ramdac \
-                   -I$(top_srcdir)/hw/xfree86/os-support/bus \
-                   -I$(top_srcdir)/glx \
-                   -DHAVE_XORG_CONFIG_H \
-                   @DIX_CFLAGS@ @XORG_CFLAGS@ @DRIPROTO_CFLAGS@ \
-                   @LIBDRM_CFLAGS@ \
-                   @DRI_CFLAGS@
-libdri_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-libdri_la_LIBADD = @LIBDRM_LIBS@ $(PIXMAN_LIBS)
-libdri_ladir = $(moduledir)/extensions
+noinst_LTLIBRARIES = libdri.la
+AM_CFLAGS = -I$(top_srcdir)/hw/xfree86/common \
+            -I$(top_srcdir)/hw/xfree86/os-support \
+            -I$(top_srcdir)/hw/xfree86/modes \
+            -I$(top_srcdir)/hw/xfree86/ddc \
+            -I$(top_srcdir)/hw/xfree86/i2c \
+            -I$(top_srcdir)/hw/xfree86/parser \
+            -I$(top_srcdir)/hw/xfree86/ramdac \
+            -I$(top_srcdir)/hw/xfree86/os-support/bus \
+            -I$(top_srcdir)/glx \
+            -DHAVE_XORG_CONFIG_H \
+            @DIX_CFLAGS@ @XORG_CFLAGS@
 libdri_la_SOURCES = \
 	dri.c \
 	dri.h \
-	drimodule.c \
 	dristruct.h \
 	sarea.h \
 	xf86dri.c
diff --git a/xorg-server/hw/xfree86/dri/dri.c b/xorg-server/hw/xfree86/dri/dri.c
index 46a9ae457..398178e27 100644
--- a/xorg-server/hw/xfree86/dri/dri.c
+++ b/xorg-server/hw/xfree86/dri/dri.c
@@ -51,6 +51,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "misc.h"
 #include "dixstruct.h"
 #include "extnsionst.h"
+#include "extinit.h"
 #include "colormapst.h"
 #include "cursorstr.h"
 #include "scrnintstr.h"
@@ -68,6 +69,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "xf86_OSproc.h"
 #include "inputstr.h"
 #include "xf86VGAarbiter.h"
+#include "xf86Extensions.h"
 
 static int DRIEntPrivIndex = -1;
 static DevPrivateKeyRec DRIScreenPrivKeyRec;
@@ -789,6 +791,8 @@ DRIExtensionInit(void)
 
     RegisterBlockAndWakeupHandlers(DRIBlockHandler, DRIWakeupHandler, NULL);
 
+    drmSetServerInfo(&DRIDRMServerInfo);
+
     return TRUE;
 }
 
diff --git a/xorg-server/hw/xfree86/dri/dri.h b/xorg-server/hw/xfree86/dri/dri.h
index 0a4036c35..4bfaf1679 100644
--- a/xorg-server/hw/xfree86/dri/dri.h
+++ b/xorg-server/hw/xfree86/dri/dri.h
@@ -197,7 +197,7 @@ extern _X_EXPORT Bool DRIScreenInit(ScreenPtr pScreen,
 
 extern _X_EXPORT void DRICloseScreen(ScreenPtr pScreen);
 
-extern _X_EXPORT Bool DRIExtensionInit(void);
+extern Bool DRIExtensionInit(void);
 
 extern _X_EXPORT void DRIReset(void);
 
diff --git a/xorg-server/hw/xfree86/dri/drimodule.c b/xorg-server/hw/xfree86/dri/drimodule.c
deleted file mode 100644
index 83eca4eb9..000000000
--- a/xorg-server/hw/xfree86/dri/drimodule.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/**************************************************************************
-
-Copyright 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>
- *   Rickard E. Faith <faith@precisioninsight.com>
- *
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xf86Module.h"
-#include "globals.h"
-
-#include "xf86drm.h"
-static MODULESETUPPROTO(driSetup);
-
-drmServerInfo DRIDRMServerInfo;
-
-static XF86ModuleVersionInfo VersRec = {
-    "dri",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 0, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_NONE,
-    {0, 0, 0, 0}
-};
-
-extern void XFree86DRIExtensionInit(INITARGS);
-
-#define _XF86DRI_SERVER_
-#include <X11/dri/xf86driproto.h>
-
-static ExtensionModule XF86DRIExt = {
-    XFree86DRIExtensionInit,
-    XF86DRINAME,
-    &noXFree86DRIExtension,
-    NULL,
-    NULL
-};
-
-_X_EXPORT XF86ModuleData driModuleData = { &VersRec, driSetup, NULL };
-
-static pointer
-driSetup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    static Bool setupDone = FALSE;
-
-    if (!setupDone) {
-        setupDone = TRUE;
-        LoadExtension(&XF86DRIExt, FALSE);
-    }
-    else {
-        if (errmaj)
-            *errmaj = LDR_ONCEONLY;
-    }
-
-    drmSetServerInfo(&DRIDRMServerInfo);
-
-    /* Need a non-NULL return value to indicate success */
-    return (pointer) 1;
-}
diff --git a/xorg-server/hw/xfree86/dri/xf86dri.c b/xorg-server/hw/xfree86/dri/xf86dri.c
index 72ce8690d..ba74bb04f 100644
--- a/xorg-server/hw/xfree86/dri/xf86dri.c
+++ b/xorg-server/hw/xfree86/dri/xf86dri.c
@@ -47,6 +47,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "misc.h"
 #include "dixstruct.h"
 #include "extnsionst.h"
+#include "extinit.h"
 #include "colormapst.h"
 #include "cursorstr.h"
 #include "scrnintstr.h"
@@ -60,17 +61,17 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "dristruct.h"
 #include "xf86drm.h"
 #include "protocol-versions.h"
+#include "xf86Extensions.h"
 
 static int DRIErrorBase;
 
-static void XF86DRIResetProc(ExtensionEntry * extEntry);
+static void XF86DRIResetProc(ExtensionEntry *extEntry);
 
 static unsigned char DRIReqCode = 0;
 
-extern void XFree86DRIExtensionInit(void);
-
- /*ARGSUSED*/ static void
-XF86DRIResetProc(ExtensionEntry * extEntry)
+/*ARGSUSED*/
+static void
+XF86DRIResetProc(ExtensionEntry *extEntry)
 {
     DRIReset();
 }
@@ -78,15 +79,16 @@ XF86DRIResetProc(ExtensionEntry * extEntry)
 static int
 ProcXF86DRIQueryVersion(register ClientPtr client)
 {
-    xXF86DRIQueryVersionReply rep;
+    xXF86DRIQueryVersionReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .majorVersion = SERVER_XF86DRI_MAJOR_VERSION,
+        .minorVersion = SERVER_XF86DRI_MINOR_VERSION,
+        .patchVersion = SERVER_XF86DRI_PATCH_VERSION
+    };
 
     REQUEST_SIZE_MATCH(xXF86DRIQueryVersionReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.majorVersion = SERVER_XF86DRI_MAJOR_VERSION;
-    rep.minorVersion = SERVER_XF86DRI_MINOR_VERSION;
-    rep.patchVersion = SERVER_XF86DRI_PATCH_VERSION;
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
@@ -94,7 +96,7 @@ ProcXF86DRIQueryVersion(register ClientPtr client)
         swaps(&rep.minorVersion);
         swapl(&rep.patchVersion);
     }
-    WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRIQueryVersionReply), &rep);
     return Success;
 }
 
@@ -111,18 +113,20 @@ ProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     if (!DRIQueryDirectRenderingCapable(screenInfo.screens[stuff->screen],
                                         &isCapable)) {
         return BadValue;
     }
-    rep.isCapable = isCapable;
 
     if (!LocalClient(client) || client->swapped)
-        rep.isCapable = 0;
+        isCapable = 0;
+
+    rep = (xXF86DRIQueryDirectRenderingCapableReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .isCapable = isCapable
+    };
 
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
@@ -131,7 +135,7 @@ ProcXF86DRIQueryDirectRenderingCapable(register ClientPtr client)
 
     WriteToClient(client,
                   sizeof(xXF86DRIQueryDirectRenderingCapableReply),
-                  (char *) &rep);
+                  &rep);
     return Success;
 }
 
@@ -141,6 +145,7 @@ ProcXF86DRIOpenConnection(register ClientPtr client)
     xXF86DRIOpenConnectionReply rep;
     drm_handle_t hSAREA;
     char *busIdString;
+    CARD32 busIdStringLength = 0;
 
     REQUEST(xXF86DRIOpenConnectionReq);
     REQUEST_SIZE_MATCH(xXF86DRIOpenConnectionReq);
@@ -154,33 +159,40 @@ ProcXF86DRIOpenConnection(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.sequenceNumber = client->sequence;
-    rep.busIdStringLength = 0;
     if (busIdString)
-        rep.busIdStringLength = strlen(busIdString);
-    rep.length =
-        bytes_to_int32(SIZEOF(xXF86DRIOpenConnectionReply) -
-                       SIZEOF(xGenericReply) +
-                       pad_to_int32(rep.busIdStringLength));
+        busIdStringLength = strlen(busIdString);
 
-    rep.hSAREALow = (CARD32) (hSAREA & 0xffffffff);
+    rep = (xXF86DRIOpenConnectionReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = bytes_to_int32(SIZEOF(xXF86DRIOpenConnectionReply) -
+                                 SIZEOF(xGenericReply) +
+                                 pad_to_int32(busIdStringLength)),
+        .busIdStringLength = busIdStringLength,
+
+        .hSAREALow = (CARD32) (hSAREA & 0xffffffff),
 #if defined(LONG64) && !defined(__linux__)
-    rep.hSAREAHigh = (CARD32) (hSAREA >> 32);
+        .hSAREAHigh = (CARD32) (hSAREA >> 32),
 #else
-    rep.hSAREAHigh = 0;
+        .hSAREAHigh = 0
 #endif
+    };
 
-    WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), (char *) &rep);
-    if (rep.busIdStringLength)
-        WriteToClient(client, rep.busIdStringLength, busIdString);
+    WriteToClient(client, sizeof(xXF86DRIOpenConnectionReply), &rep);
+    if (busIdStringLength)
+        WriteToClient(client, busIdStringLength, busIdString);
     return Success;
 }
 
 static int
 ProcXF86DRIAuthConnection(register ClientPtr client)
 {
-    xXF86DRIAuthConnectionReply rep;
+    xXF86DRIAuthConnectionReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .authenticated = 1
+    };
 
     REQUEST(xXF86DRIAuthConnectionReq);
     REQUEST_SIZE_MATCH(xXF86DRIAuthConnectionReq);
@@ -189,16 +201,11 @@ ProcXF86DRIAuthConnection(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.authenticated = 1;
-
     if (!DRIAuthConnection(screenInfo.screens[stuff->screen], stuff->magic)) {
         ErrorF("Failed to authenticate %lu\n", (unsigned long) stuff->magic);
         rep.authenticated = 0;
     }
-    WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRIAuthConnectionReply), &rep);
     return Success;
 }
 
@@ -220,7 +227,11 @@ ProcXF86DRICloseConnection(register ClientPtr client)
 static int
 ProcXF86DRIGetClientDriverName(register ClientPtr client)
 {
-    xXF86DRIGetClientDriverNameReply rep;
+    xXF86DRIGetClientDriverNameReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .clientDriverNameLength = 0
+    };
     char *clientDriverName;
 
     REQUEST(xXF86DRIGetClientDriverNameReq);
@@ -236,17 +247,13 @@ ProcXF86DRIGetClientDriverName(register ClientPtr client)
                            (int *) &rep.ddxDriverPatchVersion,
                            &clientDriverName);
 
-    rep.type = X_Reply;
-    rep.sequenceNumber = client->sequence;
-    rep.clientDriverNameLength = 0;
     if (clientDriverName)
         rep.clientDriverNameLength = strlen(clientDriverName);
     rep.length = bytes_to_int32(SIZEOF(xXF86DRIGetClientDriverNameReply) -
                                 SIZEOF(xGenericReply) +
                                 pad_to_int32(rep.clientDriverNameLength));
 
-    WriteToClient(client,
-                  sizeof(xXF86DRIGetClientDriverNameReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRIGetClientDriverNameReply), &rep);
     if (rep.clientDriverNameLength)
         WriteToClient(client, rep.clientDriverNameLength, clientDriverName);
     return Success;
@@ -255,7 +262,11 @@ ProcXF86DRIGetClientDriverName(register ClientPtr client)
 static int
 ProcXF86DRICreateContext(register ClientPtr client)
 {
-    xXF86DRICreateContextReply rep;
+    xXF86DRICreateContextReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     ScreenPtr pScreen;
 
     REQUEST(xXF86DRICreateContextReq);
@@ -265,10 +276,6 @@ ProcXF86DRICreateContext(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     pScreen = screenInfo.screens[stuff->screen];
 
     if (!DRICreateContext(pScreen,
@@ -277,7 +284,7 @@ ProcXF86DRICreateContext(register ClientPtr client)
         return BadValue;
     }
 
-    WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRICreateContextReply), &rep);
     return Success;
 }
 
@@ -301,7 +308,11 @@ ProcXF86DRIDestroyContext(register ClientPtr client)
 static int
 ProcXF86DRICreateDrawable(ClientPtr client)
 {
-    xXF86DRICreateDrawableReply rep;
+    xXF86DRICreateDrawableReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     DrawablePtr pDrawable;
     int rc;
 
@@ -312,10 +323,6 @@ ProcXF86DRICreateDrawable(ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                            DixReadAccess);
     if (rc != Success)
@@ -326,7 +333,7 @@ ProcXF86DRICreateDrawable(ClientPtr client)
         return BadValue;
     }
 
-    WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRICreateDrawableReply), &rep);
     return Success;
 }
 
@@ -360,7 +367,11 @@ ProcXF86DRIDestroyDrawable(register ClientPtr client)
 static int
 ProcXF86DRIGetDrawableInfo(register ClientPtr client)
 {
-    xXF86DRIGetDrawableInfoReply rep;
+    xXF86DRIGetDrawableInfoReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     DrawablePtr pDrawable;
     int X, Y, W, H;
     drm_clip_rect_t *pClipRects, *pClippedRects;
@@ -374,10 +385,6 @@ ProcXF86DRIGetDrawableInfo(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
                            DixReadAccess);
     if (rc != Success)
@@ -444,19 +451,19 @@ ProcXF86DRIGetDrawableInfo(register ClientPtr client)
 
     rep.length = bytes_to_int32(rep.length);
 
-    WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRIGetDrawableInfoReply), &rep);
 
     if (rep.numClipRects) {
         WriteToClient(client,
                       sizeof(drm_clip_rect_t) * rep.numClipRects,
-                      (char *) pClippedRects);
+                      pClippedRects);
         free(pClippedRects);
     }
 
     if (rep.numBackClipRects) {
         WriteToClient(client,
                       sizeof(drm_clip_rect_t) * rep.numBackClipRects,
-                      (char *) pBackClipRects);
+                      pBackClipRects);
     }
 
     return Success;
@@ -465,7 +472,11 @@ ProcXF86DRIGetDrawableInfo(register ClientPtr client)
 static int
 ProcXF86DRIGetDeviceInfo(register ClientPtr client)
 {
-    xXF86DRIGetDeviceInfoReply rep;
+    xXF86DRIGetDeviceInfoReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     drm_handle_t hFrameBuffer;
     void *pDevPrivate;
 
@@ -476,10 +487,6 @@ ProcXF86DRIGetDeviceInfo(register ClientPtr client)
         return BadValue;
     }
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-
     if (!DRIGetDeviceInfo(screenInfo.screens[stuff->screen],
                           &hFrameBuffer,
                           (int *) &rep.framebufferOrigin,
@@ -496,16 +503,15 @@ ProcXF86DRIGetDeviceInfo(register ClientPtr client)
     rep.hFrameBufferHigh = 0;
 #endif
 
-    rep.length = 0;
     if (rep.devPrivateSize) {
         rep.length = bytes_to_int32(SIZEOF(xXF86DRIGetDeviceInfoReply) -
                                     SIZEOF(xGenericReply) +
                                     pad_to_int32(rep.devPrivateSize));
     }
 
-    WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXF86DRIGetDeviceInfoReply), &rep);
     if (rep.length) {
-        WriteToClient(client, rep.devPrivateSize, (char *) pDevPrivate);
+        WriteToClient(client, rep.devPrivateSize, pDevPrivate);
     }
     return Success;
 }
diff --git a/xorg-server/hw/xfree86/dri2/Makefile.am b/xorg-server/hw/xfree86/dri2/Makefile.am
index 390ed12c8..502a2ee29 100644
--- a/xorg-server/hw/xfree86/dri2/Makefile.am
+++ b/xorg-server/hw/xfree86/dri2/Makefile.am
@@ -1,17 +1,14 @@
-libdri2_la_LTLIBRARIES = libdri2.la
-libdri2_la_CFLAGS = \
+noinst_LTLIBRARIES = libdri2.la
+AM_CFLAGS = \
 	-DHAVE_XORG_CONFIG_H \
-	@DRI_CFLAGS@ \
-	@DIX_CFLAGS@ @XORG_CFLAGS@ @DRI2PROTO_CFLAGS@ @LIBDRM_CFLAGS@ \
+	@DIX_CFLAGS@ @XORG_CFLAGS@ \
 	-I$(top_srcdir)/hw/xfree86/common \
 	-I$(top_srcdir)/hw/xfree86/os-support/bus
 
-libdri2_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-libdri2_la_LIBADD = @LIBDRM_LIBS@ $(PIXMAN_LIBS)
-libdri2_ladir = $(moduledir)/extensions
 libdri2_la_SOURCES = \
 	dri2.c \
 	dri2.h \
-	dri2ext.c
+	dri2ext.c \
+	dri2int.h
 
 sdk_HEADERS = dri2.h
diff --git a/xorg-server/hw/xfree86/dri2/dri2.c b/xorg-server/hw/xfree86/dri2/dri2.c
index d3b3c73f8..2ea0c331e 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.c
+++ b/xorg-server/hw/xfree86/dri2/dri2.c
@@ -44,13 +44,16 @@
 #include "windowstr.h"
 #include "dixstruct.h"
 #include "dri2.h"
+#include "dri2int.h"
 #include "xf86VGAarbiter.h"
-
+#include "damage.h"
 #include "xf86.h"
 
 CARD8 dri2_major;               /* version of DRI2 supported by DDX */
 CARD8 dri2_minor;
 
+uint32_t prime_id_allocate_bitmask;
+
 static DevPrivateKeyRec dri2ScreenPrivateKeyRec;
 
 #define dri2ScreenPrivateKey (&dri2ScreenPrivateKeyRec)
@@ -63,6 +66,17 @@ static DevPrivateKeyRec dri2PixmapPrivateKeyRec;
 
 #define dri2PixmapPrivateKey (&dri2PixmapPrivateKeyRec)
 
+static DevPrivateKeyRec dri2ClientPrivateKeyRec;
+
+#define dri2ClientPrivateKey (&dri2ClientPrivateKeyRec)
+
+#define dri2ClientPrivate(_pClient) (dixLookupPrivate(&(_pClient)->devPrivates, \
+                                                      dri2ClientPrivateKey))
+
+typedef struct _DRI2Client {
+    int prime_id;
+} DRI2ClientRec, *DRI2ClientPtr;
+
 static RESTYPE dri2DrawableRes;
 
 typedef struct _DRI2Screen *DRI2ScreenPtr;
@@ -87,6 +101,9 @@ typedef struct _DRI2Drawable {
     int swap_limit;             /* for N-buffering */
     unsigned long serialNumber;
     Bool needInvalidate;
+    int prime_id;
+    PixmapPtr prime_slave_pixmap;
+    PixmapPtr redirectpixmap;
 } DRI2DrawableRec, *DRI2DrawablePtr;
 
 typedef struct _DRI2Screen {
@@ -97,6 +114,7 @@ typedef struct _DRI2Screen {
     const char *deviceName;
     int fd;
     unsigned int lastSequence;
+    int prime_id;
 
     DRI2CreateBufferProcPtr CreateBuffer;
     DRI2DestroyBufferProcPtr DestroyBuffer;
@@ -113,14 +131,46 @@ typedef struct _DRI2Screen {
     HandleExposuresProcPtr HandleExposures;
 
     ConfigNotifyProcPtr ConfigNotify;
+    DRI2CreateBuffer2ProcPtr CreateBuffer2;
+    DRI2DestroyBuffer2ProcPtr DestroyBuffer2;
+    DRI2CopyRegion2ProcPtr CopyRegion2;
 } DRI2ScreenRec;
 
+static void
+destroy_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, int prime_id);
+
 static DRI2ScreenPtr
 DRI2GetScreen(ScreenPtr pScreen)
 {
     return dixLookupPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey);
 }
 
+static ScreenPtr
+GetScreenPrime(ScreenPtr master, int prime_id)
+{
+    ScreenPtr slave;
+    if (prime_id == 0 || xorg_list_is_empty(&master->offload_slave_list)) {
+        return master;
+    }
+    xorg_list_for_each_entry(slave, &master->offload_slave_list, offload_head) {
+        DRI2ScreenPtr ds;
+
+        ds = DRI2GetScreen(slave);
+        if (ds->prime_id == prime_id)
+            break;
+    }
+    if (!slave)
+        return master;
+    return slave;
+}
+
+static DRI2ScreenPtr
+DRI2GetScreenPrime(ScreenPtr master, int prime_id)
+{
+    ScreenPtr slave = GetScreenPrime(master, prime_id);
+    return DRI2GetScreen(slave);
+}
+
 static DRI2DrawablePtr
 DRI2GetDrawable(DrawablePtr pDraw)
 {
@@ -187,7 +237,8 @@ DRI2AllocateDrawable(DrawablePtr pDraw)
     xorg_list_init(&pPriv->reference_list);
     pPriv->serialNumber = DRI2DrawableSerial(pDraw);
     pPriv->needInvalidate = FALSE;
-
+    pPriv->redirectpixmap = NULL;
+    pPriv->prime_slave_pixmap = NULL;
     if (pDraw->type == DRAWABLE_WINDOW) {
         pWin = (WindowPtr) pDraw;
         dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);
@@ -286,6 +337,7 @@ DRI2CreateDrawable(ClientPtr client, DrawablePtr pDraw, XID id,
                    DRI2InvalidateProcPtr invalidate, void *priv)
 {
     DRI2DrawablePtr pPriv;
+    DRI2ClientPtr dri2_client = dri2ClientPrivate(client);
     XID dri2_id;
     int rc;
 
@@ -295,6 +347,8 @@ DRI2CreateDrawable(ClientPtr client, DrawablePtr pDraw, XID id,
     if (pPriv == NULL)
         return BadAlloc;
 
+    pPriv->prime_id = dri2_client->prime_id;
+
     dri2_id = FakeClientID(client->index);
     rc = DRI2AddDrawableRef(pPriv, id, dri2_id, invalidate, priv);
     if (rc != Success)
@@ -307,7 +361,6 @@ static int
 DRI2DrawableGone(pointer p, XID id)
 {
     DRI2DrawablePtr pPriv = p;
-    DRI2ScreenPtr ds = pPriv->dri2_screen;
     DRI2DrawableRefPtr ref, next;
     WindowPtr pWin;
     PixmapPtr pPixmap;
@@ -347,16 +400,52 @@ DRI2DrawableGone(pointer p, XID id)
 
     if (pPriv->buffers != NULL) {
         for (i = 0; i < pPriv->bufferCount; i++)
-            (*ds->DestroyBuffer) (pDraw, pPriv->buffers[i]);
+            destroy_buffer(pDraw, pPriv->buffers[i], pPriv->prime_id);
 
         free(pPriv->buffers);
     }
 
+    if (pPriv->redirectpixmap) {
+        (*pDraw->pScreen->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
+        (*pDraw->pScreen->DestroyPixmap)(pPriv->redirectpixmap);
+    }
+
     free(pPriv);
 
     return Success;
 }
 
+static DRI2BufferPtr
+create_buffer(DrawablePtr pDraw,
+              unsigned int attachment, unsigned int format)
+{
+    ScreenPtr primeScreen;
+    DRI2DrawablePtr pPriv;
+    DRI2ScreenPtr ds;
+    DRI2BufferPtr buffer;
+    pPriv = DRI2GetDrawable(pDraw);
+    primeScreen = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
+    ds = DRI2GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
+    if (ds->CreateBuffer2)
+        buffer = (*ds->CreateBuffer2)(primeScreen, pDraw, attachment, format);
+    else
+        buffer = (*ds->CreateBuffer)(pDraw, attachment, format);
+    return buffer;
+}
+
+static void
+destroy_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, int prime_id)
+{
+    ScreenPtr primeScreen;
+    DRI2ScreenPtr ds;
+    primeScreen = GetScreenPrime(pDraw->pScreen, prime_id);
+    ds = DRI2GetScreen(primeScreen);
+    if (ds->DestroyBuffer2)
+        (*ds->DestroyBuffer2)(primeScreen, pDraw, buffer);
+    else
+        (*ds->DestroyBuffer)(pDraw, buffer);
+}
+
 static int
 find_attachment(DRI2DrawablePtr pPriv, unsigned attachment)
 {
@@ -387,7 +476,7 @@ allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,
     if ((old_buf < 0)
         || attachment == DRI2BufferFrontLeft
         || !dimensions_match || (pPriv->buffers[old_buf]->format != format)) {
-        *buffer = (*ds->CreateBuffer) (pDraw, attachment, format);
+        *buffer = create_buffer (pDraw, attachment, format);
         pPriv->serialNumber = DRI2DrawableSerial(pDraw);
         return TRUE;
 
@@ -408,13 +497,12 @@ update_dri2_drawable_buffers(DRI2DrawablePtr pPriv, DrawablePtr pDraw,
                              DRI2BufferPtr * buffers, int out_count, int *width,
                              int *height)
 {
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
     int i;
 
     if (pPriv->buffers != NULL) {
         for (i = 0; i < pPriv->bufferCount; i++) {
             if (pPriv->buffers[i] != NULL) {
-                (*ds->DestroyBuffer) (pDraw, pPriv->buffers[i]);
+                destroy_buffer(pDraw, pPriv->buffers[i], pPriv->prime_id);
             }
         }
 
@@ -434,8 +522,8 @@ do_get_buffers(DrawablePtr pDraw, int *width, int *height,
                unsigned int *attachments, int count, int *out_count,
                int has_format)
 {
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
     DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
+    DRI2ScreenPtr ds;
     DRI2BufferPtr *buffers;
     int need_real_front = 0;
     int need_fake_front = 0;
@@ -452,6 +540,8 @@ do_get_buffers(DrawablePtr pDraw, int *width, int *height,
         return NULL;
     }
 
+    ds = DRI2GetScreen(pDraw->pScreen);
+
     dimensions_match = (pDraw->width == pPriv->width)
         && (pDraw->height == pPriv->height)
         && (pPriv->serialNumber == DRI2DrawableSerial(pDraw));
@@ -556,7 +646,7 @@ do_get_buffers(DrawablePtr pDraw, int *width, int *height,
     if (buffers) {
         for (i = 0; i < count; i++) {
             if (buffers[i] != NULL)
-                (*ds->DestroyBuffer) (pDraw, buffers[i]);
+                destroy_buffer(pDraw, buffers[i], 0);
         }
 
         free(buffers);
@@ -650,11 +740,118 @@ DRI2BlockClient(ClientPtr client, DrawablePtr pDraw)
     pPriv->blockedOnMsc = TRUE;
 }
 
+static inline PixmapPtr GetDrawablePixmap(DrawablePtr drawable)
+{
+    if (drawable->type == DRAWABLE_PIXMAP)
+        return (PixmapPtr)drawable;
+    else {
+        struct _Window *pWin = (struct _Window *)drawable;
+        return drawable->pScreen->GetWindowPixmap(pWin);
+    }
+}
+
+DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
+{
+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
+    PixmapPtr spix;
+    PixmapPtr mpix = GetDrawablePixmap(pDraw);
+    ScreenPtr master, slave;
+    Bool ret;
+
+    master = mpix->drawable.pScreen;
+
+    if (pDraw->type == DRAWABLE_WINDOW) {
+        WindowPtr pWin = (WindowPtr)pDraw;
+        PixmapPtr pPixmap = pDraw->pScreen->GetWindowPixmap(pWin);
+
+        if (pDraw->pScreen->GetScreenPixmap(pDraw->pScreen) == pPixmap) {
+            if (pPriv->redirectpixmap &&
+                pPriv->redirectpixmap->drawable.width == pDraw->width &&
+                pPriv->redirectpixmap->drawable.height == pDraw->height &&
+                pPriv->redirectpixmap->drawable.depth == pDraw->depth) {
+                mpix = pPriv->redirectpixmap;
+            } else {
+                if (master->ReplaceScanoutPixmap) {
+                    mpix = (*master->CreatePixmap)(master, pDraw->width, pDraw->height,
+                                                   pDraw->depth, CREATE_PIXMAP_USAGE_SHARED);
+                    if (!mpix)
+                        return NULL;
+
+                    ret = (*master->ReplaceScanoutPixmap)(pDraw, mpix, TRUE);
+                    if (ret == FALSE) {
+                        (*master->DestroyPixmap)(mpix);
+                        return NULL;
+                    }
+                    pPriv->redirectpixmap = mpix;
+                } else
+                    return NULL;
+            }
+        } else if (pPriv->redirectpixmap) {
+            (*master->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
+            (*master->DestroyPixmap)(pPriv->redirectpixmap);
+            pPriv->redirectpixmap = NULL;
+        }
+    }
+
+    slave = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
+
+    /* check if the pixmap is still fine */
+    if (pPriv->prime_slave_pixmap) {
+        if (pPriv->prime_slave_pixmap->master_pixmap == mpix)
+            return &pPriv->prime_slave_pixmap->drawable;
+        else {
+            (*master->DestroyPixmap)(pPriv->prime_slave_pixmap->master_pixmap);
+            (*slave->DestroyPixmap)(pPriv->prime_slave_pixmap);
+        }
+    }
+
+    spix = PixmapShareToSlave(mpix, slave);
+    if (!spix)
+        return NULL;
+
+    pPriv->prime_slave_pixmap = spix;
+#ifdef COMPOSITE
+    spix->screen_x = mpix->screen_x;
+    spix->screen_y = mpix->screen_y;
+#endif
+    return &spix->drawable;
+}
+
+static void dri2_copy_region(DrawablePtr pDraw, RegionPtr pRegion,
+                             DRI2BufferPtr pDest, DRI2BufferPtr pSrc)
+{
+    DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
+    DRI2ScreenPtr ds;
+    ScreenPtr primeScreen;
+
+    primeScreen = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
+    ds = DRI2GetScreen(primeScreen);
+
+    if (ds->CopyRegion2)
+        (*ds->CopyRegion2)(primeScreen, pDraw, pRegion, pDest, pSrc);
+    else
+        (*ds->CopyRegion) (pDraw, pRegion, pDest, pSrc);
+
+    /* cause damage to the box */
+    if (pPriv->prime_id) {
+       BoxRec box;
+       RegionRec region;
+       box.x1 = 0;
+       box.x2 = box.x1 + pDraw->width;
+       box.y1 = 0;
+       box.y2 = box.y1 + pDraw->height;
+       RegionInit(&region, &box, 1);
+       RegionTranslate(&region, pDraw->x, pDraw->y);
+       DamageRegionAppend(pDraw, &region);
+       DamageRegionProcessPending(pDraw);
+       RegionUninit(&region);
+    }
+}
+
 int
 DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,
                unsigned int dest, unsigned int src)
 {
-    DRI2ScreenPtr ds = DRI2GetScreen(pDraw->pScreen);
     DRI2DrawablePtr pPriv;
     DRI2BufferPtr pDestBuffer, pSrcBuffer;
     int i;
@@ -674,7 +871,7 @@ DRI2CopyRegion(DrawablePtr pDraw, RegionPtr pRegion,
     if (pSrcBuffer == NULL || pDestBuffer == NULL)
         return BadValue;
 
-    (*ds->CopyRegion) (pDraw, pRegion, pDestBuffer, pSrcBuffer);
+    dri2_copy_region(pDraw, pRegion, pDestBuffer, pSrcBuffer);
 
     return Success;
 }
@@ -879,7 +1076,7 @@ DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
     }
 
     /* Old DDX or no swap interval, just blit */
-    if (!ds->ScheduleSwap || !pPriv->swap_interval) {
+    if (!ds->ScheduleSwap || !pPriv->swap_interval || pPriv->prime_id) {
         BoxRec box;
         RegionRec region;
 
@@ -891,7 +1088,7 @@ DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
 
         pPriv->swapsPending++;
 
-        (*ds->CopyRegion) (pDraw, &region, pDestBuffer, pSrcBuffer);
+        dri2_copy_region(pDraw, &region, pDestBuffer, pSrcBuffer);
         DRI2SwapComplete(client, pDraw, target_msc, 0, 0, DRI2_BLIT_COMPLETE,
                          func, data);
         return Success;
@@ -1091,22 +1288,34 @@ DRI2HasSwapControl(ScreenPtr pScreen)
 }
 
 Bool
-DRI2Connect(ScreenPtr pScreen, unsigned int driverType, int *fd,
+DRI2Connect(ClientPtr client, ScreenPtr pScreen,
+            unsigned int driverType, int *fd,
             const char **driverName, const char **deviceName)
 {
     DRI2ScreenPtr ds;
+    uint32_t prime_id = DRI2DriverPrimeId(driverType);
+    uint32_t driver_id = driverType & 0xffff;
 
     if (!dixPrivateKeyRegistered(dri2ScreenPrivateKey))
         return FALSE;
 
-    ds = DRI2GetScreen(pScreen);
-    if (ds == NULL || driverType >= ds->numDrivers ||
-        !ds->driverNames[driverType])
+    ds = DRI2GetScreenPrime(pScreen, prime_id);
+    if (ds == NULL)
         return FALSE;
 
-    *fd = ds->fd;
-    *driverName = ds->driverNames[driverType];
+    if (driver_id >= ds->numDrivers ||
+        !ds->driverNames[driver_id])
+        return FALSE;
+
+    *driverName = ds->driverNames[driver_id];
     *deviceName = ds->deviceName;
+    *fd = ds->fd;
+
+    if (client) {
+        DRI2ClientPtr dri2_client;
+        dri2_client = dri2ClientPrivate(client);
+        dri2_client->prime_id = prime_id;
+    }
 
     return TRUE;
 }
@@ -1122,13 +1331,19 @@ DRI2AuthMagic (ScreenPtr pScreen, uint32_t magic)
 }
 
 Bool
-DRI2Authenticate(ScreenPtr pScreen, uint32_t magic)
+DRI2Authenticate(ClientPtr client, ScreenPtr pScreen, uint32_t magic)
 {
-    DRI2ScreenPtr ds = DRI2GetScreen(pScreen);
+    DRI2ScreenPtr ds;
+    DRI2ClientPtr dri2_client = dri2ClientPrivate(client);
+    ScreenPtr primescreen;
 
-    if (ds == NULL || (*ds->AuthMagic) (pScreen, magic))
+    ds = DRI2GetScreenPrime(pScreen, dri2_client->prime_id);
+    if (ds == NULL)
         return FALSE;
 
+    primescreen = GetScreenPrime(pScreen, dri2_client->prime_id);
+    if ((*ds->AuthMagic)(primescreen, magic))
+        return FALSE;
     return TRUE;
 }
 
@@ -1160,6 +1375,22 @@ DRI2ConfigNotify(WindowPtr pWin, int x, int y, int w, int h, int bw,
     return Success;
 }
 
+#define MAX_PRIME DRI2DriverPrimeMask
+static int
+get_prime_id(void)
+{
+    int i;
+    /* start at 1, prime id 0 is just normal driver */
+    for (i = 1; i < MAX_PRIME; i++) {
+         if (prime_id_allocate_bitmask & (1 << i))
+             continue;
+
+         prime_id_allocate_bitmask |= (1 << i);
+         return i;
+    }
+    return -1;
+}
+
 Bool
 DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)
 {
@@ -1190,6 +1421,9 @@ DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)
     if (!dixRegisterPrivateKey(&dri2PixmapPrivateKeyRec, PRIVATE_PIXMAP, 0))
         return FALSE;
 
+    if (!dixRegisterPrivateKey(&dri2ClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(DRI2ClientRec)))
+        return FALSE;
+
     ds = calloc(1, sizeof *ds);
     if (!ds)
         return FALSE;
@@ -1230,6 +1464,19 @@ DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info)
         cur_minor = 4;
     }
 
+    if (info->version >= 9) {
+        ds->CreateBuffer2 = info->CreateBuffer2;
+        if (info->CreateBuffer2 && pScreen->isGPU) {
+            ds->prime_id = get_prime_id();
+            if (ds->prime_id == -1) {
+                free(ds);
+                return FALSE;
+            }
+        }
+        ds->DestroyBuffer2 = info->DestroyBuffer2;
+        ds->CopyRegion2 = info->CopyRegion2;
+    }
+
     /*
      * if the driver doesn't provide an AuthMagic function or the info struct
      * version is too low, call through LegacyAuthMagic
@@ -1299,12 +1546,13 @@ DRI2CloseScreen(ScreenPtr pScreen)
 
     pScreen->ConfigNotify = ds->ConfigNotify;
 
+    if (ds->prime_id)
+        prime_id_allocate_bitmask &= ~(1 << ds->prime_id);
     free(ds->driverNames);
     free(ds);
     dixSetPrivate(&pScreen->devPrivates, dri2ScreenPrivateKey, NULL);
 }
 
-extern ExtensionModule dri2ExtensionModule;
 extern Bool DRI2ModuleSetup(void);
 
 /* Called by InitExtensions() */
@@ -1318,46 +1566,14 @@ DRI2ModuleSetup(void)
     return TRUE;
 }
 
-static pointer
-DRI2Setup(pointer module, pointer opts, int *errmaj, int *errmin)
-{
-    static Bool setupDone = FALSE;
-
-    if (!setupDone) {
-        setupDone = TRUE;
-        LoadExtension(&dri2ExtensionModule, FALSE);
-    }
-    else {
-        if (errmaj)
-            *errmaj = LDR_ONCEONLY;
-    }
-
-    return (pointer) 1;
-}
-
-static XF86ModuleVersionInfo DRI2VersRec = {
-    "dri2",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    1, 2, 0,
-    ABI_CLASS_EXTENSION,
-    ABI_EXTENSION_VERSION,
-    MOD_CLASS_NONE,
-    {0, 0, 0, 0}
-};
-
-_X_EXPORT XF86ModuleData dri2ModuleData = { &DRI2VersRec, DRI2Setup, NULL };
-
 void
 DRI2Version(int *major, int *minor)
 {
     if (major != NULL)
-        *major = DRI2VersRec.majorversion;
+        *major = 1;
 
     if (minor != NULL)
-        *minor = DRI2VersRec.minorversion;
+        *minor = 2;
 }
 
 int
diff --git a/xorg-server/hw/xfree86/dri2/dri2.h b/xorg-server/hw/xfree86/dri2/dri2.h
index 4fd0fbc52..da7825e09 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.h
+++ b/xorg-server/hw/xfree86/dri2/dri2.h
@@ -176,6 +176,18 @@ typedef void (*DRI2InvalidateProcPtr) (DrawablePtr pDraw, void *data, XID id);
 typedef Bool (*DRI2SwapLimitValidateProcPtr) (DrawablePtr pDraw,
                                               int swap_limit);
 
+typedef DRI2BufferPtr(*DRI2CreateBuffer2ProcPtr) (ScreenPtr pScreen,
+                                                  DrawablePtr pDraw,
+                                                  unsigned int attachment,
+                                                  unsigned int format);
+typedef void (*DRI2DestroyBuffer2ProcPtr) (ScreenPtr pScreen, DrawablePtr pDraw,
+                                          DRI2BufferPtr buffer);
+
+typedef void (*DRI2CopyRegion2ProcPtr) (ScreenPtr pScreen, DrawablePtr pDraw,
+                                        RegionPtr pRegion,
+                                        DRI2BufferPtr pDestBuffer,
+                                        DRI2BufferPtr pSrcBuffer);
+
 /**
  * \brief Get the value of a parameter.
  *
@@ -193,7 +205,7 @@ typedef int (*DRI2GetParamProcPtr) (ClientPtr client,
 /**
  * Version of the DRI2InfoRec structure defined in this header
  */
-#define DRI2INFOREC_VERSION 8
+#define DRI2INFOREC_VERSION 9
 
 typedef struct {
     unsigned int version;       /**< Version of this struct */
@@ -228,7 +240,6 @@ typedef struct {
     DRI2SwapLimitValidateProcPtr SwapLimitValidate;
 
     /* added in version 7 */
-
     DRI2GetParamProcPtr GetParam;
 
     /* added in version 8 */
@@ -236,9 +247,12 @@ typedef struct {
     /* If this is NULL the AuthMagic callback is used */
     /* If this is non-NULL the AuthMagic callback is ignored */
     DRI2AuthMagic2ProcPtr AuthMagic2;
-} DRI2InfoRec, *DRI2InfoPtr;
 
-extern _X_EXPORT int DRI2EventBase;
+    /* added in version 9 */
+    DRI2CreateBuffer2ProcPtr CreateBuffer2;
+    DRI2DestroyBuffer2ProcPtr DestroyBuffer2;
+    DRI2CopyRegion2ProcPtr CopyRegion2;
+} DRI2InfoRec, *DRI2InfoPtr;
 
 extern _X_EXPORT Bool DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info);
 
@@ -246,13 +260,13 @@ extern _X_EXPORT void DRI2CloseScreen(ScreenPtr pScreen);
 
 extern _X_EXPORT Bool DRI2HasSwapControl(ScreenPtr pScreen);
 
-extern _X_EXPORT Bool DRI2Connect(ScreenPtr pScreen,
+extern _X_EXPORT Bool DRI2Connect(ClientPtr client, ScreenPtr pScreen,
                                   unsigned int driverType,
                                   int *fd,
                                   const char **driverName,
                                   const char **deviceName);
 
-extern _X_EXPORT Bool DRI2Authenticate(ScreenPtr pScreen, uint32_t magic);
+extern _X_EXPORT Bool DRI2Authenticate(ClientPtr client, ScreenPtr pScreen, uint32_t magic);
 
 extern _X_EXPORT int DRI2CreateDrawable(ClientPtr client,
                                         DrawablePtr pDraw,
@@ -260,8 +274,6 @@ extern _X_EXPORT int DRI2CreateDrawable(ClientPtr client,
                                         DRI2InvalidateProcPtr invalidate,
                                         void *priv);
 
-extern _X_EXPORT void DRI2DestroyDrawable(DrawablePtr pDraw);
-
 extern _X_EXPORT DRI2BufferPtr *DRI2GetBuffers(DrawablePtr pDraw,
                                                int *width,
                                                int *height,
@@ -339,4 +351,5 @@ extern _X_EXPORT int DRI2GetParam(ClientPtr client,
                                   BOOL *is_param_recognized,
                                   CARD64 *value);
 
+extern _X_EXPORT DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest);
 #endif
diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index c6f5b4e11..eb6fd44fc 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -44,13 +44,15 @@
 #include "extnsionst.h"
 #include "xfixes.h"
 #include "dri2.h"
+#include "dri2int.h"
 #include "protocol-versions.h"
 
-/* The only xf86 include */
+/* The only xf86 includes */
 #include "xf86Module.h"
+#include "xf86Extensions.h"
+
+static int DRI2EventBase;
 
-static ExtensionEntry *dri2Extension;
-extern Bool DRI2ModuleSetup(void);
 
 static Bool
 validDrawable(ClientPtr client, XID drawable, Mask access_mode,
@@ -71,17 +73,18 @@ static int
 ProcDRI2QueryVersion(ClientPtr client)
 {
     REQUEST(xDRI2QueryVersionReq);
-    xDRI2QueryVersionReply rep;
+    xDRI2QueryVersionReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .majorVersion = dri2_major,
+        .minorVersion = dri2_minor
+    };
 
     if (client->swapped)
         swaps(&stuff->length);
 
     REQUEST_SIZE_MATCH(xDRI2QueryVersionReq);
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.majorVersion = dri2_major;
-    rep.minorVersion = dri2_minor;
 
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
@@ -99,7 +102,13 @@ static int
 ProcDRI2Connect(ClientPtr client)
 {
     REQUEST(xDRI2ConnectReq);
-    xDRI2ConnectReply rep;
+    xDRI2ConnectReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .driverNameLength = 0,
+        .deviceNameLength = 0
+    };
     DrawablePtr pDraw;
     int fd, status;
     const char *driverName;
@@ -110,13 +119,7 @@ ProcDRI2Connect(ClientPtr client)
                        &pDraw, &status))
         return status;
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
-    rep.driverNameLength = 0;
-    rep.deviceNameLength = 0;
-
-    if (!DRI2Connect(pDraw->pScreen,
+    if (!DRI2Connect(client, pDraw->pScreen,
                      stuff->driverType, &fd, &driverName, &deviceName))
         goto fail;
 
@@ -146,10 +149,12 @@ ProcDRI2Authenticate(ClientPtr client)
                        &pDraw, &status))
         return status;
 
-    rep.type = X_Reply;
-    rep.sequenceNumber = client->sequence;
-    rep.length = 0;
-    rep.authenticated = DRI2Authenticate(pDraw->pScreen, stuff->magic);
+    rep = (xDRI2AuthenticateReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .authenticated = DRI2Authenticate(client, pDraw->pScreen, stuff->magic)
+    };
     WriteToClient(client, sizeof(xDRI2AuthenticateReply), &rep);
 
     return Success;
@@ -158,11 +163,11 @@ ProcDRI2Authenticate(ClientPtr client)
 static void
 DRI2InvalidateBuffersEvent(DrawablePtr pDraw, void *priv, XID id)
 {
-    xDRI2InvalidateBuffers event;
     ClientPtr client = priv;
-
-    event.type = DRI2EventBase + DRI2_InvalidateBuffers;
-    event.drawable = id;
+    xDRI2InvalidateBuffers event = {
+        .type = DRI2EventBase + DRI2_InvalidateBuffers,
+        .drawable = id
+    };
 
     WriteEventsToClient(client, 1, (xEvent *) &event);
 }
@@ -225,12 +230,14 @@ send_buffers_reply(ClientPtr client, DrawablePtr pDrawable,
         }
     }
 
-    rep.type = X_Reply;
-    rep.length = (count - skip) * sizeof(xDRI2Buffer) / 4;
-    rep.sequenceNumber = client->sequence;
-    rep.width = width;
-    rep.height = height;
-    rep.count = count - skip;
+    rep = (xDRI2GetBuffersReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = (count - skip) * sizeof(xDRI2Buffer) / 4,
+        .width = width,
+        .height = height,
+        .count = count - skip
+    };
     WriteToClient(client, sizeof(xDRI2GetBuffersReply), &rep);
 
     for (i = 0; i < count; i++) {
@@ -330,9 +337,11 @@ ProcDRI2CopyRegion(ClientPtr client)
      * that yet.
      */
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
+    rep = (xDRI2CopyRegionReply) {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
 
     WriteToClient(client, sizeof(xDRI2CopyRegionReply), &rep);
 
@@ -356,17 +365,17 @@ static void
 DRI2SwapEvent(ClientPtr client, void *data, int type, CARD64 ust, CARD64 msc,
               CARD32 sbc)
 {
-    xDRI2BufferSwapComplete2 event;
     DrawablePtr pDrawable = data;
-
-    event.type = DRI2EventBase + DRI2_BufferSwapComplete;
-    event.event_type = type;
-    event.drawable = pDrawable->id;
-    event.ust_hi = (CARD64) ust >> 32;
-    event.ust_lo = ust & 0xffffffff;
-    event.msc_hi = (CARD64) msc >> 32;
-    event.msc_lo = msc & 0xffffffff;
-    event.sbc = sbc;
+    xDRI2BufferSwapComplete2 event = {
+        .type = DRI2EventBase + DRI2_BufferSwapComplete,
+        .event_type = type,
+        .drawable = pDrawable->id,
+        .ust_hi = (CARD64) ust >> 32,
+        .ust_lo = ust & 0xffffffff,
+        .msc_hi = (CARD64) msc >> 32,
+        .msc_lo = msc & 0xffffffff,
+        .sbc = sbc
+    };
 
     WriteEventsToClient(client, 1, (xEvent *) &event);
 }
@@ -375,7 +384,11 @@ static int
 ProcDRI2SwapBuffers(ClientPtr client)
 {
     REQUEST(xDRI2SwapBuffersReq);
-    xDRI2SwapBuffersReply rep;
+    xDRI2SwapBuffersReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     DrawablePtr pDrawable;
     CARD64 target_msc, divisor, remainder, swap_target;
     int status;
@@ -402,9 +415,6 @@ ProcDRI2SwapBuffers(ClientPtr client)
     if (status != Success)
         return BadDrawable;
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
     load_swap_reply(&rep, swap_target);
 
     WriteToClient(client, sizeof(xDRI2SwapBuffersReply), &rep);
@@ -427,7 +437,11 @@ static int
 ProcDRI2GetMSC(ClientPtr client)
 {
     REQUEST(xDRI2GetMSCReq);
-    xDRI2MSCReply rep;
+    xDRI2MSCReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
     DrawablePtr pDrawable;
     CARD64 ust, msc, sbc;
     int status;
@@ -442,9 +456,6 @@ ProcDRI2GetMSC(ClientPtr client)
     if (status != Success)
         return status;
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
     load_msc_reply(&rep, ust, msc, sbc);
 
     WriteToClient(client, sizeof(xDRI2MSCReply), &rep);
@@ -482,11 +493,12 @@ ProcDRI2WaitMSC(ClientPtr client)
 int
 ProcDRI2WaitMSCReply(ClientPtr client, CARD64 ust, CARD64 msc, CARD64 sbc)
 {
-    xDRI2MSCReply rep;
+    xDRI2MSCReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0
+    };
 
-    rep.type = X_Reply;
-    rep.length = 0;
-    rep.sequenceNumber = client->sequence;
     load_msc_reply(&rep, ust, msc, sbc);
 
     WriteToClient(client, sizeof(xDRI2MSCReply), &rep);
@@ -614,7 +626,13 @@ static int
 SProcDRI2Connect(ClientPtr client)
 {
     REQUEST(xDRI2ConnectReq);
-    xDRI2ConnectReply rep;
+    xDRI2ConnectReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = 0,
+        .driverNameLength = 0,
+        .deviceNameLength = 0
+    };
 
     /* If the client is swapped, it's not local.  Talk to the hand. */
 
@@ -622,12 +640,7 @@ SProcDRI2Connect(ClientPtr client)
     if (sizeof(*stuff) / 4 != client->req_len)
         return BadLength;
 
-    rep.type = X_Reply;
-    rep.sequenceNumber = client->sequence;
     swaps(&rep.sequenceNumber);
-    rep.length = 0;
-    rep.driverNameLength = 0;
-    rep.deviceNameLength = 0;
 
     WriteToClient(client, sizeof(xDRI2ConnectReply), &rep);
 
@@ -653,11 +666,11 @@ SProcDRI2Dispatch(ClientPtr client)
     }
 }
 
-int DRI2EventBase;
-
-static void
+void
 DRI2ExtensionInit(void)
 {
+    ExtensionEntry *dri2Extension;
+
     dri2Extension = AddExtension(DRI2_NAME,
                                  DRI2NumberEvents,
                                  DRI2NumberErrors,
@@ -668,13 +681,3 @@ DRI2ExtensionInit(void)
 
     DRI2ModuleSetup();
 }
-
-extern Bool noDRI2Extension;
-
-_X_HIDDEN ExtensionModule dri2ExtensionModule = {
-    DRI2ExtensionInit,
-    DRI2_NAME,
-    &noDRI2Extension,
-    NULL,
-    NULL
-};
diff --git a/xorg-server/hw/xfree86/dri2/dri2int.h b/xorg-server/hw/xfree86/dri2/dri2int.h
new file mode 100644
index 000000000..7f53eba45
--- /dev/null
+++ b/xorg-server/hw/xfree86/dri2/dri2int.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2011 Daniel Stone
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+extern Bool DRI2ModuleSetup(void);
diff --git a/xorg-server/hw/xfree86/loader/Makefile.am b/xorg-server/hw/xfree86/loader/Makefile.am
index ebe0c813a..bd47a635b 100644
--- a/xorg-server/hw/xfree86/loader/Makefile.am
+++ b/xorg-server/hw/xfree86/loader/Makefile.am
@@ -2,7 +2,7 @@ noinst_LTLIBRARIES = libloader.la
 
 INCLUDES = $(XORG_INCS) -I$(srcdir)/../parser -I$(top_srcdir)/miext/cw \
 	   -I$(srcdir)/../ddc -I$(srcdir)/../i2c -I$(srcdir)/../modes \
-	   -I$(srcdir)/../ramdac
+	   -I$(srcdir)/../ramdac -I$(srcdir)/../dri -I$(srcdir)/../dri2
 
 #AM_LDFLAGS = -r
 AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)
@@ -14,7 +14,6 @@ EXTRA_DIST = \
 libloader_la_SOURCES = \
 	loader.c \
 	loaderProcs.h \
-	loadext.c \
         loadmod.c \
 	os.c
 
diff --git a/xorg-server/hw/xfree86/loader/loaderProcs.h b/xorg-server/hw/xfree86/loader/loaderProcs.h
index a7b752b9a..8b4b53f28 100644
--- a/xorg-server/hw/xfree86/loader/loaderProcs.h
+++ b/xorg-server/hw/xfree86/loader/loaderProcs.h
@@ -80,7 +80,6 @@ ModuleDescPtr LoadModule(const char *, const char *, const char **,
 ModuleDescPtr DuplicateModule(ModuleDescPtr mod, ModuleDescPtr parent);
 void UnloadDriver(ModuleDescPtr);
 void LoaderSetPath(const char *path);
-void LoaderSortExtensions(void);
 
 void LoaderUnload(const char *, void *);
 unsigned long LoaderGetModuleVersion(ModuleDescPtr mod);
diff --git a/xorg-server/hw/xfree86/loader/loadext.c b/xorg-server/hw/xfree86/loader/loadext.c
deleted file mode 100644
index daa1abf8d..000000000
--- a/xorg-server/hw/xfree86/loader/loadext.c
+++ /dev/null
@@ -1,440 +0,0 @@
-/*
- * Copyright (c) 2000 by The XFree86 Project, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
- *
- * Except as contained in this notice, the name of the copyright holder(s)
- * and author(s) shall not be used in advertising or otherwise to promote
- * the sale, use or other dealings in this Software without prior written
- * authorization from the copyright holder(s) and author(s).
- */
-
-/* Maybe this file belongs elsewhere? */
-
-#define LOADERDECLARATIONS
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "loaderProcs.h"
-#include "misc.h"
-#include "xf86.h"
-
-/*
- * This should be static, but miinitext wants it.  FIXME: make extension
- * initialization not completely terrible.
- */
-ExtensionModule *ExtensionModuleList = NULL;
-static int numExtensionModules = 0;
-
-static ExtensionModule *
-NewExtensionModule(void)
-{
-    ExtensionModule *save = ExtensionModuleList;
-    int n;
-
-    /* Sanity check */
-    if (!ExtensionModuleList)
-        numExtensionModules = 0;
-
-    n = numExtensionModules + 1;
-    ExtensionModuleList = realloc(ExtensionModuleList,
-                                  (n + 1) * sizeof(ExtensionModule));
-    if (ExtensionModuleList == NULL) {
-        ExtensionModuleList = save;
-        return NULL;
-    }
-    else {
-        numExtensionModules++;
-        ExtensionModuleList[numExtensionModules].name = NULL;
-        return ExtensionModuleList + (numExtensionModules - 1);
-    }
-}
-
-void
-LoadExtension(ExtensionModule * e, Bool builtin)
-{
-    ExtensionModule *newext;
-
-    if (e == NULL || e->name == NULL)
-        return;
-
-    if (!(newext = NewExtensionModule()))
-        return;
-
-    if (builtin)
-        xf86MsgVerb(X_INFO, 2, "Initializing built-in extension %s\n", e->name);
-    else
-        xf86MsgVerb(X_INFO, 2, "Loading extension %s\n", e->name);
-
-    newext->name = e->name;
-    newext->initFunc = e->initFunc;
-    newext->disablePtr = e->disablePtr;
-    newext->setupFunc = e->setupFunc;
-    newext->initDependencies = e->initDependencies;
-
-    if (e->setupFunc != NULL)
-        e->setupFunc();
-}
-
-/*
- * Sort ExtensionModuleList according to the initialisation order
- * dependencies.  The code for this is taken from BSD's tsort,
- * and carries the following copyright/license:
- *
- *
- * Copyright (c) 1989, 1993, 1994
- *      The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Michael Rendell of Memorial University of Newfoundland.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#define	NF_MARK		0x1     /* marker for cycle detection */
-#define	NF_ACYCLIC	0x2     /* this node is cycle free */
-#define	NF_NODEST	0x4     /* Unreachable */
-
-typedef struct node_str NODE;
-struct node_str {
-    NODE **n_prevp;             /* pointer to previous node's n_next */
-    NODE *n_next;               /* next node in graph */
-    NODE **n_arcs;              /* array of arcs to other nodes */
-    int n_narcs;                /* number of arcs in n_arcs[] */
-    int n_arcsize;              /* size of n_arcs[] array */
-    int n_refcnt;               /* # of arcs pointing to this node */
-    int n_flags;                /* NF_* */
-    const char *n_name;         /* name of this node */
-};
-
-static NODE *graph = NULL, **cycle_buf = NULL, **longest_cycle = NULL;
-static int longest = 0;
-static NODE *sorted = NULL, *last = NULL;
-
-/* Find a node in the graph (insert if not found) and return a pointer to it. */
-static NODE *
-get_node(const char *name)
-{
-    NODE *n;
-
-    for (n = graph; n && n->n_name && strcmp(n->n_name, name); n = n->n_next);
-    if (n)
-        return n;
-
-    n = xnfalloc(sizeof(NODE));
-
-    n->n_narcs = 0;
-    n->n_arcsize = 0;
-    n->n_arcs = NULL;
-    n->n_refcnt = 0;
-    n->n_flags = 0;
-    n->n_name = name;
-
-    /* Add to linked list. */
-    if ((n->n_next = graph) != NULL)
-        graph->n_prevp = &n->n_next;
-    n->n_prevp = &graph;
-    graph = n;
-
-    return n;
-}
-
-/*
- * add an arc from node s1 to node s2 in the graph.  If s1 or s2 are not in
- * the graph, then add them.
- */
-static void
-add_arc(const char *s1, const char *s2)
-{
-    NODE *n1;
-    NODE *n2;
-    int bsize, i;
-
-    n1 = get_node(s1);
-
-    if (!strcmp(s1, s2))
-        return;
-
-    n2 = get_node(s2);
-
-    /*
-     * Check if this arc is already here.
-     */
-    for (i = 0; i < n1->n_narcs; i++)
-        if (n1->n_arcs[i] == n2)
-            return;
-    /*
-     * Add it.
-     */
-    if (n1->n_narcs == n1->n_arcsize) {
-        if (!n1->n_arcsize)
-            n1->n_arcsize = 10;
-        bsize = n1->n_arcsize * sizeof(*n1->n_arcs) * 2;
-        n1->n_arcs = xnfrealloc(n1->n_arcs, bsize);
-        n1->n_arcsize = bsize / sizeof(*n1->n_arcs);
-    }
-    n1->n_arcs[n1->n_narcs++] = n2;
-    ++n2->n_refcnt;
-}
-
-/*
- * Clear the NODEST flag from all nodes.
- */
-static void
-clear_cycle(void)
-{
-    NODE *n;
-
-    for (n = graph; n != NULL; n = n->n_next)
-        n->n_flags &= ~NF_NODEST;
-}
-
-/* print node and remove from graph (does not actually free node) */
-static void
-remove_node(NODE * n)
-{
-    NODE **np;
-    NODE *newnode;
-    int i;
-
-#ifdef DEBUG
-    ErrorF("%s\n", n->n_name);
-#endif
-    newnode = xnfalloc(sizeof(NODE));
-    memcpy(newnode, n, sizeof(NODE));
-    if (last)
-        last->n_next = newnode;
-    else
-        sorted = newnode;
-    last = newnode;
-    newnode->n_next = NULL;
-
-    for (np = n->n_arcs, i = n->n_narcs; --i >= 0; np++)
-        --(*np)->n_refcnt;
-    n->n_narcs = 0;
-    *n->n_prevp = n->n_next;
-    if (n->n_next)
-        n->n_next->n_prevp = n->n_prevp;
-}
-
-static void
-free_nodes(NODE * nodelist)
-{
-    NODE *n, *nextnode;
-
-    for (n = nodelist; n;) {
-        nextnode = n->n_next;
-        free(n);
-        n = nextnode;
-    }
-}
-
-/* look for the longest? cycle from node from to node to. */
-static int
-find_cycle(NODE * from, NODE * to, int longest_len, int depth)
-{
-    NODE **np;
-    int i, len;
-
-    /*
-     * avoid infinite loops and ignore portions of the graph known
-     * to be acyclic
-     */
-    if (from->n_flags & (NF_NODEST | NF_MARK | NF_ACYCLIC))
-        return 0;
-    from->n_flags |= NF_MARK;
-
-    for (np = from->n_arcs, i = from->n_narcs; --i >= 0; np++) {
-        cycle_buf[depth] = *np;
-        if (*np == to) {
-            if (depth + 1 > longest_len) {
-                longest_len = depth + 1;
-                memcpy((char *) longest_cycle,
-                       (char *) cycle_buf, longest_len * sizeof(NODE *));
-            }
-        }
-        else {
-            if ((*np)->n_flags & (NF_MARK | NF_ACYCLIC | NF_NODEST))
-                continue;
-            len = find_cycle(*np, to, longest_len, depth + 1);
-
-#ifdef DEBUG
-            ErrorF("%*s %s->%s %d\n", depth, "", from->n_name, to->n_name, len);
-#endif
-
-            if (len == 0)
-                (*np)->n_flags |= NF_NODEST;
-
-            if (len > longest_len)
-                longest_len = len;
-
-            if (len > 0 && !longest)
-                break;
-        }
-    }
-    from->n_flags &= ~NF_MARK;
-    return longest_len;
-}
-
-/* do topological sort on graph */
-static void
-tsort(void)
-{
-    NODE *n, *next;
-    int cnt, i;
-
-    while (graph != NULL) {
-        /*
-         * Keep getting rid of simple cases until there are none left,
-         * if there are any nodes still in the graph, then there is
-         * a cycle in it.
-         */
-        do {
-            for (cnt = 0, n = graph; n != NULL; n = next) {
-                next = n->n_next;
-                if (n->n_refcnt == 0) {
-                    remove_node(n);
-                    ++cnt;
-                }
-            }
-        } while (graph != NULL && cnt);
-
-        if (graph == NULL)
-            break;
-
-        if (!cycle_buf) {
-            /*
-             * Allocate space for two cycle logs - one to be used
-             * as scratch space, the other to save the longest
-             * cycle.
-             */
-            for (cnt = 0, n = graph; n != NULL; n = n->n_next)
-                ++cnt;
-            cycle_buf = xnfalloc(sizeof(NODE *) * cnt);
-            longest_cycle = xnfalloc(sizeof(NODE *) * cnt);
-            if (cycle_buf == NULL || longest_cycle == NULL)
-                return;
-        }
-        for (n = graph; n != NULL; n = n->n_next)
-            if (!(n->n_flags & NF_ACYCLIC)) {
-                if ((cnt = find_cycle(n, n, 0, 0))) {
-                    ErrorF("tsort: cycle in data");
-                    for (i = 0; i < cnt; i++)
-                        ErrorF("%s", longest_cycle[i]->n_name);
-                    remove_node(n);
-                    clear_cycle();
-                    break;
-                }
-                else {
-                    /* to avoid further checks */
-                    n->n_flags |= NF_ACYCLIC;
-                    clear_cycle();
-                }
-            }
-
-        if (n == NULL)
-            ErrorF("tsort: internal error -- could not find cycle");
-    }
-    free(cycle_buf);
-    free(longest_cycle);
-    if (graph)
-        free_nodes(graph);
-}
-
-void
-LoaderSortExtensions(void)
-{
-    int i, j;
-    ExtensionModule *ext, *newList;
-    NODE *node;
-
-    graph = NULL;
-    longest = 0;
-    sorted = NULL;
-    last = NULL;
-    cycle_buf = NULL;
-    longest_cycle = NULL;
-
-    /*
-     * Parse list and build the graph.  Enter them in reverse order
-     * because tsort() will reverse those that have no depedencies.
-     */
-    for (i = numExtensionModules - 1; i >= 0; i--) {
-        ext = &ExtensionModuleList[i];
-        add_arc(ext->name, ext->name);
-#ifdef DEBUG
-        ErrorF("Extension %s:\n", ext->name);
-#endif
-        if (ext->initDependencies)
-            for (j = 0; ext->initDependencies[j]; j++) {
-                add_arc(ext->initDependencies[j], ext->name);
-#ifdef DEBUG
-                ErrorF("\t%s\n", ext->initDependencies[j]);
-#endif
-            }
-    }
-    tsort();
-    newList = xnfalloc((numExtensionModules + 1) * sizeof(ExtensionModule));
-    i = 0;
-    for (node = sorted; node; node = node->n_next) {
-        for (j = 0; j < numExtensionModules; j++)
-            if (!strcmp(node->n_name, ExtensionModuleList[j].name))
-                break;
-        if (j != numExtensionModules)
-            newList[i++] = ExtensionModuleList[j];
-    }
-    if (sorted)
-        free_nodes(sorted);
-    if (graph)
-        free_nodes(graph);
-    newList[i].name = NULL;
-    free(ExtensionModuleList);
-    ExtensionModuleList = newList;
-#ifdef DEBUG
-    for (i = 0; ExtensionModuleList[i].name; i++)
-        ErrorF("Extension %s\n", ExtensionModuleList[i].name);
-#endif
-}
diff --git a/xorg-server/hw/xfree86/loader/loadmod.c b/xorg-server/hw/xfree86/loader/loadmod.c
index dd2057318..2347b8e5b 100644
--- a/xorg-server/hw/xfree86/loader/loadmod.c
+++ b/xorg-server/hw/xfree86/loader/loadmod.c
@@ -833,6 +833,11 @@ static const char *compiled_in_modules[] = {
     "ddc",
     "i2c",
     "ramdac",
+    "dbe",
+    "record",
+    "extmod",
+    "dri",
+    "dri2",
     NULL
 };
 
@@ -992,10 +997,6 @@ doLoadModule(const char *module, const char *path, const char **subdirlist,
         ret->VersionInfo = vers;
     }
     else {
-        /* No initdata is OK for external modules */
-        if (options == EXTERN_MODULE)
-            goto LoadModule_exit;
-
         /* no initdata, fail the load */
         xf86Msg(X_ERROR, "LoadModule: Module %s does not have a %s "
                 "data object.\n", module, p);
diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.c b/xorg-server/hw/xfree86/modes/xf86Crtc.c
index 2c8878fa7..d20152ce6 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.c
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.c
@@ -734,10 +734,27 @@ xf86CrtcCloseScreen(ScreenPtr screen)
     for (c = 0; c < config->num_crtc; c++) {
         xf86CrtcPtr crtc = config->crtc[c];
 
+        if (crtc->randr_crtc->scanout_pixmap)
+            RRCrtcDetachScanoutPixmap(crtc->randr_crtc);
+
         crtc->randr_crtc = NULL;
     }
+    /* detach any providers */
+    if (config->randr_provider) {
+        if (config->randr_provider->offload_sink) {
+            DetachOffloadGPU(screen);
+            config->randr_provider->offload_sink = NULL;
+        }
+        else if (config->randr_provider->output_source) {
+            DetachOutputGPU(screen);
+            config->randr_provider->output_source = NULL;
+        }
+        else if (screen->current_master)
+            DetachUnboundGPU(screen);
+    }
     xf86RandR12CloseScreen(screen);
 
+    free(config->name);
     return screen->CloseScreen(screen);
 }
 
@@ -3202,3 +3219,40 @@ xf86_crtc_supports_gamma(ScrnInfoPtr pScrn)
 
     return FALSE;
 }
+
+void
+xf86ProviderSetup(ScrnInfoPtr scrn,
+                  const xf86ProviderFuncsRec *funcs, const char *name)
+{
+    xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+
+    assert(!xf86_config->name);
+    assert(name);
+
+    xf86_config->name = strdup(name);
+    xf86_config->provider_funcs = funcs;
+#ifdef RANDR_12_INTERFACE
+    xf86_config->randr_provider = NULL;
+#endif
+}
+
+void
+xf86DetachAllCrtc(ScrnInfoPtr scrn)
+{
+        xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+        int i;
+
+        for (i = 0; i < xf86_config->num_crtc; i++) {
+            xf86CrtcPtr crtc = xf86_config->crtc[i];
+
+            if (crtc->randr_crtc)
+                RRCrtcDetachScanoutPixmap(crtc->randr_crtc);
+
+            /* dpms off */
+            (*crtc->funcs->dpms) (crtc, DPMSModeOff);
+            /* force a reset the next time its used */
+            crtc->randr_crtc->mode = NULL;
+            crtc->mode.HDisplay = 0;
+            crtc->x = crtc->y = 0;
+        }
+}
diff --git a/xorg-server/hw/xfree86/modes/xf86Crtc.h b/xorg-server/hw/xfree86/modes/xf86Crtc.h
index a6a3c2e95..802303f74 100644
--- a/xorg-server/hw/xfree86/modes/xf86Crtc.h
+++ b/xorg-server/hw/xfree86/modes/xf86Crtc.h
@@ -218,9 +218,14 @@ typedef struct _xf86CrtcFuncs {
     void
      (*set_origin) (xf86CrtcPtr crtc, int x, int y);
 
+    /**
+     */
+    Bool
+    (*set_scanout_pixmap)(xf86CrtcPtr crtc, PixmapPtr pixmap);
+
 } xf86CrtcFuncsRec, *xf86CrtcFuncsPtr;
 
-#define XF86_CRTC_VERSION 4
+#define XF86_CRTC_VERSION 5
 
 struct _xf86Crtc {
     /**
@@ -371,6 +376,10 @@ struct _xf86Crtc {
      * Added in ABI version 4
      */
     Bool driverIsPerformingTransform;
+
+    /* Added in ABI version 5
+     */
+    PixmapPtr current_scanout;
 };
 
 typedef struct _xf86OutputFuncs {
@@ -607,6 +616,29 @@ struct _xf86Output {
     INT16 initialBorder[4];
 };
 
+typedef struct _xf86ProviderFuncs {
+    /**
+     * Called to allow the provider a chance to create properties after the
+     * RandR objects have been created.
+     */
+    void
+    (*create_resources) (ScrnInfoPtr scrn);
+
+    /**
+     * Callback when an provider's property has changed.
+     */
+    Bool
+    (*set_property) (ScrnInfoPtr scrn,
+                     Atom property, RRPropertyValuePtr value);
+
+    /**
+     * Callback to get an updated property value
+     */
+    Bool
+    (*get_property) (ScrnInfoPtr provider, Atom property);
+
+} xf86ProviderFuncsRec, *xf86ProviderFuncsPtr;
+
 typedef struct _xf86CrtcConfigFuncs {
     /**
      * Requests that the driver resize the screen.
@@ -681,6 +713,13 @@ typedef struct _xf86CrtcConfig {
     /* callback when crtc configuration changes */
     xf86_crtc_notify_proc_ptr xf86_crtc_notify;
 
+    char *name;
+    const xf86ProviderFuncsRec *provider_funcs;
+#ifdef RANDR_12_INTERFACE
+    RRProviderPtr randr_provider;
+#else
+    void *randr_provider;
+#endif
 } xf86CrtcConfigRec, *xf86CrtcConfigPtr;
 
 extern _X_EXPORT int xf86CrtcConfigPrivateIndex;
@@ -975,4 +1014,11 @@ extern _X_EXPORT void
 extern _X_EXPORT Bool
  xf86_crtc_supports_gamma(ScrnInfoPtr pScrn);
 
+extern _X_EXPORT void
+xf86ProviderSetup(ScrnInfoPtr scrn,
+                  const xf86ProviderFuncsRec * funcs, const char *name);
+
+extern _X_EXPORT void
+xf86DetachAllCrtc(ScrnInfoPtr scrn);
+
 #endif                          /* _XF86CRTC_H_ */
diff --git a/xorg-server/hw/xfree86/modes/xf86DiDGA.c b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
index bb954ac4b..3f1a3309f 100644
--- a/xorg-server/hw/xfree86/modes/xf86DiDGA.c
+++ b/xorg-server/hw/xfree86/modes/xf86DiDGA.c
@@ -178,7 +178,7 @@ _xf86_di_dga_reinit_internal(ScreenPtr pScreen)
     ScrnInfoPtr scrn = xf86ScreenToScrn(pScreen);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
 
-    if (!DGAAvailable(pScreen->myNum))
+    if (!DGAScreenAvailable(pScreen))
         return TRUE;
 
     if (!xf86_dga_get_modes(pScreen))
diff --git a/xorg-server/hw/xfree86/modes/xf86RandR12.c b/xorg-server/hw/xfree86/modes/xf86RandR12.c
index 59b6f8217..b4ed46aeb 100644
--- a/xorg-server/hw/xfree86/modes/xf86RandR12.c
+++ b/xorg-server/hw/xfree86/modes/xf86RandR12.c
@@ -1157,6 +1157,9 @@ xf86RandR12CrtcSet(ScreenPtr pScreen,
     if (rotation != crtc->rotation)
         changed = TRUE;
 
+    if (crtc->current_scanout != randr_crtc->scanout_pixmap)
+        changed = TRUE;
+
     transform = RRCrtcGetTransform(randr_crtc);
     if ((transform != NULL) != crtc->transformPresent)
         changed = TRUE;
@@ -1218,6 +1221,7 @@ xf86RandR12CrtcSet(ScreenPtr pScreen,
              */
             crtc->desiredMode = mode;
             crtc->desiredRotation = rotation;
+            crtc->current_scanout = randr_crtc->scanout_pixmap;
             if (transform) {
                 crtc->desiredTransform = *transform;
                 crtc->desiredTransformPresent = TRUE;
@@ -1552,6 +1556,14 @@ xf86RandR12CreateObjects12(ScreenPtr pScreen)
             output->funcs->create_resources(output);
         RRPostPendingProperties(output->randr_output);
     }
+
+    if (config->name) {
+        config->randr_provider = RRProviderCreate(pScreen, config->name,
+                                                  strlen(config->name));
+
+        RRProviderSetCapabilities(config->randr_provider, pScrn->capabilities);
+    }
+
     return TRUE;
 }
 
@@ -1746,6 +1758,108 @@ xf86RandR12EnterVT(ScrnInfoPtr pScrn)
 }
 
 static Bool
+xf86RandR14ProviderSetOutputSource(ScreenPtr pScreen,
+                                   RRProviderPtr provider,
+                                   RRProviderPtr source_provider)
+{
+
+
+    if (!source_provider) {
+        if (provider->output_source) {
+            ScreenPtr cmScreen = pScreen->current_master;
+
+            DetachOutputGPU(pScreen);
+            AttachUnboundGPU(cmScreen, pScreen);
+        }
+        provider->output_source = NULL;
+        return TRUE;
+    }
+
+    if (provider->output_source == source_provider)
+        return TRUE;
+
+    SetRootClip(source_provider->pScreen, FALSE);
+
+    DetachUnboundGPU(pScreen);
+    AttachOutputGPU(source_provider->pScreen, pScreen);
+
+    provider->output_source = source_provider;
+    SetRootClip(source_provider->pScreen, TRUE);
+    return TRUE;
+}
+
+static Bool
+xf86RandR14ProviderSetOffloadSink(ScreenPtr pScreen,
+                                  RRProviderPtr provider,
+                                  RRProviderPtr sink_provider)
+{
+    if (!sink_provider) {
+        if (provider->offload_sink) {
+            ScreenPtr cmScreen = pScreen->current_master;
+            DetachOutputGPU(pScreen);
+            AttachUnboundGPU(cmScreen, pScreen);
+        }
+
+        provider->offload_sink = NULL;
+        return TRUE;
+    }
+
+    if (provider->offload_sink == sink_provider)
+        return TRUE;
+
+    DetachUnboundGPU(pScreen);
+    AttachOffloadGPU(sink_provider->pScreen, pScreen);
+
+    provider->offload_sink = sink_provider;
+    return TRUE;
+}
+
+static Bool
+xf86RandR14ProviderSetProperty(ScreenPtr pScreen,
+                             RRProviderPtr randr_provider,
+                             Atom property, RRPropertyValuePtr value)
+{
+    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+
+    /* If we don't have any property handler, then we don't care what the
+     * user is setting properties to.
+     */
+    if (config->provider_funcs->set_property == NULL)
+        return TRUE;
+
+    /*
+     * This function gets called even when vtSema is FALSE, as
+     * drivers will need to remember the correct value to apply
+     * when the VT switch occurs
+     */
+    return config->provider_funcs->set_property(pScrn, property, value);
+}
+
+static Bool
+xf86RandR14ProviderGetProperty(ScreenPtr pScreen,
+                               RRProviderPtr randr_provider, Atom property)
+{
+    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
+    xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
+
+    if (config->provider_funcs->get_property == NULL)
+        return TRUE;
+
+    /* Should be safe even w/o vtSema */
+    return config->provider_funcs->get_property(pScrn, property);
+}
+
+static Bool
+xf86CrtcSetScanoutPixmap(RRCrtcPtr randr_crtc, PixmapPtr pixmap)
+{
+    xf86CrtcPtr crtc = randr_crtc->devPrivate;
+    if (!crtc->funcs->set_scanout_pixmap)
+        return FALSE;
+    return crtc->funcs->set_scanout_pixmap(crtc, pixmap);
+}
+
+static Bool
 xf86RandR12Init12(ScreenPtr pScreen)
 {
     ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
@@ -1767,6 +1881,14 @@ xf86RandR12Init12(ScreenPtr pScreen)
 #endif
     rp->rrModeDestroy = xf86RandR12ModeDestroy;
     rp->rrSetConfig = NULL;
+
+    rp->rrProviderSetOutputSource = xf86RandR14ProviderSetOutputSource;
+    rp->rrProviderSetOffloadSink = xf86RandR14ProviderSetOffloadSink;
+
+    rp->rrProviderSetProperty = xf86RandR14ProviderSetProperty;
+    rp->rrProviderGetProperty = xf86RandR14ProviderGetProperty;
+    rp->rrCrtcSetScanoutPixmap = xf86CrtcSetScanoutPixmap;
+
     pScrn->PointerMoved = xf86RandR12PointerMoved;
     pScrn->ChangeGamma = xf86RandR12ChangeGamma;
 
diff --git a/xorg-server/hw/xfree86/modes/xf86Rotate.c b/xorg-server/hw/xfree86/modes/xf86Rotate.c
index 31e03727e..a3937478f 100644
--- a/xorg-server/hw/xfree86/modes/xf86Rotate.c
+++ b/xorg-server/hw/xfree86/modes/xf86Rotate.c
@@ -322,6 +322,12 @@ xf86CrtcFitsScreen(xf86CrtcPtr crtc, struct pict_f_transform *crtc_to_fb)
     /* When called before PreInit, the driver is
      * presumably doing load detect
      */
+    if (pScrn->is_gpu) {
+	ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
+	if (pScreen->current_master)
+	    pScrn = xf86ScreenToScrn(pScreen->current_master);
+    }
+
     if (pScrn->virtualX == 0 || pScrn->virtualY == 0)
         return TRUE;
 
diff --git a/xorg-server/hw/xfree86/os-support/shared/vidmem.c b/xorg-server/hw/xfree86/os-support/shared/vidmem.c
index a7717d8f6..514fc2fa7 100644
--- a/xorg-server/hw/xfree86/os-support/shared/vidmem.c
+++ b/xorg-server/hw/xfree86/os-support/shared/vidmem.c
@@ -157,19 +157,6 @@ checkMtrrOption(VidMapPtr vp)
 }
 
 void
-xf86MakeNewMapping(int ScreenNum, int Flags, unsigned long Base,
-                   unsigned long Size, pointer Vbase)
-{
-    VidMapPtr vp;
-    MappingPtr mp;
-
-    vp = getVidMapRec(ScreenNum);
-    mp = newMapping(vp);
-    mp->size = Size;
-    mp->virtBase = Vbase;
-}
-
-void
 xf86InitVidMem(void)
 {
     if (!vidMemInfo.initialised) {
diff --git a/xorg-server/hw/xfree86/os-support/xf86_OSproc.h b/xorg-server/hw/xfree86/os-support/xf86_OSproc.h
index 2f0172e15..ea2b16e46 100644
--- a/xorg-server/hw/xfree86/os-support/xf86_OSproc.h
+++ b/xorg-server/hw/xfree86/os-support/xf86_OSproc.h
@@ -215,8 +215,6 @@ extern _X_EXPORT int xf86ProcessArgument(int, char **, int);
 extern _X_EXPORT void xf86UseMsg(void);
 extern _X_EXPORT PMClose xf86OSPMOpen(void);
 
-extern _X_EXPORT _X_DEPRECATED void xf86MakeNewMapping(int, int, unsigned long,
-                                                       unsigned long, pointer);
 extern _X_EXPORT void xf86InitVidMem(void);
 
 #endif                          /* XF86_OS_PRIVS */
diff --git a/xorg-server/hw/xfree86/ramdac/.gitignore b/xorg-server/hw/xfree86/ramdac/.gitignore
deleted file mode 100644
index 9074a4300..000000000
--- a/xorg-server/hw/xfree86/ramdac/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-#		Add & Override for this directory and it's subdirectories

-xf86BitOrder.c

diff --git a/xorg-server/hw/xfree86/ramdac/Makefile.am b/xorg-server/hw/xfree86/ramdac/Makefile.am
index 3c3780516..346af4ccc 100644
--- a/xorg-server/hw/xfree86/ramdac/Makefile.am
+++ b/xorg-server/hw/xfree86/ramdac/Makefile.am
@@ -1,19 +1,12 @@
 noinst_LTLIBRARIES = libramdac.la
 
 libramdac_la_SOURCES = xf86RamDac.c xf86RamDacCmap.c \
-                      xf86Cursor.c xf86HWCurs.c IBM.c BT.c TI.c \
-		      xf86BitOrder.c
+                      xf86Cursor.c xf86HWCurs.c IBM.c BT.c TI.c
 
 sdk_HEADERS = BT.h IBM.h TI.h xf86Cursor.h xf86RamDac.h
 
-DISTCLEANFILES = xf86BitOrder.c
 EXTRA_DIST = BTPriv.h IBMPriv.h TIPriv.h xf86CursorPriv.h xf86RamDacPriv.h \
 	CURSOR.NOTES
 
-AM_CFLAGS = -DXAAReverseBitOrder=xf86ReverseBitOrder -DRAMDAC_MODULE \
-            $(DIX_CFLAGS) $(XORG_CFLAGS)
+AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)
 INCLUDES = $(XORG_INCS)
-
-xf86BitOrder.c:
-	$(AM_V_GEN)echo "#define XAAReverseBitOrder xf86ReverseBitOrder" > $@
-	$(AM_V_GEN)echo "#include \"$(srcdir)/../xaa/xaaBitOrder.c\"" >> $@
diff --git a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
index 8b91e0574..8d48a7542 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86Cursor.c
@@ -336,7 +336,7 @@ xf86CursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs,
         if (!infoPtr->pScrn->vtSema)
             ScreenPriv->SavedCursor = pCurs;
 
-        if (infoPtr->pScrn->vtSema &&
+        if (infoPtr->pScrn->vtSema && xorg_list_is_empty(&pScreen->pixmap_dirty_list) &&
             (ScreenPriv->ForceHWCursorCount ||
              ((
 #ifdef ARGB_CURSOR
diff --git a/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h b/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
index d04f93207..04be14135 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
+++ b/xorg-server/hw/xfree86/ramdac/xf86CursorPriv.h
@@ -43,8 +43,6 @@ void xf86MoveCursor(ScreenPtr pScreen, int x, int y);
 void xf86RecolorCursor(ScreenPtr pScreen, CursorPtr pCurs, Bool displayed);
 Bool xf86InitHardwareCursor(ScreenPtr pScreen, xf86CursorInfoPtr infoPtr);
 
-CARD32 xf86ReverseBitOrder(CARD32 data);
-
 extern _X_EXPORT DevPrivateKeyRec xf86CursorScreenKeyRec;
 
 #define xf86CursorScreenKey (&xf86CursorScreenKeyRec)
diff --git a/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c b/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
index cb62d9b20..197abff8f 100644
--- a/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
+++ b/xorg-server/hw/xfree86/ramdac/xf86HWCurs.c
@@ -21,6 +21,15 @@
 
 #include "servermd.h"
 
+static CARD32
+xf86ReverseBitOrder(CARD32 v)
+{
+    return (((0x01010101 & v) << 7) | ((0x02020202 & v) << 5) |
+            ((0x04040404 & v) << 3) | ((0x08080808 & v) << 1) |
+            ((0x10101010 & v) >> 1) | ((0x20202020 & v) >> 3) |
+            ((0x40404040 & v) >> 5) | ((0x80808080 & v) >> 7));
+}
+
 #if BITMAP_SCANLINE_PAD == 64
 
 #if 1
diff --git a/xorg-server/hw/xfree86/sdksyms.sh b/xorg-server/hw/xfree86/sdksyms.sh
index f6c3f2244..c0398da18 100644
--- a/xorg-server/hw/xfree86/sdksyms.sh
+++ b/xorg-server/hw/xfree86/sdksyms.sh
@@ -46,10 +46,8 @@ cat > sdksyms.c << EOF
 #include "misyncstr.h"
 
 /* Xext/Makefile.am -- half is module, half is builtin */
-/*
 #include "xvdix.h"
 #include "xvmcext.h"
- */
 #include "geext.h"
 #include "geint.h"
 #ifdef MITSHM
@@ -95,11 +93,9 @@ cat > sdksyms.c << EOF
 
 
 /* hw/xfree86/dri2/Makefile.am -- module */
-/*
 #if DRI2
 # include "dri2.h"
 #endif
- */
 
 
 /* hw/xfree86/vgahw/Makefile.am -- module */
@@ -135,12 +131,9 @@ cat > sdksyms.c << EOF
 # include "xf86xvmc.h"
 # include "xf86xvpriv.h"
 #endif
-/* XF86VidMode code is in libextmod module */
-/*
 #if XF86VIDMODE
 # include "vidmodeproc.h"
 #endif
- */
 #include "xorgVersion.h"
 #if defined(__sparc__) || defined(__sparc)
 # include "xf86sbusBus.h"
@@ -181,18 +174,10 @@ cat > sdksyms.c << EOF
 #endif
 
 
-/* hw/xfree86/xaa/Makefile.am -- module */
-/*
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaarop.h"
- */
-
-
 /* hw/xfree86/dixmods/extmod/Makefile.am -- module */
-/*
+#ifdef XFreeXDGA
 #include "dgaproc.h"
- */
+#endif
 
 
 /* hw/xfree86/parser/Makefile.am */
@@ -208,13 +193,11 @@ cat > sdksyms.c << EOF
 
 
 /* hw/xfree86/dri/Makefile.am -- module */
-/*
 #if XF86DRI
 # include "dri.h"
 # include "sarea.h"
 # include "dristruct.h"
 #endif
- */
 
 
 /* mi/Makefile.am */
@@ -241,9 +224,9 @@ cat > sdksyms.c << EOF
 
 
 /* dbe/Makefile.am -- module */
-/*
+#ifdef DBE
 #include "dbestruct.h"
- */
+#endif
 
 
 /* exa/Makefile.am -- module */
@@ -279,7 +262,6 @@ cat > sdksyms.c << EOF
 #include "dixstruct.h"
 #include "exevents.h"
 #include "extension.h"
-#include "extinit.h"
 #include "extnsionst.h"
 #include "gc.h"
 #include "gcstruct.h"
@@ -327,8 +309,8 @@ topdir=$1
 shift
 LC_ALL=C
 export LC_ALL
-${CPP:-cpp} "$@" -DXorgLoader sdksyms.c > /dev/null || exit $?
-${CPP:-cpp} "$@" -DXorgLoader sdksyms.c | ${AWK:-awk} -v topdir=$topdir '
+${CPP:-cpp} "$@" sdksyms.c > /dev/null || exit $?
+${CPP:-cpp} "$@" sdksyms.c | ${AWK:-awk} -v topdir=$topdir '
 BEGIN {
     sdk = 0;
     print("/*");
diff --git a/xorg-server/hw/xfree86/vgahw/vgaCmap.c b/xorg-server/hw/xfree86/vgahw/vgaCmap.c
index a1aa405a8..e7a0d023e 100644
--- a/xorg-server/hw/xfree86/vgahw/vgaCmap.c
+++ b/xorg-server/hw/xfree86/vgahw/vgaCmap.c
@@ -97,7 +97,7 @@ xColorItem *pdefs;
     }
 
     writeColormap = scrninfp->vtSema;
-    if (DGAAvailable(scrnIndex)) {
+    if (DGAScreenAvailable(pmap->pScreen)) {
         writeColormap = writeColormap ||
             (DGAGetDirectMode(scrnIndex) &&
              !(DGAGetFlags(scrnIndex) & XF86DGADirectColormap)) ||
diff --git a/xorg-server/hw/xfree86/xaa/.gitignore b/xorg-server/hw/xfree86/xaa/.gitignore
deleted file mode 100644
index 1ba5b2602..000000000
--- a/xorg-server/hw/xfree86/xaa/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-#		Add & Override for this directory and it's subdirectories

-[lms]-xaa*.c

-[lm]f3-xaa*.c

-[lm][f3]-xaa*.c

diff --git a/xorg-server/hw/xfree86/xaa/Makefile.am b/xorg-server/hw/xfree86/xaa/Makefile.am
deleted file mode 100644
index 5614d723a..000000000
--- a/xorg-server/hw/xfree86/xaa/Makefile.am
+++ /dev/null
@@ -1,79 +0,0 @@
-LSB_FIRST = l-xaaBitmap.c l-xaaStipple.c l-xaaTEGlyph.c
-LSB_3_FIRST = l3-xaaBitmap.c l3-xaaStipple.c
-MSB_FIRST = m-xaaBitmap.c m-xaaStipple.c m-xaaTEGlyph.c
-MSB_3_FIRST = m3-xaaBitmap.c m3-xaaStipple.c
-LSB_FIXED = lf-xaaBitmap.c lf-xaaStipple.c lf-xaaTEGlyph.c
-LSB_3_FIXED = lf3-xaaBitmap.c lf3-xaaStipple.c
-MSB_FIXED = mf-xaaBitmap.c mf-xaaStipple.c mf-xaaTEGlyph.c
-MSB_3_FIXED = mf3-xaaBitmap.c mf3-xaaStipple.c
-POLYSEG = s-xaaLine.c s-xaaDashLine.c
-
-if XAA
-
-libxaa_la_LDFLAGS = -module -avoid-version $(LD_NO_UNDEFINED_FLAG)
-libxaa_la_LIBADD = $(PIXMAN_LIBS)
-if COMPOSITE
-libxaa_la_LIBADD += $(top_builddir)/miext/cw/libcw.la
-endif
-
-module_LTLIBRARIES = libxaa.la
-libxaa_la_SOURCES = xaaInit.c xaaGC.c xaaInitAccel.c xaaFallback.c \
-                   xaaBitBlt.c xaaCpyArea.c xaaGCmisc.c xaaCpyWin.c \
-                   xaaCpyPlane.c xaaFillRect.c xaaTEText.c xaaNonTEText.c \
-                   xaaPCache.c xaaSpans.c xaaROP.c xaaImage.c \
-                   xaaRect.c xaaLineMisc.c xaaBitOrder.c \
-                   xaaFillPoly.c xaaWideLine.c xaaTables.c xaaFillArc.c \
-                   xaaLine.c xaaDashLine.c xaaOverlay.c xaaOffscreen.c \
-                   xaaOverlayDF.c xaaStateChange.c xaaPict.c $(POLYSEG) \
-                   $(LSB_FIRST) $(MSB_FIRST) $(LSB_FIXED) $(MSB_FIXED) \
-                   $(LSB_3_FIRST) $(MSB_3_FIRST) $(LSB_3_FIXED) $(MSB_3_FIXED)
-${POLYSEG}:
-	$(AM_V_GEN)echo "#define POLYSEGMENT" > $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:s-%=%}"' >> $@
-${LSB_FIRST}:
-	$(AM_V_GEN)echo "#define LSBFIRST" > $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:l-%=%}"' >> $@
-${LSB_3_FIRST}:
-	$(AM_V_GEN)echo "#define LSBFIRST" > $@
-	$(AM_V_GEN)echo "#define TRIPLE_BITS" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:l3-%=%}"' >> $@
-${LSB_FIXED}:
-	$(AM_V_GEN)echo "#define LSBFIRST" > $@
-	$(AM_V_GEN)echo "#define FIXEDBASE" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:lf-%=%}"' >> $@
-${LSB_3_FIXED}:
-	$(AM_V_GEN)echo "#define LSBFIRST" > $@
-	$(AM_V_GEN)echo "#define TRIPLE_BITS" >> $@
-	$(AM_V_GEN)echo "#define FIXEDBASE" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:lf3-%=%}"' >> $@
-${MSB_FIRST}:
-	$(AM_V_GEN)echo "#define MSBFIRST" > $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:m-%=%}"' >> $@
-${MSB_3_FIRST}:
-	$(AM_V_GEN)echo "#define MSBFIRST" > $@
-	$(AM_V_GEN)echo "#define TRIPLE_BITS" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:m3-%=%}"' >> $@
-${MSB_FIXED}:
-	$(AM_V_GEN)echo "#define MSBFIRST" > $@
-	$(AM_V_GEN)echo "#define FIXEDBASE" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:mf-%=%}"' >> $@
-${MSB_3_FIXED}:
-	$(AM_V_GEN)echo "#define MSBFIRST" > $@
-	$(AM_V_GEN)echo "#define TRIPLE_BITS" >> $@
-	$(AM_V_GEN)echo "#define FIXEDBASE" >> $@
-	$(AM_V_GEN)echo '#include "$(srcdir)/${@:mf3-%=%}"' >> $@
-
-endif # XAA
-
-DISTCLEANFILES = $(POLYSEG) \
-	$(LSB_FIRST) $(LSB_FIXED) $(MSB_FIRST) $(MSB_FIXED) \
-	$(LSB_3_FIRST) $(LSB_3_FIXED) $(MSB_3_FIRST) $(MSB_3_FIXED)
-
-sdk_HEADERS = xaa.h xaalocal.h xaarop.h
-EXTRA_DIST = xaacexp.h xaawrap.h xaaLine.c xaaDashLine.c \
-             xaaStipple.c xaaTEGlyph.c xaaNonTEGlyph.c xaaBitmap.c \
-             XAA.HOWTO
-
-INCLUDES = $(XORG_INCS) -I$(srcdir)/../../../miext/cw
-
-AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)
diff --git a/xorg-server/hw/xfree86/xaa/XAA.HOWTO b/xorg-server/hw/xfree86/xaa/XAA.HOWTO
deleted file mode 100644
index 531ead0a0..000000000
--- a/xorg-server/hw/xfree86/xaa/XAA.HOWTO
+++ /dev/null
@@ -1,1427 +0,0 @@
-

-

-                          XAA.HOWTO

-

-  This file describes how to add basic XAA support to a chipset driver.

-

-0)  What is XAA

-1)  XAA Initialization and Shutdown

-2)  The Primitives

-  2.0  Generic Flags

-  2.1  Screen to Screen Copies

-  2.2  Solid Fills

-  2.3  Solid Lines

-  2.4  Dashed Lines

-  2.5  Color Expand Fills

-    2.5.1 Screen to Screen Color Expansion

-    2.5.2 CPU to Screen Color Expansion

-      2.5.2.1 The Direct Method

-      2.5.2.2 The Indirect Method

-  2.6  8x8 Mono Pattern Fills

-  2.7  8x8 Color Pattern Fills

-  2.8  Image Writes

-    2.8.1 The Direct Method

-    2.8.2 The Indirect Method

-  2.9 Clipping

-3)  The Pixmap Cache

-4)  Offscreen Pixmaps

-

-/********************************************************************/

-

-0) WHAT IS XAA

-	

-   XAA (the XFree86 Acceleration Architecture) is a device dependent

-layer that encapsulates the unaccelerated framebuffer rendering layer,

-intercepting rendering commands sent to it from higher levels of the

-server.  For rendering tasks where hardware acceleration is not 

-possible, XAA allows the requests to proceed to the software rendering

-code.  Otherwise, XAA breaks the sometimes complicated X primitives

-into simpler primitives more suitable for hardware acceleration and

-will use accelerated functions exported by the chipset driver to 

-render these.

-

-   XAA provides a simple, easy to use driver interface that allows

-the driver to communicate its acceleration capabilities and restrictions

-back to XAA.  XAA will use the information provided by the driver

-to determine whether or not acceleration will be possible for a

-particular X primitive.

-

-

-

-1) XAA INITIALIZATION AND SHUTDOWN

-

-   All relevant prototypes and defines are in xaa.h.

-

-   To Initialize the XAA layer, the driver should allocate an XAAInfoRec

-via XAACreateInfoRec(), fill it out as described in this document

-and pass it to XAAInit().  XAAInit() must be called _after_ the 

-framebuffer initialization (usually cfb?ScreenInit or similar) since 

-it is "wrapping" that layer.  XAAInit() should be called _before_ the 

-cursor initialization (usually miDCInitialize) since the cursor

-layer needs to "wrap" all the rendering code including XAA.

-

-   When shutting down, the driver should free the XAAInfoRec

-structure in its CloseScreen function via XAADestroyInfoRec().

-The prototypes for the functions mentioned above are as follows:

-

-   XAAInfoRecPtr XAACreateInfoRec(void);

-   Bool XAAInit(ScreenPtr, XAAInfoRecPtr);

-   void XAADestroyInfoRec(XAAInfoRec);

-

-   The driver informs XAA of it's acceleration capablities by

-filling out an XAAInfoRec structure and passing it to XAAInit().

-The XAAInfoRec structure contains many fields, most of which are

-function pointers and flags.  Each primitive will typically have

-two functions and a set of flags associated with it, but it may

-have more.  These two functions are the "SetupFor" and "Subsequent" 

-functions.  The "SetupFor" function tells the driver that the 

-hardware should be initialized for a particular type of graphics 

-operation.  After the "SetupFor" function, one or more calls to the 

-"Subsequent" function will be made to indicate that an instance

-of the particular primitive should be rendered by the hardware.

-The details of each instance (width, height, etc...) are given

-with each "Subsequent" function.   The set of flags associated

-with each primitive lets the driver tell XAA what its hardware

-limitations are (eg. It doesn't support a planemask, it can only

-do one of the raster-ops, etc...).

-

-  Of the XAAInfoRec fields, one is required.  This is the

-Sync function.  XAA initialization will fail if this function

-is not provided.

-

-void Sync(ScrnInfoPtr pScrn)			/* Required */

-

-   Sync will be called when XAA needs to be certain that all

-   graphics coprocessor operations are finished, such as when

-   the framebuffer must be written to or read from directly

-   and it must be certain that the accelerator will not be

-   overwriting the area of interest.

-

-   One needs to make certain that the Sync function not only

-   waits for the accelerator fifo to empty, but that it waits for

-   the rendering of that last operation to complete.

-

-   It is guaranteed that no direct framebuffer access will

-   occur after a "SetupFor" or "Subsequent" function without

-   the Sync function being called first.

-

-

-

-2)  THE PRIMITIVES

-

-2.0  Generic Flags

-

-  Each primitive type has a set of flags associated with it which

-allow the driver to tell XAA what the hardware limitations are.

-The common ones are as follows:

-

-/* Foreground, Background, rop and planemask restrictions */

-

-   GXCOPY_ONLY

-

-     This indicates that the accelerator only supports GXcopy

-     for the particular primitive.

-

-   ROP_NEEDS_SOURCE

-

-     This indicates that the accelerator doesn't supports a

-     particular primitive with rops that don't involve the source.

-     These rops are GXclear, GXnoop, GXinvert and GXset. If neither

-     this flag nor GXCOPY_ONLY is defined, it is assumed that the

-     accelerator supports all 16 raster operations (rops) for that

-     primitive.

-

-   NO_PLANEMASK

-

-     This indicates that the accelerator does not support a hardware

-     write planemask for the particular primitive.

-

-   RGB_EQUAL

-

-     This indicates that the particular primitive requires the red, 

-     green and blue bytes of the foreground color (and background color,

-     if applicable) to be equal. This is useful for 24bpp when a graphics

-     coprocessor is used in 8bpp mode, which is not uncommon in older

-     hardware since some have no support for or only limited support for 

-     acceleration at 24bpp. This way, many operations will be accelerated 

-     for the common case of "grayscale" colors.  This flag should only

-     be used in 24bpp.

-

-  In addition to the common ones listed above which are possible for

-nearly all primitives, each primitive may have its own flags specific

-to that primitive.  If such flags exist they are documented in the

-descriptions of those primitives below.

- 

-

-

-

-2.1  Screen to Screen Copies

-

-   The SetupFor and Subsequent ScreenToScreenCopy functions provide

-   an interface for copying rectangular areas from video memory to

-   video memory.  To accelerate this primitive the driver should

-   provide both the SetupFor and Subsequent functions and indicate

-   the hardware restrictions via the ScreenToScreenCopyFlags.  The

-   NO_PLANEMASK, GXCOPY_ONLY and ROP_NEEDS_SOURCE flags as described

-   in Section 2.0 are valid as well as the following:

-

-    NO_TRANSPARENCY

-     

-      This indicates that the accelerator does not support skipping

-      of color keyed pixels when copying from the source to the destination.

-

-    TRANSPARENCY_GXCOPY_ONLY

-

-      This indicates that the accelerator supports skipping of color keyed

-      pixels only when the rop is GXcopy.

-

-    ONLY_LEFT_TO_RIGHT_BITBLT

-

-      This indicates that the hardware only accepts blitting when the

-      x direction is positive.

-

-    ONLY_TWO_BITBLT_DIRECTIONS

-

-      This indicates that the hardware can only cope with blitting when

-      the direction of x is the same as the direction in y.

-

-

-void SetupForScreenToScreenCopy( ScrnInfoPtr pScrn,

-			int xdir, int ydir,

-			int rop,

-			unsigned int planemask,

-			int trans_color )

-

-    When this is called, SubsequentScreenToScreenCopy will be called

-    one or more times directly after.  If ydir is 1, then the accelerator

-    should copy starting from the top (minimum y) of the source and

-    proceed downward.  If ydir is -1, then the accelerator should copy

-    starting from the bottom of the source (maximum y) and proceed

-    upward.  If xdir is 1, then the accelerator should copy each

-    y scanline starting from the leftmost pixel of the source.  If

-    xdir is -1, it should start from the rightmost pixel.  

-       If trans_color is not -1 then trans_color indicates that the

-    accelerator should not copy pixels with the color trans_color

-    from the source to the destination, but should skip them. 

-    Trans_color is always -1 if the NO_TRANSPARENCY flag is set.

- 

-

-void SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,

-			int x1, int y1,

-			int x2, int y2,

-			int width, int height)

-

-    Copy a rectangle "width" x "height" from the source (x1,y1) to the 

-    destination (x2,y2) using the parameters passed by the last

-    SetupForScreenToScreenCopy call. (x1,y1) and (x2,y2) always denote 

-    the upper left hand corners of the source and destination regardless 

-    of which xdir and ydir values are given by SetupForScreenToScreenCopy.  

-

-

-

-2.2 Solid Fills

-

-   The SetupFor and Subsequent SolidFill(Rect/Trap) functions provide

-   an interface for filling rectangular areas of the screen with a

-   foreground color.  To accelerate this primitive the driver should

-   provide both the SetupForSolidFill and SubsequentSolidFillRect 

-   functions and indicate the hardware restrictions via the SolidFillFlags.

-   The driver may optionally provide a SubsequentSolidFillTrap if

-   it is capable of rendering the primitive correctly.  

-   The GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags

-   as described in Section 2.0 are valid.

-

-  

-void SetupForSolidFill(ScrnInfoPtr pScrn, 

-                       int color, int rop, unsigned int planemask)

-

-    SetupForSolidFill indicates that any combination of the following 

-    may follow it.

-

-	SubsequentSolidFillRect

-	SubsequentSolidFillTrap

-

-

- 

-void SubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h)

-

-     Fill a rectangle of dimensions "w" by "h" with origin at (x,y) 

-     using the color, rop and planemask given by the last 

-     SetupForSolidFill call.

-

-void SubsequentSolidFillTrap(ScrnInfoPtr pScrn, int y, int h, 

-	int left, int dxL, int dyL, int eL,

-	int right, int dxR, int dyR, int eR)

-

-     These parameters describe a trapezoid via a version of

-     Bresenham's parameters. "y" is the top line. "h" is the

-     number of spans to be filled in the positive Y direction.

-     "left" and "right" indicate the starting X values of the

-     left and right edges.  dy/dx describes the edge slope.

-     These are not the deltas between the beginning and ending

-     points on an edge.  They merely describe the slope. "e" is

-     the initial error term.  It's the relationships between dx,

-     dy and e that define the edge.

-	If your engine does not do bresenham trapezoids or does

-     not allow the programmer to specify the error term then

-     you are not expected to be able to accelerate them.

-

-

-2.3  Solid Lines

-

-    XAA provides an interface for drawing thin lines.  In order to

-    draw X lines correctly a high degree of accuracy is required.

-    This usually limits line acceleration to hardware which has a

-    Bresenham line engine, though depending on the algorithm used,

-    other line engines may come close if they accept 16 bit line 

-    deltas.  XAA has both a Bresenham line interface and a two-point

-    line interface for drawing lines of arbitrary orientation.  

-    Additionally there is a SubsequentSolidHorVertLine which will

-    be used for all horizontal and vertical lines.  Horizontal and

-    vertical lines are handled separately since hardware that doesn't

-    have a line engine (or has one that is unusable due to precision

-    problems) can usually draw these lines by some other method such

-    as drawing them as thin rectangles.  Even for hardware that can

-    draw arbitrary lines via the Bresenham or two-point interfaces,

-    the SubsequentSolidHorVertLine is used for horizontal and vertical

-    lines since most hardware is able to render the horizontal lines

-    and sometimes the vertical lines faster by other methods (Hint:

-    try rendering horizontal lines as flattened rectangles).  If you have 

-    not provided a SubsequentSolidHorVertLine but you have provided 

-    Bresenham or two-point lines, a SubsequentSolidHorVertLine function 

-    will be supplied for you.

-

-    The flags field associated with Solid Lines is SolidLineFlags and 

-    the GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags as

-    described in Section 2.0 are valid restrictions.  

-

-    Some line engines have line biases hardcoded to comply with

-    Microsoft line biasing rules.  A tell-tale sign of this is the

-    hardware lines not matching the software lines in the zeroth and

-    fourth octants.  The driver can set the flag:

-	

-	MICROSOFT_ZERO_LINE_BIAS

-

-    in the AccelInfoRec.Flags field to adjust the software lines to

-    match the hardware lines.   This is in the generic flags field

-    rather than the SolidLineFlags since this flag applies to all

-    software zero-width lines on the screen and not just the solid ones.

-

-

-void SetupForSolidLine(ScrnInfoPtr pScrn, 

-                       int color, int rop, unsigned int planemask)

-

-    SetupForSolidLine indicates that any combination of the following 

-    may follow it.

-

-	SubsequentSolidBresenhamLine

-	SubsequentSolidTwoPointLine

-        SubsequentSolidHorVertLine 	

-

-

-void SubsequentSolidHorVertLine( ScrnInfoPtr pScrn,

-        			int x, int y, int len, int dir )

-

-    All vertical and horizontal solid thin lines are rendered with

-    this function.  The line starts at coordinate (x,y) and extends

-    "len" pixels inclusive.  In the direction indicated by "dir."

-    The direction is either DEGREES_O or DEGREES_270.  That is, it

-    always extends to the right or down.

-

-

-

-void SubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,

-        	int x1, int y1, int x2, int y2, int flags)

-

-    Draw a line from (x1,y1) to (x2,y2).  If the flags field contains

-    the flag OMIT_LAST, the last pixel should not be drawn.  Otherwise,

-    the pixel at (x2,y2) should be drawn.

-

-    If you use the TwoPoint line interface there is a good possibility

-    that your line engine has hard-coded line biases that do not match

-    the default X zero-width lines.  If so, you may need to set the

-    MICROSOFT_ZERO_LINE_BIAS flag described above.  Note that since

-    any vertex in the 16-bit signed coordinate system is valid, your

-    line engine is expected to handle 16-bit values if you have hardware

-    line clipping enabled.  If your engine cannot handle 16-bit values,

-    you should not use hardware line clipping.

-

-

-void SubsequentSolidBresenhamLine(ScrnInfoPtr pScrn,

-        int x, int y, int major, int minor, int err, int len, int octant)

-

-    "X" and "y" are the starting point of the line.  "Major" and "minor" 

-    are the major and minor step constants.  "Err" is the initial error

-    term.  "Len" is the number of pixels to be drawn (inclusive). "Octant"

-    can be any combination of the following flags OR'd together:

-

-      Y_MAJOR		Y is the major axis (X otherwise)

-      X_DECREASING	The line is drawn from right to left

-      Y_DECREASING	The line is drawn from bottom to top

-	  

-    The major, minor and err terms are the "raw" Bresenham parameters

-    consistent with a line engine that does:

-

-	e = err;

-	while(len--) {

-	   DRAW_POINT(x,y);

-	   e += minor;

-	   if(e >= 0) {

-		e -= major;

-		TAKE_ONE_STEP_ALONG_MINOR_AXIS;

-	   }

-	   TAKE_ONE_STEP_ALONG_MAJOR_AXIS;

-	}

-

-    IBM 8514 style Bresenham line interfaces require their parameters

-    modified in the following way:

-

-	Axial = minor;

-	Diagonal = minor - major;

-	Error = minor + err;

-

-SolidBresenhamLineErrorTermBits

-

-    This field allows the driver to tell XAA how many bits large its

-    Bresenham parameter registers are.  Many engines have registers that

-    only accept 12 or 13 bit Bresenham parameters, and the parameters

-    for clipped lines may overflow these if they are not scaled down.

-    If this field is not set, XAA will assume the engine can accomodate

-    16 bit parameters, otherwise, it will scale the parameters to the

-    size specified.

-

-

-2.4  Dashed Lines

-

-    The same degree of accuracy required by the solid lines is required

-    for drawing dashed lines as well.  The dash pattern itself is a

-    buffer of binary data where ones are expanded into the foreground

-    color and zeros either correspond to the background color or

-    indicate transparency depending on whether or not DoubleDash or

-    OnOffDashes are being drawn.  

-

-    The flags field associated with dashed Lines is DashedLineFlags and 

-    the GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags as

-    described in Section 2.0 are valid restrictions.  Additionally, the

-    following flags are valid:

-

-      NO_TRANSPARENCY

-

-	This indicates that the driver cannot support dashed lines

-	with transparent backgrounds (OnOffDashes).

-

-      TRANSPARENCY_ONLY

-

-	This indicates that the driver cannot support dashes with

-	both a foreground and background color (DoubleDashes).

-

-      LINE_PATTERN_POWER_OF_2_ONLY

-

-	This indicates that only patterns with a power of 2 length

-	can be accelerated.

-

-      LINE_PATTERN_LSBFIRST_MSBJUSTIFIED

-      LINE_PATTERN_LSBFIRST_LSBJUSTIFIED

-      LINE_PATTERN_MSBFIRST_MSBJUSTIFIED

-      LINE_PATTERN_MSBFIRST_LSBJUSTIFIED

-

-	These describe how the line pattern should be packed.

-	The pattern buffer is DWORD padded.  LSBFIRST indicates

-	that the pattern runs from the LSB end to the MSB end.

-	MSBFIRST indicates that the pattern runs from the MSB end

-	to the LSB end.  When the pattern does not completely fill

-	the DWORD padded buffer, the pattern will be justified 

-	towards the MSB or LSB end based on the flags above.

-

-

-    The following field indicates the maximum length dash pattern that

-    should be accelerated.

-

-	int DashPatternMaxLength

-

-

-void SetupForDashedLine(ScrnInfoPtr pScrn,

-		int fg, int bg, int rop, unsigned int planemask,

-        	int length, unsigned char *pattern)

-

-    

-    SetupForDashedLine indicates that any combination of the following 

-    may follow it.

-

-	SubsequentDashedBresenhamLine

-	SubsequentDashedTwoPointLine

-

-    If "bg" is -1, then the background (pixels corresponding to clear

-    bits in the pattern) should remain unmodified. "Bg" indicates the

-    background color otherwise.  "Length" indicates the length of

-    the pattern in bits and "pattern" points to the DWORD padded buffer

-    holding the pattern which has been packed according to the flags

-    set above.  

-

-    

-void SubsequentDashedTwoPointLine( ScrnInfoPtr pScrn,

-        int x1, int y1, int x2, int y2, int flags, int phase)

-

-void SubsequentDashedBresenhamLine(ScrnInfoPtr pScrn,

-        int x1, int y1, int major, int minor, int err, int len, int octant,

-        int phase)

-  

-    These are the same as the SubsequentSolidTwoPointLine and

-    SubsequentBresenhamLine functions except for the addition

-    of the "phase" field which indicates the offset into the dash 

-    pattern that the pixel at (x1,y1) corresponds to.

-

-    As with the SubsequentBresenhamLine, there is an

- 

-	int DashedBresenhamLineErrorTermBits 

-   

-    field which indicates the size of the error term registers

-    used with dashed lines.  This is usually the same value as

-    the field for the solid lines (because it's usually the same

-    register).

-       

-      

-

-2.5   Color Expansion Fills

-

-    When filling a color expansion rectangle, the accelerator

-    paints each pixel depending on whether or not a bit in a

-    corresponding bitmap is set or clear. Opaque expansions are 

-    when a set bit corresponds to the foreground color and a clear 

-    bit corresponds to the background color.  A transparent expansion

-    is when a set bit corresponds to the foreground color and a

-    clear bit indicates that the pixel should remain unmodified.

-   

-    The graphics accelerator usually has access to the source 

-    bitmap in one of two ways: 1) the bitmap data is sent serially

-    to the accelerator by the CPU through some memory mapped aperture

-    or 2) the accelerator reads the source bitmap out of offscreen

-    video memory.  Some types of primitives are better suited towards 

-    one method or the other.  Type 2 is useful for reusable patterns

-    such as stipples which can be cached in offscreen memory.  The

-    aperature method can be used for stippling but the CPU must pass

-    the data across the bus each time a stippled fill is to be performed.  

-    For expanding 1bpp client pixmaps or text strings to the screen,

-    the aperature method is usually superior because the intermediate

-    copy in offscreen memory needed by the second method would only be 

-    used once.  Unfortunately, many accelerators can only do one of these

-    methods and not both.  

-

-    XAA provides both ScreenToScreen and CPUToScreen color expansion 

-    interfaces for doing color expansion fills.  The ScreenToScreen

-    functions can only be used with hardware that supports reading

-    of source bitmaps from offscreen video memory, and these are only

-    used for cacheable patterns such as stipples.  There are two

-    variants of the CPUToScreen routines - a direct method intended

-    for hardware that has a transfer aperature, and an indirect method

-    intended for hardware without transfer aperatures or hardware

-    with unusual transfer requirements.  Hardware that can only expand

-    bitmaps from video memory should supply ScreenToScreen routines

-    but also ScanlineCPUToScreen (indirect) routines to optimize transfers 

-    of non-cacheable data.  Hardware that can only accept source bitmaps

-    through an aperature should supply CPUToScreen (or ScanlineCPUToScreen) 

-    routines. Hardware that can do both should provide both ScreenToScreen 

-    and CPUToScreen routines.

-

-    For both ScreenToScreen and CPUToScreen interfaces, the GXCOPY_ONLY,

-    ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags described in

-    Section 2.0 are valid as well as the following:

-

-    /* bit order requirements (one of these must be set) */

-   

-    BIT_ORDER_IN_BYTE_LSBFIRST

-

-      This indicates that least significant bit in each byte of the source

-      data corresponds to the leftmost of that block of 8 pixels.  This

-      is the prefered format.

-

-    BIT_ORDER_IN_BYTE_MSBFIRST    

-

-      This indicates that most significant bit in each byte of the source

-      data corresponds to the leftmost of that block of 8 pixels.

-

-    /* transparency restrictions */

-

-    NO_TRANSPARENCY

-

-      This indicates that the accelerator cannot do a transparent expansion.

-

-    TRANSPARENCY_ONLY

-

-      This indicates that the accelerator cannot do an opaque expansion.

-      In cases where where the background needs to be filled, XAA will

-      render the primitive in two passes when using the CPUToScreen

-      interface, but will not do so with the ScreenToScreen interface 

-      since that would require caching of two patterns.  Some 

-      ScreenToScreen hardware may be able to render two passes at the

-      driver level and remove the TRANSPARENCY_ONLY restriction if

-      it can render pixels corresponding to the zero bits.

-

-

-

-2.5.1  Screen To Screen Color Expansion

-

-    The ScreenToScreenColorExpandFill routines provide an interface

-    for doing expansion blits from source patterns stored in offscreen

-    video memory.

-

-    void SetupForScreenToScreenColorExpandFill (ScrnInfoPtr pScrn,

-        			int fg, int bg, 

-				int rop, unsigned int planemask)

-

-

-    Ones in the source bitmap will correspond to the fg color.

-    Zeros in the source bitmap will correspond to the bg color

-    unless bg = -1.  In that case the pixels corresponding to the

-    zeros in the bitmap shall be left unmodified by the accelerator.

-

-    For hardware that doesn't allow an easy implementation of skipleft, the

-    driver can replace CacheMonoStipple function with one that stores multiple

-    rotated copies of the stipple and select between them. In this case the

-    driver should set CacheColorExpandDensity to tell XAA how many copies of

-    the pattern are stored in the width of a cache slot. For instance if the

-    hardware can specify the starting address in bytes, then 8 rotated copies

-    of the stipple are needed and CacheColorExpandDensity should be set to 8.

-

-    void SubsequentScreenToScreenColorExpandFill( ScrnInfoPtr pScrn,

-				int x, int y, int w, int h,

-				int srcx, int srcy, int offset )

-

-   

-    Fill a rectangle "w" x "h" at location (x,y).  The source pitch

-    between scanlines is the framebuffer pitch (pScrn->displayWidth

-    pixels) and srcx and srcy indicate the start of the source pattern 

-    in units of framebuffer pixels. "Offset" indicates the bit offset

-    into the pattern that corresponds to the pixel being painted at

-    "x" on the screen.  Some hardware accepts source coordinates in

-    units of bits which makes implementation of the offset trivial.

-    In that case, the bit address of the source bit corresponding to

-    the pixel painted at (x,y) would be:

-	

-     (srcy * pScrn->displayWidth + srcx) * pScrn->bitsPerPixel + offset

-

-    It should be noted that the offset assumes LSBFIRST hardware.  

-    For MSBFIRST hardware, the driver may need to implement the 

-    offset by bliting only from byte boundaries and hardware clipping.

-

-

-

-2.5.2  CPU To Screen Color Expansion

-

-

-    The CPUToScreenColorExpandFill routines provide an interface for 

-    doing expansion blits from source patterns stored in system memory.

-    There are two varieties of this primitive, a CPUToScreenColorExpandFill

-    and a ScanlineCPUToScreenColorExpandFill.  With the 

-    CPUToScreenColorExpandFill method, the source data is sent serially

-    through a memory mapped aperature.  With the Scanline version, the

-    data is rendered scanline at a time into intermediate buffers with

-    a call to SubsequentColorExpandScanline following each scanline.

-

-    These two methods have separate flags fields, the

-    CPUToScreenColorExpandFillFlags and ScanlineCPUToScreenColorExpandFillFlags

-    respectively.  Flags specific to one method or the other are described 

-    in sections 2.5.2.1 and 2.5.2.2 but for both cases the bit order and

-    transparency restrictions listed at the beginning of section 2.5 are 

-    valid as well as the following:

-    

-    /* clipping  (optional) */

-    

-    LEFT_EDGE_CLIPPING

- 

-      This indicates that the accelerator supports omission of up to

-      31 pixels on the left edge of the rectangle to be filled.  This

-      is beneficial since it allows transfer of the source bitmap to

-      always occur from DWORD boundaries. 

-

-    LEFT_EDGE_CLIPPING_NEGATIVE_X

-

-      This flag indicates that the accelerator can render color expansion

-      rectangles even if the value of x origin is negative (off of

-      the screen on the left edge).

-

-    /* misc */

-

-    TRIPLE_BITS_24BPP

-

-      When enabled (must be in 24bpp mode), color expansion functions

-      are expected to require three times the amount of bits to be

-      transferred so that 24bpp grayscale colors can be used with color

-      expansion in 8bpp coprocessor mode. Each bit is expanded to 3

-      bits when writing the monochrome data.

-

-

- 2.5.1 The Direct Method 

-

-

-    Using the direct method of color expansion XAA will send all

-    bitmap data to the accelerator serially through an memory mapped

-    transfer window defined by the following two fields:

-

-      unsigned char *ColorExpandBase

-

-        This indicates the memory address of the beginning of the aperture.

-

-      int ColorExpandRange

-

-        This indicates the size in bytes of the aperture.

-

-    The driver should specify how the transfered data should be padded.

-    There are options for both the padding of each Y scanline and for the

-    total transfer to the aperature.

-    One of the following two flags must be set:

-

-      CPU_TRANSFER_PAD_DWORD

-

-        This indicates that the total transfer (sum of all scanlines) sent

-        to the aperature must be DWORD padded.  This is the default behavior.

-

-      CPU_TRANSFER_PAD_QWORD 

-

-	This indicates that the total transfer (sum of all scanlines) sent

-	to the aperature must be QWORD padded.  With this set, XAA will send

-        an extra DWORD to the aperature when needed to ensure that only

-        an even number of DWORDs are sent.

-

-    And then there are the flags for padding of each scanline:

-

-      SCANLINE_PAD_DWORD

-

-	This indicates that each Y scanline should be DWORD padded.

-        This is the only option available and is the default.

-

-    Finally, there is the CPU_TRANSFER_BASE_FIXED flag which indicates

-    that the aperture is a single register rather than a range of

-    registers, and XAA should write all of the data to the first DWORD.

-    If the ColorExpandRange is not large enough to accomodate scanlines

-    the width of the screen, this option will be forced. That is, the

-    ColorExpandRange must be:

-

-        ((virtualX + 31)/32) * 4   bytes or more.

-

-        ((virtualX + 62)/32 * 4) if LEFT_EDGE_CLIPPING_NEGATIVE_X is set.

-  

-    If the TRIPLE_BITS_24BPP flag is set, the required area should be 

-    multiplied by three.

-     

-    

-void SetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,

-        		int fg, int bg,

-			int rop,

-			unsigned int planemask)

-

-  

- 

-     Ones in the source bitmap will correspond to the fg color.

-     Zeros in the source bitmap will correspond to the bg color

-     unless bg = -1.  In that case the pixels corresponding to the

-     zeros in the bitmap shall be left unmodified by the accelerator.

-

-

-void SubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,

-			int x, int y, int w, int h,

-			int skipleft )

-

-     When this function is called, the accelerator should be setup

-     to fill a rectangle of dimension "w" by "h" with origin at (x,y)

-     in the fill style prescribed by the last call to 

-     SetupForCPUToScreenColorExpandFill.  XAA will pass the data to 

-     the aperture immediately after this function is called.  If the 

-     skipleft is non-zero (and LEFT_EDGE_CLIPPING has been enabled), then 

-     the accelerator _should_not_ render skipleft pixels on the leftmost

-     edge of the rectangle.  Some engines have an alignment feature

-     like this built in, some others can do this using a clipping

-     window.

-

-     It can be arranged for XAA to call Sync() after it is through 

-     calling the Subsequent function by setting SYNC_AFTER_COLOR_EXPAND 

-     in the  CPUToScreenColorExpandFillFlags.  This can provide the driver 

-     with an oportunity to reset a clipping window if needed.

-

-    

-2.5.2  The Indirect Method 

-

-     Using the indirect method, XAA will render the bitmap data scanline

-     at a time to one or more buffers.  These buffers may be memory

-     mapped apertures or just intermediate storage.

-

-     int NumScanlineColorExpandBuffers

-

-       This indicates the number of buffers available.

-

-     unsigned char **ScanlineColorExpandBuffers

-

-       This is an array of pointers to the memory locations of each buffer.

-       Each buffer is expected to be large enough to accommodate scanlines

-       the width of the screen.  That is:

-

-        ((virtualX + 31)/32) * 4   bytes or more.

-

-        ((virtualX + 62)/32 * 4) if LEFT_EDGE_CLIPPING_NEGATIVE_X is set.

-  

-     Scanlines are always DWORD padded.

-     If the TRIPLE_BITS_24BPP flag is set, the required area should be 

-     multiplied by three.

-

-

-void SetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,

-        		int fg, int bg,

-			int rop,

-			unsigned int planemask)

- 

-     Ones in the source bitmap will correspond to the fg color.

-     Zeros in the source bitmap will correspond to the bg color

-     unless bg = -1.  In that case the pixels corresponding to the

-     zeros in the bitmap shall be left unmodified by the accelerator.

-

-     

-void SubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,

-			int x, int y, int w, int h,

-			int skipleft )

-

-void SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)

-

-

-    When SubsequentScanlineCPUToScreenColorExpandFill is called, XAA 

-    will begin transfering the source data scanline at a time, calling  

-    SubsequentColorExpandScanline after each scanline.  If more than

-    one buffer is available, XAA will cycle through the buffers.

-    Subsequent scanlines will use the next buffer and go back to the

-    buffer 0 again when the last buffer is reached.  The index into

-    the ScanlineColorExpandBuffers array is presented as "bufno"

-    with each SubsequentColorExpandScanline call.

-

-    The skipleft field is the same as for the direct method.

-

-    The indirect method can be use to send the source data directly 

-    to a memory mapped aperture represented by a single color expand

-    buffer, scanline at a time, but more commonly it is used to place 

-    the data into offscreen video memory so that the accelerator can 

-    blit it to the visible screen from there.  In the case where the

-    accelerator permits rendering into offscreen video memory while

-    the accelerator is active, several buffers can be used so that

-    XAA can be placing source data into the next buffer while the

-    accelerator is blitting the current buffer.  For cases where

-    the accelerator requires some special manipulation of the source

-    data first, the buffers can be in system memory.  The CPU can

-    manipulate these buffers and then send the data to the accelerator.

-

-

-

-2.6   8x8 Mono Pattern Fills

-

-    XAA provides support for two types of 8x8 hardware patterns -

-    "Mono" patterns and "Color" patterns.  Mono pattern data is

-    64 bits of color expansion data with ones indicating the

-    foreground color and zeros indicating the background color.

-    The source bitmaps for the 8x8 mono patterns can be presented

-    to the graphics accelerator in one of two ways.  They can be

-    passed as two DWORDS to the 8x8 mono pattern functions or

-    they can be cached in offscreen memory and their locations

-    passed to the 8x8 mono pattern functions.  In addition to the

-    GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags

-    defined in Section 2.0, the following are defined for the

-    Mono8x8PatternFillFlags:

-

-    HARDWARE_PATTERN_PROGRAMMED_BITS

-

-      This indicates that the 8x8 patterns should be packed into two

-      DWORDS and passed to the 8x8 mono pattern functions.  The default

-      behavior is to cache the patterns in offscreen video memory and

-      pass the locations of these patterns to the functions instead.

-      The pixmap cache must be enabled for the default behavior (8x8 

-      pattern caching) to work.  See Section 3 for how to enable the

-      pixmap cache. The pixmap cache is not necessary for 

-      HARDWARE_PATTERN_PROGRAMMED_BITS.

-

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN

-

-      If the hardware supports programmable pattern offsets then

-      this option should be set. See the table below for further

-      infomation.

-

-    HARDWARE_PATTERN_SCREEN_ORIGIN

-

-      Some hardware wants the pattern offset specified with respect to the

-      upper left-hand corner of the primitive being drawn.  Other hardware 

-      needs the option HARDWARE_PATTERN_SCREEN_ORIGIN set to indicate that 

-      all pattern offsets should be referenced to the upper left-hand 

-      corner of the screen.  HARDWARE_PATTERN_SCREEN_ORIGIN is preferable 

-      since this is more natural for the X-Window system and offsets will 

-      have to be recalculated for each Subsequent function otherwise.

-

-    BIT_ORDER_IN_BYTE_MSBFIRST

-    BIT_ORDER_IN_BYTE_LSBFIRST

-

-      As with other color expansion routines this indicates whether the

-      most or the least significant bit in each byte from the pattern is 

-      the leftmost on the screen.

-

-    TRANSPARENCY_ONLY

-    NO_TRANSPARENCY

-

-      This means the same thing as for the color expansion rect routines

-      except that for TRANSPARENCY_ONLY XAA will not render the primitive

-      in two passes since this is more easily handled by the driver.

-      It is recommended that TRANSPARENCY_ONLY hardware handle rendering

-      of opaque patterns in two passes (the background can be filled as

-      a rectangle in GXcopy) in the Subsequent function so that the

-      TRANSPARENCY_ONLY restriction can be removed. 

-

-

-

-    Additional information about cached patterns...

-    For the case where HARDWARE_PATTERN_PROGRAMMED_BITS is not set and 

-    the pattern must be cached in offscreen memory, the first pattern

-    starts at the cache slot boundary which is set by the 

-    CachePixelGranularity field used to configure the pixmap cache.

-    One should ensure that the CachePixelGranularity reflects any 

-    alignment restrictions that the accelerator may put on 8x8 pattern 

-    storage locations.  When HARDWARE_PATTERN_PROGRAMMED_ORIGIN is set 

-    there is only one pattern stored.  When this flag is not set,

-    all 64 pre-rotated copies of the pattern are cached in offscreen memory.

-    The MonoPatternPitch field can be used to specify the X position pixel

-    granularity that each of these patterns must align on.  If the

-    MonoPatternPitch is not supplied, the patterns will be densely packed

-    within the cache slot.  The behavior of the default XAA 8x8 pattern

-    caching mechanism to store all 8x8 patterns linearly in video memory.

-    If the accelerator needs the patterns stored in a more unusual fashion,

-    the driver will need to provide its own 8x8 mono pattern caching 

-    routines for XAA to use. 

-

-    The following table describes the meanings of the "patx" and "paty"

-    fields in both the SetupFor and Subsequent functions.

-

-    With HARDWARE_PATTERN_SCREEN_ORIGIN

-    -----------------------------------

-

-    HARDWARE_PATTERN_PROGRAMMED_BITS and HARDWARE_PATTERN_PROGRAMMED_ORIGIN

-

-	SetupFor: patx and paty are the first and second DWORDS of the

-		  8x8 mono pattern.

-

-	Subsequent: patx and paty are the x,y offset into that pattern.

-		    All Subsequent calls will have the same offset in 

-		    the case of HARDWARE_PATTERN_SCREEN_ORIGIN so only

-		    the offset specified by the first Subsequent call 

-		    after a SetupFor call will need to be observed.

-

-    HARDWARE_PATTERN_PROGRAMMED_BITS only

-

-	SetupFor: patx and paty hold the first and second DWORDS of

-		  the 8x8 mono pattern pre-rotated to match the desired

-		  offset.

-

-	Subsequent: These just hold the same patterns and can be ignored.

-

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN only

-

-	SetupFor: patx and paty hold the x,y coordinates of the offscreen

-		  memory location where the 8x8 pattern is stored.  The

-		  bits are stored linearly in memory at that location.

-

-	Subsequent: patx and paty hold the offset into the pattern.

-		    All Subsequent calls will have the same offset in 

-		    the case of HARDWARE_PATTERN_SCREEN_ORIGIN so only

-		    the offset specified by the first Subsequent call 

-		    after a SetupFor call will need to be observed.

-

-    Neither programmed bits or origin

-

-	SetupFor: patx and paty hold the x,y coordinates of the offscreen 	

-		  memory location where the pre-rotated 8x8 pattern is

-		  stored.

-

-	Subsequent: patx and paty are the same as in the SetupFor function

-		    and can be ignored.

-		  

-

-    Without HARDWARE_PATTERN_SCREEN_ORIGIN

-    -------------------------------------- 

-

-    HARDWARE_PATTERN_PROGRAMMED_BITS and HARDWARE_PATTERN_PROGRAMMED_ORIGIN

-

-	SetupFor: patx and paty are the first and second DWORDS of the

-		  8x8 mono pattern.

-

-	Subsequent: patx and paty are the x,y offset into that pattern.

-

-    HARDWARE_PATTERN_PROGRAMMED_BITS only

-

-	SetupFor: patx and paty holds the first and second DWORDS of

-		  the unrotated 8x8 mono pattern.  This can be ignored. 

-

-	Subsequent: patx and paty hold the rotated 8x8 pattern to be 

-		    rendered.

-

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN only

-

-	SetupFor: patx and paty hold the x,y coordinates of the offscreen

-		  memory location where the 8x8 pattern is stored.  The

-		  bits are stored linearly in memory at that location.

-

-	Subsequent: patx and paty hold the offset into the pattern.

-

-    Neither programmed bits or origin

-

-	SetupFor: patx and paty hold the x,y coordinates of the offscreen 	

-		  memory location where the unrotated 8x8 pattern is

-		  stored.  This can be ignored.

-

-	Subsequent: patx and paty hold the x,y coordinates of the

-		    rotated 8x8 pattern to be rendered.

-

-

-

-void SetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,

-        int fg, int bg, int rop, unsigned int planemask)

-

-    SetupForMono8x8PatternFill indicates that any combination of the 

-    following  may follow it.

-

-	SubsequentMono8x8PatternFillRect

-	SubsequentMono8x8PatternFillTrap

-

-    The fg, bg, rop and planemask fields have the same meaning as the

-    ones used for the other color expansion routines.  Patx's and paty's

-    meaning can be determined from the table above.

-

- 

-void SubsequentMono8x8PatternFillRect( ScrnInfoPtr pScrn,

-        	int patx, int paty, int x, int y, int w, int h)

-

-     Fill a rectangle of dimensions "w" by "h" with origin at (x,y) 

-     using the parameters give by the last SetupForMono8x8PatternFill

-     call.  The meanings of patx and paty can be determined by the

-     table above.

-

-void SubsequentMono8x8PatternFillTrap( ScrnInfoPtr pScrn,

-     			   int patx, int paty, int y, int h, 

-     			   int left, int dxL, int dyL, int eL,

-     			   int right, int dxR, int dyR, int eR )

-

-     The meanings of patx and paty can be determined by the table above.

-     The rest of the fields have the same meanings as those in the 

-     SubsequentSolidFillTrap function. 

-

-

-

-2.7   8x8 Color Pattern Fills

-  

-    8x8 color pattern data is 64 pixels of full color data that

-    is stored linearly in offscreen video memory.  8x8 color patterns 

-    are useful as a substitute for 8x8 mono patterns when tiling,

-    doing opaque stipples, or in the case where transperency is

-    supported, regular stipples.  8x8 color pattern fills also have

-    the additional benefit of being able to tile full color 8x8

-    patterns instead of just 2 color ones like the mono patterns.

-    However, full color 8x8 patterns aren't used very often in the

-    X Window system so you might consider passing this primitive

-    by if you already can do mono patterns, especially if they 

-    require alot of cache area.  Color8x8PatternFillFlags is

-    the flags field for this primitive and the GXCOPY_ONLY,

-    ROP_NEEDS_SOURCE and NO_PLANEMASK flags as described in

-    Section 2.0 are valid as well as the following:

-

-

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN

-

-      If the hardware supports programmable pattern offsets then

-      this option should be set.  

-

-    HARDWARE_PATTERN_SCREEN_ORIGIN

-

-      Some hardware wants the pattern offset specified with respect to the

-      upper left-hand corner of the primitive being drawn.  Other hardware 

-      needs the option HARDWARE_PATTERN_SCREEN_ORIGIN set to indicate that 

-      all pattern offsets should be referenced to the upper left-hand 

-      corner of the screen.  HARDWARE_PATTERN_SCREEN_ORIGIN is preferable 

-      since this is more natural for the X-Window system and offsets will 

-      have to be recalculated for each Subsequent function otherwise.

-

-    NO_TRANSPARENCY

-    TRANSPARENCY_GXCOPY_ONLY

-

-      These mean the same as for the ScreenToScreenCopy functions.

-

-

-    The following table describes the meanings of patx and paty passed

-    to the SetupFor and Subsequent fields:

-

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN && HARDWARE_PATTERN_SCREEN_ORIGIN

-	

-	SetupFor: patx and paty hold the x,y location of the unrotated 

-		  pattern.

-

-	Subsequent: patx and paty hold the pattern offset.  For the case

-		    of HARDWARE_PATTERN_SCREEN_ORIGIN all Subsequent calls

-		    have the same offset so only the first call will need

-		    to be observed.

-

-    

-    HARDWARE_PATTERN_PROGRAMMED_ORIGIN only

-

-	SetupFor: patx and paty hold the x,y location of the unrotated

-		  pattern.

-

-	Subsequent: patx and paty hold the pattern offset. 

-

-    HARDWARE_PATTERN_SCREEN_ORIGIN

-

-	SetupFor: patx and paty hold the x,y location of the rotated pattern.

-

-	Subsequent: patx and paty hold the same location as the SetupFor

-		    function so these can be ignored.

-

-    neither flag

-

-	SetupFor: patx and paty hold the x,y location of the unrotated

-		  pattern.  This can be ignored.

-

-	Subsequent: patx and paty hold the x,y location of the rotated

-		    pattern.

-

-    Additional information about cached patterns...

-    All 8x8 color patterns are cached in offscreen video memory so

-    the pixmap cache must be enabled to use them. The first pattern

-    starts at the cache slot boundary which is set by the 

-    CachePixelGranularity field used to configure the pixmap cache.

-    One should ensure that the CachePixelGranularity reflects any 

-    alignment restrictions that the accelerator may put on 8x8 pattern 

-    storage locations.  When HARDWARE_PATTERN_PROGRAMMED_ORIGIN is set 

-    there is only one pattern stored.  When this flag is not set,

-    all 64 rotations off the pattern are accessible but it is assumed

-    that the accelerator is capable of accessing data stored on 8

-    pixel boundaries.  If the accelerator has stricter alignment 

-    requirements than this the dirver will need to provide its own 

-    8x8 color pattern caching routines. 

-

-

-void SetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,

-        	int rop, unsigned int planemask, int trans_color)

-

-    SetupForColor8x8PatternFill indicates that any combination of the 

-    following  may follow it.

-

-	SubsequentColor8x8PatternFillRect

-	SubsequentColor8x8PatternFillTrap	(not implemented yet)

-

-    For the meanings of patx and paty, see the table above.  Trans_color

-    means the same as for the ScreenToScreenCopy functions.

-

-

- 

-void SubsequentColor8x8PatternFillRect( ScrnInfoPtr pScrn,

-        	int patx, int paty, int x, int y, int w, int h)

-

-     Fill a rectangle of dimensions "w" by "h" with origin at (x,y) 

-     using the parameters give by the last SetupForColor8x8PatternFill

-     call.  The meanings of patx and paty can be determined by the

-     table above.

-

-void SubsequentColor8x8PatternFillTrap( ScrnInfoPtr pScrn,

-     			   int patx, int paty, int y, int h, 

-     			   int left, int dxL, int dyL, int eL,

-     			   int right, int dxR, int dyR, int eR )

-

-    For the meanings of patx and paty, see the table above. 

-    The rest of the fields have the same meanings as those in the 

-    SubsequentSolidFillTrap function. 

-

-

-

-2.8  Image Writes

-

-    XAA provides a mechanism for transfering full color pixel data from

-    system memory to video memory through the accelerator.  This is 

-    useful for dealing with alignment issues and performing raster ops

-    on the data when writing it to the framebuffer.  As with color

-    expansion rectangles, there is a direct and indirect method.  The

-    direct method sends all data through a memory mapped aperature.

-    The indirect method sends the data to an intermediated buffer scanline 

-    at a time.

-

-    The direct and indirect methods have separate flags fields, the

-    ImageWriteFlags and ScanlineImageWriteFlags respectively.

-    Flags specific to one method or the other are described in sections 

-    2.8.1 and 2.8.2 but for both cases the GXCOPY_ONLY, ROP_NEEDS_SOURCE

-    and NO_PLANEMASK flags described in Section 2.0 are valid as well as

-    the following:

-

-    NO_GXCOPY

-

-      In order to have accelerated image transfers faster than the 

-      software versions for GXcopy, the engine needs to support clipping,

-      be using the direct method and have a large enough image transfer

-      range so that CPU_TRANSFER_BASE_FIXED doesn't need to be set.

-      If these are not supported, then it is unlikely that transfering

-      the data through the accelerator will be of any advantage for the

-      simple case of GXcopy.  In fact, it may be much slower.  For such

-      cases it's probably best to set the NO_GXCOPY flag so that 

-      Image writes will only be used for the more complicated rops.

-

-    /* transparency restrictions */

-

-    NO_TRANSPARENCY

-     

-      This indicates that the accelerator does not support skipping

-      of color keyed pixels when copying from the source to the destination.

-

-    TRANSPARENCY_GXCOPY_ONLY

-

-      This indicates that the accelerator supports skipping of color keyed

-      pixels only when the rop is GXcopy.

-

-    /* clipping  (optional) */

-    

-    LEFT_EDGE_CLIPPING

- 

-      This indicates that the accelerator supports omission of up to

-      3 pixels on the left edge of the rectangle to be filled.  This

-      is beneficial since it allows transfer from the source pixmap to

-      always occur from DWORD boundaries. 

-

-    LEFT_EDGE_CLIPPING_NEGATIVE_X

-

-      This flag indicates that the accelerator can fill areas with

-      image write data even if the value of x origin is negative (off of

-      the screen on the left edge).

-

-

-2.8.1 The Direct Method

-

-    Using the direct method of ImageWrite XAA will send all

-    bitmap data to the accelerator serially through an memory mapped

-    transfer window defined by the following two fields:

-

-      unsigned char *ImageWriteBase

-

-        This indicates the memory address of the beginning of the aperture.

-

-      int ImageWriteRange

-

-        This indicates the size in bytes of the aperture.

-

-    The driver should specify how the transfered data should be padded.

-    There are options for both the padding of each Y scanline and for the

-    total transfer to the aperature.

-    One of the following two flags must be set:

-

-      CPU_TRANSFER_PAD_DWORD

-

-        This indicates that the total transfer (sum of all scanlines) sent

-        to the aperature must be DWORD padded.  This is the default behavior.

-

-      CPU_TRANSFER_PAD_QWORD 

-

-	This indicates that the total transfer (sum of all scanlines) sent

-	to the aperature must be QWORD padded.  With this set, XAA will send

-        an extra DWORD to the aperature when needed to ensure that only

-        an even number of DWORDs are sent.

-

-    And then there are the flags for padding of each scanline:

-

-      SCANLINE_PAD_DWORD

-

-	This indicates that each Y scanline should be DWORD padded.

-        This is the only option available and is the default.

-

-    Finally, there is the CPU_TRANSFER_BASE_FIXED flag which indicates

-    that the aperture is a single register rather than a range of

-    registers, and XAA should write all of the data to the first DWORD.

-    XAA will automatically select CPU_TRANSFER_BASE_FIXED if the 

-    ImageWriteRange is not large enough to accomodate an entire scanline.   

-

-

-void SetupForImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,

-        			int trans_color, int bpp, int depth)

-

-     If trans_color is not -1 then trans_color indicates the transparency

-     color key and pixels with color trans_color passed through the 

-     aperature should not be transfered to the screen but should be 

-     skipped.  Bpp and depth indicate the bits per pixel and depth of

-     the source pixmap.  Trans_color is always -1 if the NO_TRANSPARENCY

-     flag is set.

-

-

-void SubsequentImageWriteRect(ScrnInfoPtr pScrn, 

-				int x, int y, int w, int h, int skipleft)

-

-     

-     Data passed through the aperature should be copied to a rectangle

-     of width "w" and height "h" with origin (x,y).  If LEFT_EDGE_CLIPPING

-     has been enabled, skipleft will correspond to the number of pixels

-     on the left edge that should not be drawn.  Skipleft is zero 

-     otherwise.

-

-     It can be arranged for XAA to call Sync() after it is through 

-     calling the Subsequent functions by setting SYNC_AFTER_IMAGE_WRITE 

-     in the  ImageWriteFlags.  This can provide the driver with an

-     oportunity to reset a clipping window if needed.

-

-2.8.2  The Indirect Method

-

-     Using the indirect method, XAA will render the pixel data scanline

-     at a time to one or more buffers.  These buffers may be memory

-     mapped apertures or just intermediate storage.

-

-     int NumScanlineImageWriteBuffers

-

-       This indicates the number of buffers available.

-

-     unsigned char **ScanlineImageWriteBuffers

-

-       This is an array of pointers to the memory locations of each buffer.

-       Each buffer is expected to be large enough to accommodate scanlines

-       the width of the screen.  That is:

-

-         pScrn->VirtualX * pScreen->bitsPerPixel/8   bytes or more.

-

-       If LEFT_EDGE_CLIPPING_NEGATIVE_X is set, add an additional 4

-       bytes to that requirement in 8 and 16bpp, 12 bytes in 24bpp.

-  

-     Scanlines are always DWORD padded.

-

-void SetupForScanlineImageWrite(ScrnInfoPtr pScrn, int rop, 

-				unsigned int planemask, int trans_color, 

-				int bpp, int depth)

-

-     If trans_color is not -1 then trans_color indicates the transparency

-     color key and pixels with color trans_color in the buffer should not 

-     be transfered to the screen but should be skipped.  Bpp and depth 

-     indicate the bits per pixel and depth of the source bitmap.  

-     Trans_color is always -1 if the NO_TRANSPARENCY flag is set.

-

-

-void SubsequentImageWriteRect(ScrnInfoPtr pScrn, 

-				int x, int y, int w, int h, int skipleft)

-

-     

-void SubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno)

-

-

-    When SubsequentImageWriteRect is called, XAA will begin

-    transfering the source data scanline at a time, calling  

-    SubsequentImageWriteScanline after each scanline.  If more than

-    one buffer is available, XAA will cycle through the buffers.

-    Subsequent scanlines will use the next buffer and go back to the

-    buffer 0 again when the last buffer is reached.  The index into

-    the ScanlineImageWriteBuffers array is presented as "bufno"

-    with each SubsequentImageWriteScanline call.

-

-    The skipleft field is the same as for the direct method.

-

-    The indirect method can be use to send the source data directly 

-    to a memory mapped aperture represented by a single image write

-    buffer, scanline at a time, but more commonly it is used to place 

-    the data into offscreen video memory so that the accelerator can 

-    blit it to the visible screen from there.  In the case where the

-    accelerator permits rendering into offscreen video memory while

-    the accelerator is active, several buffers can be used so that

-    XAA can be placing source data into the next buffer while the

-    accelerator is blitting the current buffer.  For cases where

-    the accelerator requires some special manipulation of the source

-    data first, the buffers can be in system memory.  The CPU can

-    manipulate these buffers and then send the data to the accelerator.

-

-

-2.9 Clipping

-

-    XAA supports hardware clipping rectangles.  To use clipping

-    in this way it is expected that the graphics accelerator can

-    clip primitives with verticies anywhere in the 16 bit signed 

-    coordinate system. 

-

-void SetClippingRectangle ( ScrnInfoPtr pScrn,

-        		int left, int top, int right, int bottom)

-

-void DisableClipping (ScrnInfoPtr pScrn)

-

-    When SetClippingRectangle is called, all hardware rendering

-    following it should be clipped to the rectangle specified

-    until DisableClipping is called.

-

-    The ClippingFlags field indicates which operations this sort

-    of Set/Disable pairing can be used with.  Any of the following

-    flags may be OR'd together.

-

-	HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND

-	HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY

-	HARDWARE_CLIP_MONO_8x8_FILL

-	HARDWARE_CLIP_COLOR_8x8_FILL

-	HARDWARE_CLIP_SOLID_FILL

-	HARDWARE_CLIP_DASHED_LINE

-	HARDWARE_CLIP_SOLID_LINE

-

-

-

-3)  XAA PIXMAP CACHE

-

-   /* NOTE:  XAA has no knowledge of framebuffer particulars so until

-	the framebuffer is able to render into offscreen memory, usage

-	of the pixmap cache requires that the driver provide ImageWrite

-	routines or a WritePixmap or WritePixmapToCache replacement so

-	that patterns can even be placed in the cache.

-

-      ADDENDUM: XAA can now load the pixmap cache without requiring

-	that the driver supply an ImageWrite function, but this can

-	only be done on linear framebuffers.  If you have a linear

-	framebuffer, set LINEAR_FRAMEBUFFER in the XAAInfoRec.Flags

-	field and XAA will then be able to upload pixmaps into the

-	cache without the driver providing functions to do so.

-   */

-

-

-   The XAA pixmap cache provides a mechanism for caching of patterns

-   in offscreen video memory so that tiled fills and in some cases

-   stippling can be done by blitting the source patterns from offscreen

-   video memory. The pixmap cache also provides the mechanism for caching 

-   of 8x8 color and mono hardware patterns.  Any unused offscreen video

-   memory gets used for the pixmap cache and that information is 

-   provided by the XFree86 Offscreen Memory Manager. XAA registers a 

-   callback with the manager so that it can be informed of any changes 

-   in the offscreen memory configuration.  The driver writer does not 

-   need to deal with any of this since it is all automatic.  The driver 

-   merely needs to initialize the Offscreen Memory Manager as described 

-   in the DESIGN document and set the PIXMAP_CACHE flag in the 

-   XAAInfoRec.Flags field.  The Offscreen Memory Manager initialization 

-   must occur before XAA is initialized or else pixmap cache 

-   initialization will fail.  

-

-   PixmapCacheFlags is an XAAInfoRec field which allows the driver to

-   control pixmap cache behavior to some extent.  Currently only one

-   flag is defined:

-

-   DO_NOT_BLIT_STIPPLES

-

-     This indicates that the stippling should not be done by blitting

-     from the pixmap cache.  This does not apply to 8x8 pattern fills. 

-

-

-   CachePixelGranularity is an optional field.  If the hardware requires

-   that a 8x8 patterns have some particular pixel alignment it should

-   be reflected in this field.  Ignoring this field or setting it to

-   zero or one means there are no alignment issues.

-

-

-4)  OFFSCREEN PIXMAPS

-

-   XAA has the ability to store pixmap drawables in offscreen video 

-   memory and render into them with full hardware acceleration.  Placement

-   of pixmaps in the cache is done automatically on a first-come basis and 

-   only if there is room.  To enable this feature, set the OFFSCREEN_PIXMAPS

-   flag in the XAAInfoRec.Flags field.  This is only available when a

-   ScreenToScreenCopy function is provided, when the Offscreen memory 

-   manager has been initialized and when the LINEAR_FRAMEBUFFER flag is

-   also set.

-

-   int maxOffPixWidth

-   int maxOffPixHeight

-

-       These two fields allow the driver to limit the maximum dimensions

-     of an offscreen pixmap.  If one of these is not set, it is assumed

-     that there is no limit on that dimension.  Note that if an offscreen

-     pixmap with a particular dimension is allowed, then your driver will be

-     expected to render primitives as large as that pixmap.  

-

-$XFree86: xc/programs/Xserver/hw/xfree86/xaa/XAA.HOWTO,v 1.12 2000/04/12 14:44:42 tsi Exp $

diff --git a/xorg-server/hw/xfree86/xaa/xaa.h b/xorg-server/hw/xfree86/xaa/xaa.h
deleted file mode 100644
index b530037c9..000000000
--- a/xorg-server/hw/xfree86/xaa/xaa.h
+++ /dev/null
@@ -1,1038 +0,0 @@
-
-#ifndef _XAA_H
-#define _XAA_H
-
-#define XAA_VERSION_MAJOR   1
-#define XAA_VERSION_MINOR   2
-#define XAA_VERSION_RELEASE 1
-
-/*
-
-   ******** OPERATION SPECIFIC FLAGS *********
-
-   **** solid/dashed line flags ****
- 
----------               --------
-23           LINE_PATTERN_LSBFIRST_MSBJUSTIFIED
-22           LINE_PATTERN_LSBFIRST_LSBJUSTIFIED
-21           LINE_PATTERN_MSBFIRST_MSBJUSTIFIED
-20           LINE_PATTERN_MSBFIRST_LSBJUSTIFIED
-19           LINE_PATTERN_POWER_OF_2_ONLY
-18           LINE_LIMIT_COORDS
-17                         .
-16                         .
----------               -------
-
-   **** screen to screen copy flags ****
-
----------               --------
-23           ONLY_LEFT_TO_RIGHT_BITBLT
-22           ONLY_TWO_BITBLT_DIRECTIONS
-21                         .
-20                         .
-19                         .
-18                         .
-17                         .
-16                         .
----------               -------
-
-   ****  clipping flags ****
-
----------               --------
-23                         .
-22           HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND
-21           HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
-20           HARDWARE_CLIP_MONO_8x8_FILL
-19           HARDWARE_CLIP_COLOR_8x8_FILL    
-18           HARDWARE_CLIP_SOLID_FILL
-17           HARDWARE_CLIP_DASHED_LINE
-16           HARDWARE_CLIP_SOLID_LINE
----------               -------
-
-   ****  hardware pattern flags ****
-
----------               --------
-23                         .
-22                         .
-21           HARDWARE_PATTERN_SCREEN_ORIGIN
-20                         .
-19                         .
-18                         .
-17           HARDWARE_PATTERN_PROGRAMMED_ORIGIN
-16           HARDWARE_PATTERN_PROGRAMMED_BITS
----------               -------
-
-   ****  write pixmap flags ****
-
----------               --------
-23                         .
-22                         .
-21                         .
-20                         .
-19                         .
-18                         .
-17                         .
-16           CONVERT_32BPP_TO_24BPP
----------               -------
-
-   ******** GENERIC FLAGS *********
-
----------               -------
-15           SYNC_AFTER_COLOR_EXPAND
-14           CPU_TRANSFER_PAD_QWORD
-13                         .
-12           LEFT_EDGE_CLIPPING_NEGATIVE_X
-11	     LEFT_EDGE_CLIPPING
-10	     CPU_TRANSFER_BASE_FIXED
- 9           BIT_ORDER_IN_BYTE_MSBFIRST           
- 8           TRANSPARENCY_GXCOPY_ONLY
----------               -------
- 7           NO_TRANSPARENCY
- 6           TRANSPARENCY_ONLY
- 5           ROP_NEEDS_SOURCE
- 4           TRIPLE_BITS_24BPP
- 3           RGB_EQUAL
- 2           NO_PLANEMASK
- 1           NO_GXCOPY
- 0           GXCOPY_ONLY
----------               -------
-
-
-*/
-
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "regionstr.h"
-#include "xf86fbman.h"
-
-#include "picturestr.h"
-
-/* Flags */
-#define PIXMAP_CACHE			0x00000001
-#define MICROSOFT_ZERO_LINE_BIAS	0x00000002
-#define OFFSCREEN_PIXMAPS		0x00000004
-#define LINEAR_FRAMEBUFFER		0x00000008
-
-/* GC fg, bg, and planemask restrictions */
-#define GXCOPY_ONLY			0x00000001
-#define NO_GXCOPY			0x00000002
-#define NO_PLANEMASK			0x00000004
-#define RGB_EQUAL			0x00000008
-#define TRIPLE_BITS_24BPP		0x00000010
-#define ROP_NEEDS_SOURCE		0x00000020
-
-/* transparency restrictions */
-#define TRANSPARENCY_ONLY		0x00000040
-#define NO_TRANSPARENCY			0x00000080
-#define TRANSPARENCY_GXCOPY_ONLY     	0x00000100
-
-/* bit order restrictions */
-#define BIT_ORDER_IN_BYTE_MSBFIRST	0x00000200
-#define BIT_ORDER_IN_BYTE_LSBFIRST	0x00000000
-
-/* transfer base restriction */
-#define CPU_TRANSFER_BASE_FIXED		0x00000400
-
-/* skipleft restrictions */
-#define LEFT_EDGE_CLIPPING		0x00000800
-#define LEFT_EDGE_CLIPPING_NEGATIVE_X	0x00001000
-
-/* data padding */
-#define CPU_TRANSFER_PAD_DWORD		0x00000000
-#define CPU_TRANSFER_PAD_QWORD		0x00004000
-#define SCANLINE_PAD_DWORD		0x00000000
-
-#define SYNC_AFTER_COLOR_EXPAND		0x00008000
-#define SYNC_AFTER_IMAGE_WRITE		SYNC_AFTER_COLOR_EXPAND
-
-/* hardware pattern */
-#define HARDWARE_PATTERN_PROGRAMMED_BITS	0x00010000
-#define HARDWARE_PATTERN_PROGRAMMED_ORIGIN	0x00020000
-#define HARDWARE_PATTERN_SCREEN_ORIGIN		0x00200000
-
-/* copyarea flags */
-#define ONLY_TWO_BITBLT_DIRECTIONS	0x00400000
-#define ONLY_LEFT_TO_RIGHT_BITBLT	0x00800000
-
-/* line flags */
-#define LINE_PATTERN_LSBFIRST_MSBJUSTIFIED	0x00800000
-#define LINE_PATTERN_LSBFIRST_LSBJUSTIFIED	0x00400000
-#define LINE_PATTERN_MSBFIRST_MSBJUSTIFIED	0x00200000
-#define LINE_PATTERN_MSBFIRST_LSBJUSTIFIED	0x00100000
-#define LINE_PATTERN_POWER_OF_2_ONLY		0x00080000
-#define LINE_LIMIT_COORDS			0x00040000
-
-/* clipping flags */
-#define HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND	0x00400000
-#define HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY		0x00200000
-#define HARDWARE_CLIP_MONO_8x8_FILL			0x00100000
-#define HARDWARE_CLIP_COLOR_8x8_FILL			0x00080000
-#define HARDWARE_CLIP_SOLID_FILL			0x00040000
-#define HARDWARE_CLIP_DASHED_LINE			0x00020000
-#define HARDWARE_CLIP_SOLID_LINE			0x00010000
-
-#define HARDWARE_CLIP_LINE				0x00000000
-
-/* image write flags */
-#define CONVERT_32BPP_TO_24BPP			0x00010000
-
-/* pixmap cache flags */
-#define CACHE_MONO_8x8			0x00000001
-#define CACHE_COLOR_8x8			0x00000002
-#define DO_NOT_BLIT_STIPPLES		0x00000004
-#define DO_NOT_TILE_MONO_DATA		0x00000008
-#define DO_NOT_TILE_COLOR_DATA		0x00000010
-
-#define DEGREES_0	0
-#define DEGREES_90	1
-#define DEGREES_180	2
-#define DEGREES_270	3
-
-#define OMIT_LAST	1
-
-/* render flags */
-
-#define XAA_RENDER_POWER_OF_2_TILE_ONLY	0x00000008
-#define XAA_RENDER_NO_SRC_ALPHA		0x00000004
-#define XAA_RENDER_IMPRECISE_ONLY	0x00000002
-#define XAA_RENDER_NO_TILE		0x00000001
-
-#define XAA_RENDER_REPEAT		0x00000001
-
-typedef void (*ValidateGCProcPtr) (GCPtr pGC,
-                                   unsigned long changes, DrawablePtr pDraw);
-
-typedef struct {
-    unsigned char *bits;
-    int width;
-    int height;
-    int yoff;
-    int srcwidth;
-    int start;
-    int end;
-} NonTEGlyphInfo, *NonTEGlyphPtr;
-
-typedef struct {
-    int x;
-    int y;
-    int w;
-    int h;
-    int orig_w;
-    int orig_h;
-    unsigned long serialNumber;
-    int pat0;
-    int pat1;
-    int fg;
-    int bg;
-    int trans_color;
-    DDXPointPtr offsets;
-    DevUnion devPrivate;
-} XAACacheInfoRec, *XAACacheInfoPtr;
-
-typedef struct _PixmapLink {
-    PixmapPtr pPix;
-    struct _PixmapLink *next;
-    FBAreaPtr area;
-} PixmapLink, *PixmapLinkPtr;
-
-typedef struct _XAAInfoRec {
-    ScrnInfoPtr pScrn;
-    int Flags;
-
-    void (*Sync) (ScrnInfoPtr pScrn);
-
-    /* Restore Accel State is a driver callback that is used
-     * when another screen on the same device has been active.
-     * This allows multihead on a single device to work.
-     * If The entityProp has IS_SHARED_ACCEL defined then this
-     * function is required.
-     */
-
-    void (*RestoreAccelState) (ScrnInfoPtr pScrn);
-
-   /***************** Low Level *****************/
-
-/* Blits */
-    void (*SetupForScreenToScreenCopy) (ScrnInfoPtr pScrn,
-                                        int xdir, int ydir,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int trans_color);
-    int ScreenToScreenCopyFlags;
-
-    void (*SubsequentScreenToScreenCopy) (ScrnInfoPtr pScrn,
-                                          int xsrc, int ysrc,
-                                          int xdst, int ydst, int w, int h);
-
-/* Solid fills */
-    void (*SetupForSolidFill) (ScrnInfoPtr pScrn,
-                               int color, int rop, unsigned int planemask);
-    int SolidFillFlags;
-
-    void (*SubsequentSolidFillRect) (ScrnInfoPtr pScrn,
-                                     int x, int y, int w, int h);
-
-    void (*SubsequentSolidFillTrap) (ScrnInfoPtr pScrn,
-                                     int y, int h,
-                                     int left, int dxL, int dyL, int eL,
-                                     int right, int dxR, int dyR, int eR);
-
-/* Solid lines */
-
-    void (*SetupForSolidLine) (ScrnInfoPtr pScrn,
-                               int color, int rop, unsigned int planemask);
-    int SolidLineFlags;
-
-    void (*SubsequentSolidTwoPointLine) (ScrnInfoPtr pScrn,
-                                         int xa, int ya, int xb, int yb,
-                                         int flags);
-
-    void (*SubsequentSolidBresenhamLine) (ScrnInfoPtr pScrn,
-                                          int x, int y, int absmaj, int absmin,
-                                          int err, int len, int octant);
-    int SolidBresenhamLineErrorTermBits;
-
-    void (*SubsequentSolidHorVertLine) (ScrnInfoPtr pScrn,
-                                        int x, int y, int len, int dir);
-
-/* Dashed lines */
-
-    void (*SetupForDashedLine) (ScrnInfoPtr pScrn,
-                                int fg, int bg,
-                                int rop,
-                                unsigned int planemask,
-                                int length, unsigned char *pattern);
-    int DashedLineFlags;
-    int DashPatternMaxLength;
-
-    void (*SubsequentDashedTwoPointLine) (ScrnInfoPtr pScrn,
-                                          int xa, int ya, int xb, int yb,
-                                          int flags, int phase);
-
-    void (*SubsequentDashedBresenhamLine) (ScrnInfoPtr pScrn,
-                                           int x, int y, int absmaj, int absmin,
-                                           int err, int len, int flags,
-                                           int phase);
-    int DashedBresenhamLineErrorTermBits;
-
-/* Clipper */
-
-    void (*SetClippingRectangle) (ScrnInfoPtr pScrn,
-                                  int left, int top, int right, int bottom);
-    int ClippingFlags;
-
-    void (*DisableClipping) (ScrnInfoPtr pScrn);
-
-/* 8x8 mono pattern fills */
-    void (*SetupForMono8x8PatternFill) (ScrnInfoPtr pScrn,
-                                        int patx, int paty,
-                                        int fg, int bg,
-                                        int rop, unsigned int planemask);
-    int Mono8x8PatternFillFlags;
-
-    void (*SubsequentMono8x8PatternFillRect) (ScrnInfoPtr pScrn,
-                                              int patx, int paty,
-                                              int x, int y, int w, int h);
-
-    void (*SubsequentMono8x8PatternFillTrap) (ScrnInfoPtr pScrn,
-                                              int patx, int paty,
-                                              int y, int h,
-                                              int left, int dxL, int dyL,
-                                              int eL, int right, int dxR,
-                                              int dyR, int eR);
-
-/* 8x8 color pattern fills */
-
-    void (*SetupForColor8x8PatternFill) (ScrnInfoPtr pScrn,
-                                         int patx, int paty,
-                                         int rop,
-                                         unsigned int planemask,
-                                         int transparency_color);
-    int Color8x8PatternFillFlags;
-
-    void (*SubsequentColor8x8PatternFillRect) (ScrnInfoPtr pScrn,
-                                               int patx, int paty,
-                                               int x, int y, int w, int h);
-
-    void (*SubsequentColor8x8PatternFillTrap) (ScrnInfoPtr pScrn,
-                                               int patx, int paty,
-                                               int y, int h,
-                                               int left, int dxL, int dyL,
-                                               int eL, int right, int dxR,
-                                               int dyR, int eR);
-
-/* Color expansion */
-
-    void (*SetupForCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                int fg, int bg,
-                                                int rop,
-                                                unsigned int planemask);
-    int CPUToScreenColorExpandFillFlags;
-
-    void (*SubsequentCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                  int x, int y, int w, int h,
-                                                  int skipleft);
-
-    unsigned char *ColorExpandBase;
-    int ColorExpandRange;
-
-/* Scanline color expansion  */
-
-    void (*SetupForScanlineCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                        int fg, int bg,
-                                                        int rop,
-                                                        unsigned int planemask);
-    int ScanlineCPUToScreenColorExpandFillFlags;
-
-    void (*SubsequentScanlineCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                          int x, int y, int w,
-                                                          int h, int skipleft);
-
-    void (*SubsequentColorExpandScanline) (ScrnInfoPtr pScrn, int bufno);
-
-    int NumScanlineColorExpandBuffers;
-    unsigned char **ScanlineColorExpandBuffers;
-
-/* Screen to screen color expansion */
-
-    void (*SetupForScreenToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                   int fg, int bg,
-                                                   int rop,
-                                                   unsigned int planemask);
-    int ScreenToScreenColorExpandFillFlags;
-
-    void (*SubsequentScreenToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                     int x, int y, int w, int h,
-                                                     int srcx, int srcy,
-                                                     int skipleft);
-
-/*  Image transfers */
-
-    void (*SetupForImageWrite) (ScrnInfoPtr pScrn,
-                                int rop,
-                                unsigned int planemask,
-                                int transparency_color, int bpp, int depth);
-    int ImageWriteFlags;
-
-    void (*SubsequentImageWriteRect) (ScrnInfoPtr pScrn,
-                                      int x, int y, int w, int h, int skipleft);
-    unsigned char *ImageWriteBase;
-    int ImageWriteRange;
-
-/*  Scanline Image transfers */
-
-    void (*SetupForScanlineImageWrite) (ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int transparency_color,
-                                        int bpp, int depth);
-    int ScanlineImageWriteFlags;
-
-    void (*SubsequentScanlineImageWriteRect) (ScrnInfoPtr pScrn,
-                                              int x, int y, int w, int h,
-                                              int skipleft);
-
-    void (*SubsequentImageWriteScanline) (ScrnInfoPtr pScrn, int bufno);
-
-    int NumScanlineImageWriteBuffers;
-    unsigned char **ScanlineImageWriteBuffers;
-
-    /* Image Reads - OBSOLETE AND NOT USED */
-
-    void (*SetupForImageRead) (ScrnInfoPtr pScrn, int bpp, int depth);
-    int ImageReadFlags;
-
-    unsigned char *ImageReadBase;
-    int ImageReadRange;
-
-    void (*SubsequentImageReadRect) (ScrnInfoPtr pScrn,
-                                     int x, int y, int w, int h);
-
-   /***************** Mid Level *****************/
-    void (*ScreenToScreenBitBlt) (ScrnInfoPtr pScrn,
-                                  int nbox,
-                                  DDXPointPtr pptSrc,
-                                  BoxPtr pbox,
-                                  int xdir, int ydir,
-                                  int alu, unsigned int planmask);
-    int ScreenToScreenBitBltFlags;
-
-    void (*WriteBitmap) (ScrnInfoPtr pScrn,
-                         int x, int y, int w, int h,
-                         unsigned char *src,
-                         int srcwidth,
-                         int skipleft,
-                         int fg, int bg, int rop, unsigned int planemask);
-    int WriteBitmapFlags;
-
-    void (*FillSolidRects) (ScrnInfoPtr pScrn,
-                            int fg, int rop,
-                            unsigned int planemask, int nBox, BoxPtr pBox);
-    int FillSolidRectsFlags;
-
-    void (*FillMono8x8PatternRects) (ScrnInfoPtr pScrn,
-                                     int fg, int bg, int rop,
-                                     unsigned int planemask,
-                                     int nBox,
-                                     BoxPtr pBox,
-                                     int pat0, int pat1, int xorg, int yorg);
-    int FillMono8x8PatternRectsFlags;
-
-    void (*FillColor8x8PatternRects) (ScrnInfoPtr pScrn,
-                                      int rop,
-                                      unsigned int planemask,
-                                      int nBox,
-                                      BoxPtr pBox,
-                                      int xorg, int yorg,
-                                      XAACacheInfoPtr pCache);
-    int FillColor8x8PatternRectsFlags;
-
-    void (*FillCacheBltRects) (ScrnInfoPtr pScrn,
-                               int rop,
-                               unsigned int planemask,
-                               int nBox,
-                               BoxPtr pBox,
-                               int xorg, int yorg, XAACacheInfoPtr pCache);
-    int FillCacheBltRectsFlags;
-
-    void (*FillColorExpandRects) (ScrnInfoPtr pScrn,
-                                  int fg, int bg, int rop,
-                                  unsigned int planemask,
-                                  int nBox,
-                                  BoxPtr pBox,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    int FillColorExpandRectsFlags;
-
-    void (*FillCacheExpandRects) (ScrnInfoPtr pScrn,
-                                  int fg, int bg, int rop,
-                                  unsigned int planemask,
-                                  int nBox,
-                                  BoxPtr pBox,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    int FillCacheExpandRectsFlags;
-
-    void (*FillImageWriteRects) (ScrnInfoPtr pScrn,
-                                 int rop,
-                                 unsigned int planemask,
-                                 int nBox,
-                                 BoxPtr pBox,
-                                 int xorg, int yorg, PixmapPtr pPix);
-    int FillImageWriteRectsFlags;
-
-    void (*FillSolidSpans) (ScrnInfoPtr pScrn,
-                            int fg, int rop,
-                            unsigned int planemask,
-                            int n,
-                            DDXPointPtr points, int *widths, int fSorted);
-    int FillSolidSpansFlags;
-
-    void (*FillMono8x8PatternSpans) (ScrnInfoPtr pScrn,
-                                     int fg, int bg, int rop,
-                                     unsigned int planemask,
-                                     int n,
-                                     DDXPointPtr points,
-                                     int *widths,
-                                     int fSorted,
-                                     int pat0, int pat1, int xorg, int yorg);
-    int FillMono8x8PatternSpansFlags;
-
-    void (*FillColor8x8PatternSpans) (ScrnInfoPtr pScrn,
-                                      int rop,
-                                      unsigned int planemask,
-                                      int n,
-                                      DDXPointPtr points,
-                                      int *widths,
-                                      int fSorted,
-                                      XAACacheInfoPtr pCache,
-                                      int xorg, int yorg);
-    int FillColor8x8PatternSpansFlags;
-
-    void (*FillCacheBltSpans) (ScrnInfoPtr pScrn,
-                               int rop,
-                               unsigned int planemask,
-                               int n,
-                               DDXPointPtr points,
-                               int *widths,
-                               int fSorted,
-                               XAACacheInfoPtr pCache, int xorg, int yorg);
-    int FillCacheBltSpansFlags;
-
-    void (*FillColorExpandSpans) (ScrnInfoPtr pScrn,
-                                  int fg, int bg, int rop,
-                                  unsigned int planemask,
-                                  int n,
-                                  DDXPointPtr points,
-                                  int *widths,
-                                  int fSorted,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    int FillColorExpandSpansFlags;
-
-    void (*FillCacheExpandSpans) (ScrnInfoPtr pScrn,
-                                  int fg, int bg, int rop,
-                                  unsigned int planemask,
-                                  int n,
-                                  DDXPointPtr ppt,
-                                  int *pwidth,
-                                  int fSorted,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    int FillCacheExpandSpansFlags;
-
-    void (*TEGlyphRenderer) (ScrnInfoPtr pScrn,
-                             int x, int y, int w, int h, int skipleft,
-                             int startline, unsigned int **glyphs,
-                             int glyphWidth, int fg, int bg, int rop,
-                             unsigned planemask);
-    int TEGlyphRendererFlags;
-
-    void (*NonTEGlyphRenderer) (ScrnInfoPtr pScrn,
-                                int x, int y, int n,
-                                NonTEGlyphPtr glyphs,
-                                BoxPtr pbox,
-                                int fg, int rop, unsigned int planemask);
-    int NonTEGlyphRendererFlags;
-
-    void (*WritePixmap) (ScrnInfoPtr pScrn,
-                         int x, int y, int w, int h,
-                         unsigned char *src,
-                         int srcwidth,
-                         int rop,
-                         unsigned int planemask,
-                         int transparency_color, int bpp, int depth);
-    int WritePixmapFlags;
-
-    void (*ReadPixmap) (ScrnInfoPtr pScrn,
-                        int x, int y, int w, int h,
-                        unsigned char *dst, int dstwidth, int bpp, int depth);
-    int ReadPixmapFlags;
-
-   /***************** GC Level *****************/
-    RegionPtr (*CopyArea) (DrawablePtr pSrcDrawable,
-                           DrawablePtr pDstDrawable,
-                           GC * pGC,
-                           int srcx, int srcy,
-                           int width, int height, int dstx, int dsty);
-    int CopyAreaFlags;
-
-    RegionPtr (*CopyPlane) (DrawablePtr pSrc,
-                            DrawablePtr pDst,
-                            GCPtr pGC,
-                            int srcx, int srcy,
-                            int width, int height,
-                            int dstx, int dsty, unsigned long bitPlane);
-    int CopyPlaneFlags;
-
-    void (*PushPixelsSolid) (GCPtr pGC,
-                             PixmapPtr pBitMap,
-                             DrawablePtr pDrawable,
-                             int dx, int dy, int xOrg, int yOrg);
-    int PushPixelsFlags;
-
-   /** PolyFillRect **/
-
-    void (*PolyFillRectSolid) (DrawablePtr pDraw,
-                               GCPtr pGC, int nrectFill, xRectangle *prectInit);
-    int PolyFillRectSolidFlags;
-
-    void (*PolyFillRectStippled) (DrawablePtr pDraw,
-                                  GCPtr pGC,
-                                  int nrectFill, xRectangle *prectInit);
-    int PolyFillRectStippledFlags;
-
-    void (*PolyFillRectOpaqueStippled) (DrawablePtr pDraw,
-                                        GCPtr pGC,
-                                        int nrectFill, xRectangle *prectInit);
-    int PolyFillRectOpaqueStippledFlags;
-
-    void (*PolyFillRectTiled) (DrawablePtr pDraw,
-                               GCPtr pGC, int nrectFill, xRectangle *prectInit);
-    int PolyFillRectTiledFlags;
-
-   /** FillSpans **/
-
-    void (*FillSpansSolid) (DrawablePtr pDraw,
-                            GCPtr pGC,
-                            int nInit,
-                            DDXPointPtr ppt, int *pwidth, int fSorted);
-    int FillSpansSolidFlags;
-
-    void (*FillSpansStippled) (DrawablePtr pDraw,
-                               GCPtr pGC,
-                               int nInit,
-                               DDXPointPtr ppt, int *pwidth, int fSorted);
-    int FillSpansStippledFlags;
-
-    void (*FillSpansOpaqueStippled) (DrawablePtr pDraw,
-                                     GCPtr pGC,
-                                     int nInit,
-                                     DDXPointPtr ppt, int *pwidth, int fSorted);
-    int FillSpansOpaqueStippledFlags;
-
-    void (*FillSpansTiled) (DrawablePtr pDraw,
-                            GCPtr pGC,
-                            int nInit,
-                            DDXPointPtr ppt, int *pwidth, int fSorted);
-    int FillSpansTiledFlags;
-
-    int (*PolyText8TE) (DrawablePtr pDraw,
-                        GCPtr pGC, int x, int y, int count, char *chars);
-    int PolyText8TEFlags;
-
-    int (*PolyText16TE) (DrawablePtr pDraw,
-                         GCPtr pGC,
-                         int x, int y, int count, unsigned short *chars);
-    int PolyText16TEFlags;
-
-    void (*ImageText8TE) (DrawablePtr pDraw,
-                          GCPtr pGC, int x, int y, int count, char *chars);
-    int ImageText8TEFlags;
-
-    void (*ImageText16TE) (DrawablePtr pDraw,
-                           GCPtr pGC,
-                           int x, int y, int count, unsigned short *chars);
-    int ImageText16TEFlags;
-
-    void (*ImageGlyphBltTE) (DrawablePtr pDrawable,
-                             GCPtr pGC,
-                             int xInit, int yInit,
-                             unsigned int nglyph,
-                             CharInfoPtr * ppci, pointer pglyphBase);
-    int ImageGlyphBltTEFlags;
-
-    void (*PolyGlyphBltTE) (DrawablePtr pDrawable,
-                            GCPtr pGC,
-                            int xInit, int yInit,
-                            unsigned int nglyph,
-                            CharInfoPtr * ppci, pointer pglyphBase);
-    int PolyGlyphBltTEFlags;
-
-    int (*PolyText8NonTE) (DrawablePtr pDraw,
-                           GCPtr pGC, int x, int y, int count, char *chars);
-    int PolyText8NonTEFlags;
-
-    int (*PolyText16NonTE) (DrawablePtr pDraw,
-                            GCPtr pGC,
-                            int x, int y, int count, unsigned short *chars);
-    int PolyText16NonTEFlags;
-
-    void (*ImageText8NonTE) (DrawablePtr pDraw,
-                             GCPtr pGC, int x, int y, int count, char *chars);
-    int ImageText8NonTEFlags;
-
-    void (*ImageText16NonTE) (DrawablePtr pDraw,
-                              GCPtr pGC,
-                              int x, int y, int count, unsigned short *chars);
-    int ImageText16NonTEFlags;
-
-    void (*ImageGlyphBltNonTE) (DrawablePtr pDrawable,
-                                GCPtr pGC,
-                                int xInit, int yInit,
-                                unsigned int nglyph,
-                                CharInfoPtr * ppci, pointer pglyphBase);
-    int ImageGlyphBltNonTEFlags;
-
-    void (*PolyGlyphBltNonTE) (DrawablePtr pDrawable,
-                               GCPtr pGC,
-                               int xInit, int yInit,
-                               unsigned int nglyph,
-                               CharInfoPtr * ppci, pointer pglyphBase);
-    int PolyGlyphBltNonTEFlags;
-
-    void (*PolyRectangleThinSolid) (DrawablePtr pDrawable,
-                                    GCPtr pGC,
-                                    int nRectsInit, xRectangle *pRectsInit);
-    int PolyRectangleThinSolidFlags;
-
-    void (*PolylinesWideSolid) (DrawablePtr pDrawable,
-                                GCPtr pGC, int mode, int npt, DDXPointPtr pPts);
-    int PolylinesWideSolidFlags;
-
-    void (*PolylinesThinSolid) (DrawablePtr pDrawable,
-                                GCPtr pGC, int mode, int npt, DDXPointPtr pPts);
-    int PolylinesThinSolidFlags;
-
-    void (*PolySegmentThinSolid) (DrawablePtr pDrawable,
-                                  GCPtr pGC, int nseg, xSegment * pSeg);
-    int PolySegmentThinSolidFlags;
-
-    void (*PolylinesThinDashed) (DrawablePtr pDrawable,
-                                 GCPtr pGC,
-                                 int mode, int npt, DDXPointPtr pPts);
-    int PolylinesThinDashedFlags;
-
-    void (*PolySegmentThinDashed) (DrawablePtr pDrawable,
-                                   GCPtr pGC, int nseg, xSegment * pSeg);
-    int PolySegmentThinDashedFlags;
-
-    void (*FillPolygonSolid) (DrawablePtr pDrawable,
-                              GCPtr pGC,
-                              int shape,
-                              int mode, int count, DDXPointPtr ptsIn);
-    int FillPolygonSolidFlags;
-
-    void (*FillPolygonStippled) (DrawablePtr pDrawable,
-                                 GCPtr pGC,
-                                 int shape,
-                                 int mode, int count, DDXPointPtr ptsIn);
-    int FillPolygonStippledFlags;
-
-    void (*FillPolygonOpaqueStippled) (DrawablePtr pDrawable,
-                                       GCPtr pGC,
-                                       int shape,
-                                       int mode, int count, DDXPointPtr ptsIn);
-    int FillPolygonOpaqueStippledFlags;
-
-    void (*FillPolygonTiled) (DrawablePtr pDrawable,
-                              GCPtr pGC,
-                              int shape,
-                              int mode, int count, DDXPointPtr ptsIn);
-    int FillPolygonTiledFlags;
-
-    void (*PolyFillArcSolid) (DrawablePtr pDraw,
-                              GCPtr pGC, int narcs, xArc * parcs);
-    int PolyFillArcSolidFlags;
-
-    void (*PutImage) (DrawablePtr pDraw,
-                      GCPtr pGC,
-                      int depth,
-                      int x,
-                      int y,
-                      int w, int h, int leftPad, int format, char *pImage);
-    int PutImageFlags;
-
-    /* Validation masks */
-
-    unsigned long FillSpansMask;
-    ValidateGCProcPtr ValidateFillSpans;
-    unsigned long SetSpansMask;
-    ValidateGCProcPtr ValidateSetSpans;
-    unsigned long PutImageMask;
-    ValidateGCProcPtr ValidatePutImage;
-    unsigned long CopyAreaMask;
-    ValidateGCProcPtr ValidateCopyArea;
-    unsigned long CopyPlaneMask;
-    ValidateGCProcPtr ValidateCopyPlane;
-    unsigned long PolyPointMask;
-    ValidateGCProcPtr ValidatePolyPoint;
-    unsigned long PolylinesMask;
-    ValidateGCProcPtr ValidatePolylines;
-    unsigned long PolySegmentMask;
-    ValidateGCProcPtr ValidatePolySegment;
-    unsigned long PolyRectangleMask;
-    ValidateGCProcPtr ValidatePolyRectangle;
-    unsigned long PolyArcMask;
-    ValidateGCProcPtr ValidatePolyArc;
-    unsigned long FillPolygonMask;
-    ValidateGCProcPtr ValidateFillPolygon;
-    unsigned long PolyFillRectMask;
-    ValidateGCProcPtr ValidatePolyFillRect;
-    unsigned long PolyFillArcMask;
-    ValidateGCProcPtr ValidatePolyFillArc;
-    unsigned long PolyText8Mask;
-    ValidateGCProcPtr ValidatePolyText8;
-    unsigned long PolyText16Mask;
-    ValidateGCProcPtr ValidatePolyText16;
-    unsigned long ImageText8Mask;
-    ValidateGCProcPtr ValidateImageText8;
-    unsigned long ImageText16Mask;
-    ValidateGCProcPtr ValidateImageText16;
-    unsigned long PolyGlyphBltMask;
-    ValidateGCProcPtr ValidatePolyGlyphBlt;
-    unsigned long ImageGlyphBltMask;
-    ValidateGCProcPtr ValidateImageGlyphBlt;
-    unsigned long PushPixelsMask;
-    ValidateGCProcPtr ValidatePushPixels;
-
-    void (*ComputeDash) (GCPtr pGC);
-
-    /* Pixmap Cache */
-
-    int PixmapCacheFlags;
-    Bool UsingPixmapCache;
-    Bool CanDoMono8x8;
-    Bool CanDoColor8x8;
-
-    void (*InitPixmapCache) (ScreenPtr pScreen, RegionPtr areas, pointer data);
-    void (*ClosePixmapCache) (ScreenPtr pScreen);
-
-    int (*StippledFillChooser) (GCPtr pGC);
-    int (*OpaqueStippledFillChooser) (GCPtr pGC);
-    int (*TiledFillChooser) (GCPtr pGC);
-
-    int CachePixelGranularity;
-    int MaxCacheableTileWidth;
-    int MaxCacheableTileHeight;
-    int MaxCacheableStippleWidth;
-    int MaxCacheableStippleHeight;
-
-     XAACacheInfoPtr(*CacheTile) (ScrnInfoPtr Scrn, PixmapPtr pPix);
-     XAACacheInfoPtr(*CacheStipple) (ScrnInfoPtr Scrn, PixmapPtr pPix,
-                                     int fg, int bg);
-     XAACacheInfoPtr(*CacheMonoStipple) (ScrnInfoPtr Scrn, PixmapPtr pPix);
-     XAACacheInfoPtr(*CacheMono8x8Pattern) (ScrnInfoPtr Scrn, int pat0,
-                                            int pat1);
-     XAACacheInfoPtr(*CacheColor8x8Pattern) (ScrnInfoPtr Scrn, PixmapPtr pPix,
-                                             int fg, int bg);
-
-    int MonoPatternPitch;
-    int CacheWidthMono8x8Pattern;
-    int CacheHeightMono8x8Pattern;
-
-    int ColorPatternPitch;
-    int CacheWidthColor8x8Pattern;
-    int CacheHeightColor8x8Pattern;
-
-    int CacheColorExpandDensity;
-
-    void (*WriteBitmapToCache) (ScrnInfoPtr pScrn,
-                                int x, int y, int w, int h,
-                                unsigned char *src,
-                                int srcwidth, int fg, int bg);
-    void (*WritePixmapToCache) (ScrnInfoPtr pScrn,
-                                int x, int y, int w, int h,
-                                unsigned char *src,
-                                int srcwidth, int bpp, int depth);
-    void (*WriteMono8x8PatternToCache) (ScrnInfoPtr pScrn,
-                                        XAACacheInfoPtr pCache);
-    void (*WriteColor8x8PatternToCache) (ScrnInfoPtr pScrn,
-                                         PixmapPtr pPix,
-                                         XAACacheInfoPtr pCache);
-
-    char *PixmapCachePrivate;
-
-    /* Miscellaneous */
-
-    GC ScratchGC;
-    int PreAllocSize;
-    unsigned char *PreAllocMem;
-
-    CharInfoPtr CharInfo[255];
-    NonTEGlyphInfo GlyphInfo[255];
-
-    unsigned int FullPlanemask; /* deprecated */
-
-    PixmapLinkPtr OffscreenPixmaps;
-    int maxOffPixWidth;
-    int maxOffPixHeight;
-
-    XAACacheInfoRec ScratchCacheInfoRec;
-
-    BoxPtr ClipBox;
-
-    Bool NeedToSync;
-
-    char *dgaSaves;
-
-    /* These can be supplied to override the defaults */
-
-    GetImageProcPtr GetImage;
-    GetSpansProcPtr GetSpans;
-    CopyWindowProcPtr CopyWindow;
-
-    unsigned int offscreenDepths;
-    Bool offscreenDepthsInitialized;
-
-    CARD32 FullPlanemasks[32];
-
-    Bool (*Composite) (CARD8 op,
-                       PicturePtr pSrc,
-                       PicturePtr pMask,
-                       PicturePtr pDst,
-                       INT16 xSrc,
-                       INT16 ySrc,
-                       INT16 xMask,
-                       INT16 yMask,
-                       INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
-
-    Bool (*Glyphs) (CARD8 op,
-                    PicturePtr pSrc,
-                    PicturePtr pDst,
-                    PictFormatPtr maskFormat,
-                    INT16 xSrc,
-                    INT16 ySrc,
-                    int nlist, GlyphListPtr list, GlyphPtr * glyphs);
-
-    /* The old SetupForCPUToScreenAlphaTexture function is no longer used because
-     * it doesn't pass in enough information to write a conforming
-     * implementation.  See SetupForCPUToScreenAlphaTexture2.
-     */
-    Bool (*SetupForCPUToScreenAlphaTexture) (ScrnInfoPtr pScrn,
-                                             int op,
-                                             CARD16 red,
-                                             CARD16 green,
-                                             CARD16 blue,
-                                             CARD16 alpha,
-                                             int alphaType,
-                                             CARD8 *alphaPtr,
-                                             int alphaPitch,
-                                             int width, int height, int flags);
-    void (*SubsequentCPUToScreenAlphaTexture) (ScrnInfoPtr pScrn,
-                                               int dstx,
-                                               int dsty,
-                                               int srcx,
-                                               int srcy, int width, int height);
-    int CPUToScreenAlphaTextureFlags;
-    CARD32 *CPUToScreenAlphaTextureFormats;
-
-    /* The old SetupForCPUToScreenTexture function is no longer used because
-     * it doesn't pass in enough information to write a conforming
-     * implementation.  See SetupForCPUToScreenTexture2.
-     */
-    Bool (*SetupForCPUToScreenTexture) (ScrnInfoPtr pScrn,
-                                        int op,
-                                        int texType,
-                                        CARD8 *texPtr,
-                                        int texPitch,
-                                        int width, int height, int flags);
-    void (*SubsequentCPUToScreenTexture) (ScrnInfoPtr pScrn,
-                                          int dstx,
-                                          int dsty,
-                                          int srcx,
-                                          int srcy, int width, int height);
-    int CPUToScreenTextureFlags;
-    CARD32 *CPUToScreenTextureFormats;
-
-    /* these were added for 4.3.0 */
-    BoxRec SolidLineLimits;
-    BoxRec DashedLineLimits;
-
-    /* These were added for X.Org 6.8.0 */
-    Bool (*SetupForCPUToScreenAlphaTexture2) (ScrnInfoPtr pScrn,
-                                              int op,
-                                              CARD16 red,
-                                              CARD16 green,
-                                              CARD16 blue,
-                                              CARD16 alpha,
-                                              CARD32 maskFormat,
-                                              CARD32 dstFormat,
-                                              CARD8 *alphaPtr,
-                                              int alphaPitch,
-                                              int width, int height, int flags);
-    CARD32 *CPUToScreenAlphaTextureDstFormats;
-
-    Bool (*SetupForCPUToScreenTexture2) (ScrnInfoPtr pScrn,
-                                         int op,
-                                         CARD32 srcFormat,
-                                         CARD32 dstFormat,
-                                         CARD8 *texPtr,
-                                         int texPitch,
-                                         int width, int height, int flags);
-    CARD32 *CPUToScreenTextureDstFormats;
-} XAAInfoRec, *XAAInfoRecPtr;
-
-#define SET_SYNC_FLAG(infoRec)	(infoRec)->NeedToSync = TRUE
-
-extern _X_EXPORT Bool
- XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec);
-
-extern _X_EXPORT XAAInfoRecPtr XAACreateInfoRec(void);
-
-extern _X_EXPORT void
- XAADestroyInfoRec(XAAInfoRecPtr infoRec);
-
-typedef void (*DepthChangeFuncPtr) (ScrnInfoPtr pScrn, int depth);
-
-extern _X_EXPORT Bool
- XAAInitDualFramebufferOverlay(ScreenPtr pScreen, DepthChangeFuncPtr callback);
-
-#endif                          /* _XAA_H */
diff --git a/xorg-server/hw/xfree86/xaa/xaaBitBlt.c b/xorg-server/hw/xfree86/xaa/xaaBitBlt.c
deleted file mode 100644
index c1595c497..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaBitBlt.c
+++ /dev/null
@@ -1,229 +0,0 @@
-
-/* 
-   This is a lighter version of cfbBitBlt.  We calculate the boxes
-   when accelerating pixmap->screen and screen->screen copies. 
-   We also pass the GC to the doBitBlt function so that it has access
-   to the fg and bg so CopyPlane can use this. 
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "mi.h"
-#include "pixmapstr.h"
-#include "gcstruct.h"
-#include "windowstr.h"
-#include "xaalocal.h"
-
-RegionPtr
-XAABitBlt(DrawablePtr pSrcDrawable,
-          DrawablePtr pDstDrawable,
-          GC * pGC,
-          int srcx, int srcy,
-          int width, int height,
-          int dstx, int dsty,
-          void (*doBitBlt) (DrawablePtr, DrawablePtr, GCPtr, RegionPtr,
-                            DDXPointPtr), unsigned long bitPlane)
-{
-
-    RegionPtr prgnSrcClip = NULL;       /* may be a new region, or just a copy */
-    RegionPtr prgnExposed;
-    Bool freeSrcClip = FALSE;
-    RegionRec rgnDst;
-    DDXPointPtr pptSrc, ppt;
-    DDXPointRec origDest;
-    BoxPtr pbox;
-    BoxRec fastBox;
-    int i, dx, dy, numRects;
-    xRectangle origSource;
-    int fastClip = 0;           /* for fast clipping with pixmap source */
-    int fastExpose = 0;         /* for fast exposures with pixmap source */
-
-    origSource.x = srcx;
-    origSource.y = srcy;
-    origSource.width = width;
-    origSource.height = height;
-    origDest.x = dstx;
-    origDest.y = dsty;
-
-    if (pSrcDrawable->pScreen->SourceValidate) {
-        (*pSrcDrawable->pScreen->SourceValidate) (pSrcDrawable, srcx, srcy,
-                                                  width, height,
-                                                  pGC->subWindowMode);
-    }
-
-    srcx += pSrcDrawable->x;
-    srcy += pSrcDrawable->y;
-
-    /* clip the source */
-    if (pSrcDrawable->type == DRAWABLE_PIXMAP) {
-        if ((pSrcDrawable == pDstDrawable) && (pGC->clientClipType == CT_NONE))
-            prgnSrcClip = pGC->pCompositeClip;
-        else
-            fastClip = 1;
-    }
-    else {                      /* Window */
-        if (pGC->subWindowMode == IncludeInferiors) {
-            if (!((WindowPtr) pSrcDrawable)->parent) {
-                /*
-                 * special case bitblt from root window in
-                 * IncludeInferiors mode; just like from a pixmap
-                 */
-                fastClip = 1;
-            }
-            else if ((pSrcDrawable == pDstDrawable) &&
-                     (pGC->clientClipType == CT_NONE)) {
-                prgnSrcClip = pGC->pCompositeClip;
-            }
-            else {
-                prgnSrcClip = NotClippedByChildren((WindowPtr) pSrcDrawable);
-                freeSrcClip = TRUE;
-            }
-        }
-        else {
-            prgnSrcClip = &((WindowPtr) pSrcDrawable)->clipList;
-        }
-    }
-
-    fastBox.x1 = srcx;
-    fastBox.y1 = srcy;
-    fastBox.x2 = srcx + width;
-    fastBox.y2 = srcy + height;
-
-    /* Don't create a source region if we are doing a fast clip */
-    if (fastClip) {
-        fastExpose = 1;
-        /*
-         * clip the source; if regions extend beyond the source size,
-         * make sure exposure events get sent
-         */
-        if (fastBox.x1 < pSrcDrawable->x) {
-            fastBox.x1 = pSrcDrawable->x;
-            fastExpose = 0;
-        }
-        if (fastBox.y1 < pSrcDrawable->y) {
-            fastBox.y1 = pSrcDrawable->y;
-            fastExpose = 0;
-        }
-        if (fastBox.x2 > pSrcDrawable->x + (int) pSrcDrawable->width) {
-            fastBox.x2 = pSrcDrawable->x + (int) pSrcDrawable->width;
-            fastExpose = 0;
-        }
-        if (fastBox.y2 > pSrcDrawable->y + (int) pSrcDrawable->height) {
-            fastBox.y2 = pSrcDrawable->y + (int) pSrcDrawable->height;
-            fastExpose = 0;
-        }
-    }
-    else {
-        RegionInit(&rgnDst, &fastBox, 1);
-        RegionIntersect(&rgnDst, &rgnDst, prgnSrcClip);
-    }
-
-    dstx += pDstDrawable->x;
-    dsty += pDstDrawable->y;
-
-    if (pDstDrawable->type == DRAWABLE_WINDOW) {
-        if (!((WindowPtr) pDstDrawable)->realized) {
-            if (!fastClip)
-                RegionUninit(&rgnDst);
-            if (freeSrcClip)
-                RegionDestroy(prgnSrcClip);
-            return NULL;
-        }
-    }
-
-    dx = srcx - dstx;
-    dy = srcy - dsty;
-
-    /* Translate and clip the dst to the destination composite clip */
-    if (fastClip) {
-        RegionPtr cclip;
-
-        /* Translate the region directly */
-        fastBox.x1 -= dx;
-        fastBox.x2 -= dx;
-        fastBox.y1 -= dy;
-        fastBox.y2 -= dy;
-
-        /* If the destination composite clip is one rectangle we can
-           do the clip directly.  Otherwise we have to create a full
-           blown region and call intersect */
-
-        cclip = pGC->pCompositeClip;
-        if (RegionNumRects(cclip) == 1) {
-            BoxPtr pBox = RegionRects(cclip);
-
-            if (fastBox.x1 < pBox->x1)
-                fastBox.x1 = pBox->x1;
-            if (fastBox.x2 > pBox->x2)
-                fastBox.x2 = pBox->x2;
-            if (fastBox.y1 < pBox->y1)
-                fastBox.y1 = pBox->y1;
-            if (fastBox.y2 > pBox->y2)
-                fastBox.y2 = pBox->y2;
-
-            /* Check to see if the region is empty */
-            if (fastBox.x1 >= fastBox.x2 || fastBox.y1 >= fastBox.y2) {
-                RegionNull(&rgnDst);
-            }
-            else {
-                RegionInit(&rgnDst, &fastBox, 1);
-            }
-        }
-        else {
-            /* We must turn off fastClip now, since we must create
-               a full blown region.  It is intersected with the
-               composite clip below. */
-            fastClip = 0;
-            RegionInit(&rgnDst, &fastBox, 1);
-        }
-    }
-    else {
-        RegionTranslate(&rgnDst, -dx, -dy);
-    }
-
-    if (!fastClip) {
-        RegionIntersect(&rgnDst, &rgnDst, pGC->pCompositeClip);
-    }
-
-    /* Do bit blitting */
-    numRects = RegionNumRects(&rgnDst);
-    if (numRects && width && height) {
-        if (!(pptSrc = (DDXPointPtr) malloc(numRects * sizeof(DDXPointRec)))) {
-            RegionUninit(&rgnDst);
-            if (freeSrcClip)
-                RegionDestroy(prgnSrcClip);
-            return NULL;
-        }
-        pbox = RegionRects(&rgnDst);
-        ppt = pptSrc;
-        for (i = numRects; --i >= 0; pbox++, ppt++) {
-            ppt->x = pbox->x1 + dx;
-            ppt->y = pbox->y1 + dy;
-        }
-
-        (*doBitBlt) (pSrcDrawable, pDstDrawable, pGC, &rgnDst, pptSrc);
-        free(pptSrc);
-    }
-
-    prgnExposed = NULL;
-    if (pGC->fExpose) {
-        /* Pixmap sources generate a NoExposed (we return NULL to do this) */
-        if (!fastExpose)
-            prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
-                                            origSource.x, origSource.y,
-                                            (int) origSource.width,
-                                            (int) origSource.height,
-                                            origDest.x, origDest.y, bitPlane);
-    }
-    RegionUninit(&rgnDst);
-    if (freeSrcClip)
-        RegionDestroy(prgnSrcClip);
-    return prgnExposed;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaBitOrder.c b/xorg-server/hw/xfree86/xaa/xaaBitOrder.c
deleted file mode 100644
index 3d9b980e1..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaBitOrder.c
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/Xmd.h>
-#include "xaalocal.h"
-
-CARD32
-XAAReverseBitOrder(CARD32 v)
-{
-    return (((0x01010101 & v) << 7) | ((0x02020202 & v) << 5) |
-            ((0x04040404 & v) << 3) | ((0x08080808 & v) << 1) |
-            ((0x10101010 & v) >> 1) | ((0x20202020 & v) >> 3) |
-            ((0x40404040 & v) >> 5) | ((0x80808080 & v) >> 7));
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaBitmap.c b/xorg-server/hw/xfree86/xaa/xaaBitmap.c
deleted file mode 100644
index 45d5a09be..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaBitmap.c
+++ /dev/null
@@ -1,477 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaacexp.h"
-#include "xf86.h"
-
-/********** byte swapping ***************/
-
-#ifdef FIXEDBASE
-#define DEST(i)	*dest
-#define RETURN(i)	return(dest)
-#else
-#define DEST(i)	dest[i]
-#define RETURN(i)	return(dest + i)
-#endif
-
-#ifdef MSBFIRST
-#define SOURCE(i)	SWAP_BITS_IN_BYTES(src[i])
-#else
-#define SOURCE(i)	src[i]
-#endif
-
-typedef CARD32 *(*BitmapScanlineProcPtr) (CARD32 *, CARD32 *, int, int);
-
-#ifdef TRIPLE_BITS
-static CARD32 *
-BitmapScanline(CARD32 *src, CARD32 *base, int count, int skipleft)
-{
-    CARD32 bits;
-
-    while (count >= 3) {
-        bits = *src;
-        WRITE_BITS3(bits);
-        src++;
-        count -= 3;
-    }
-    if (count == 2) {
-        bits = *src;
-        WRITE_BITS2(bits);
-    }
-    else if (count == 1) {
-        bits = *src;
-        WRITE_BITS1(bits);
-    }
-
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Inverted(CARD32 *src, CARD32 *base, int count, int skipleft)
-{
-    CARD32 bits;
-
-    while (count >= 3) {
-        bits = ~(*src);
-        WRITE_BITS3(bits);
-        src++;
-        count -= 3;
-    }
-    if (count == 2) {
-        bits = ~(*src);
-        WRITE_BITS2(bits);
-    }
-    else if (count == 1) {
-        bits = ~(*src);
-        WRITE_BITS1(bits);
-    }
-
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Shifted(CARD32 *src, CARD32 *base, int count, int skipleft)
-{
-    CARD32 bits;
-
-    while (count >= 3) {
-        bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
-        WRITE_BITS3(bits);
-        src++;
-        count -= 3;
-    }
-    if (count == 2) {
-        bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
-        WRITE_BITS2(bits);
-    }
-    else if (count == 1) {
-        bits = SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft));
-        WRITE_BITS1(bits);
-    }
-
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Shifted_Inverted(CARD32 *src, CARD32 *base,
-                                int count, int skipleft)
-{
-    CARD32 bits;
-
-    while (count >= 3) {
-        bits =
-            ~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
-        WRITE_BITS3(bits);
-        src++;
-        count -= 3;
-    }
-    if (count == 2) {
-        bits =
-            ~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
-        WRITE_BITS2(bits);
-    }
-    else if (count == 1) {
-        bits =
-            ~(SHIFT_R(*src, skipleft) | SHIFT_L(*(src + 1), (32 - skipleft)));
-        WRITE_BITS1(bits);
-    }
-
-    return base;
-}
-
-#define BitmapScanline_Shifted_Careful BitmapScanline_Shifted
-#define BitmapScanline_Shifted_Inverted_Careful BitmapScanline_Shifted_Inverted
-
-#else
-static CARD32 *
-BitmapScanline(CARD32 *src, CARD32 *dest, int count, int skipleft)
-{
-    while (count >= 4) {
-        DEST(0) = SOURCE(0);
-        DEST(1) = SOURCE(1);
-        DEST(2) = SOURCE(2);
-        DEST(3) = SOURCE(3);
-        count -= 4;
-        src += 4;
-#ifndef FIXEDBASE
-        dest += 4;
-#endif
-    }
-
-    if (!count)
-        return dest;
-    DEST(0) = SOURCE(0);
-    if (count == 1)
-        RETURN(1);
-    DEST(1) = SOURCE(1);
-    if (count == 2)
-        RETURN(2);
-    DEST(2) = SOURCE(2);
-    RETURN(3);
-}
-
-static CARD32 *
-BitmapScanline_Inverted(CARD32 *src, CARD32 *dest, int count, int skipleft)
-{
-    while (count >= 4) {
-        DEST(0) = ~SOURCE(0);
-        DEST(1) = ~SOURCE(1);
-        DEST(2) = ~SOURCE(2);
-        DEST(3) = ~SOURCE(3);
-        count -= 4;
-        src += 4;
-#ifndef FIXEDBASE
-        dest += 4;
-#endif
-    }
-
-    if (!count)
-        return dest;
-    DEST(0) = ~SOURCE(0);
-    if (count == 1)
-        RETURN(1);
-    DEST(1) = ~SOURCE(1);
-    if (count == 2)
-        RETURN(2);
-    DEST(2) = ~SOURCE(2);
-    RETURN(3);
-}
-
-static CARD32 *
-BitmapScanline_Shifted(CARD32 *bits, CARD32 *base, int count, int skipleft)
-{
-    while (count--) {
-        register CARD32 tmp = SHIFT_R(*bits, skipleft) |
-            SHIFT_L(*(bits + 1), (32 - skipleft));
-        WRITE_BITS(tmp);
-        bits++;
-    }
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Shifted_Inverted(CARD32 *bits, CARD32 *base,
-                                int count, int skipleft)
-{
-    while (count--) {
-        register CARD32 tmp = ~(SHIFT_R(*bits, skipleft) |
-                                SHIFT_L(*(bits + 1), (32 - skipleft)));
-        WRITE_BITS(tmp);
-        bits++;
-    }
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Shifted_Careful(CARD32 *bits, CARD32 *base,
-                               int count, int skipleft)
-{
-    register CARD32 tmp;
-
-    while (--count) {
-        tmp = SHIFT_R(*bits, skipleft) | SHIFT_L(*(bits + 1), (32 - skipleft));
-        WRITE_BITS(tmp);
-        bits++;
-    }
-    tmp = SHIFT_R(*bits, skipleft);
-    WRITE_BITS(tmp);
-
-    return base;
-}
-
-static CARD32 *
-BitmapScanline_Shifted_Inverted_Careful(CARD32 *bits, CARD32 *base,
-                                        int count, int skipleft)
-{
-    register CARD32 tmp;
-
-    while (--count) {
-        tmp =
-            ~(SHIFT_R(*bits, skipleft) | SHIFT_L(*(bits + 1), (32 - skipleft)));
-        WRITE_BITS(tmp);
-        bits++;
-    }
-    tmp = ~(SHIFT_R(*bits, skipleft));
-    WRITE_BITS(tmp);
-    return base;
-}
-
-#endif
-
-/*  
-    When the accelerator is TRANSPARENCY_ONLY, WriteBitmap can do
-    the fill in two passes, inverting the source on the second pass.  
-    For GXcopy we can fill the backing rectangle as a solid rect and
-    avoid the invert.
-*/
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAWriteBitmapColorExpand3) (
-#else
- EXPNAME(XAAWriteBitmapColorExpand) (
-#endif
-                                        ScrnInfoPtr pScrn,
-                                        int x, int y, int w, int H,
-                                        unsigned char *src,
-                                        int srcwidth,
-                                        int skipleft,
-                                        int fg, int bg,
-                                        int rop, unsigned int planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    unsigned char *srcp = src;
-    int SecondPassColor = -1;
-    int shift = 0, dwords;
-    BitmapScanlineProcPtr firstFunc;
-    BitmapScanlineProcPtr secondFunc;
-    int flag;
-    int h = H;
-
-#ifdef TRIPLE_BITS
-    if ((bg != -1) &&
-        ((infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) ||
-         ((infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) &&
-          (!CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg != -1) &&
-        (infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        if ((rop == GXcopy) && infoRec->SetupForSolidFill) {
-            (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-            (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        }
-        else
-            SecondPassColor = bg;
-        bg = -1;
-    }
-
-#ifdef TRIPLE_BITS
-    if (skipleft) {
-#else
-    if (skipleft &&
-        (!(infoRec->CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING) ||
-         (!(infoRec->
-            CPUToScreenColorExpandFillFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
-          (skipleft > x)))) {
-#endif
-        if ((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
-            /* don't read past the end */
-            firstFunc = BitmapScanline_Shifted_Careful;
-            secondFunc = BitmapScanline_Shifted_Inverted_Careful;
-        }
-        else {
-            firstFunc = BitmapScanline_Shifted;
-            secondFunc = BitmapScanline_Shifted_Inverted;
-        }
-        shift = skipleft;
-        skipleft = 0;
-    }
-    else {
-        firstFunc = BitmapScanline;
-        secondFunc = BitmapScanline_Inverted;
-        w += skipleft;
-        x -= skipleft;
-    }
-
-#ifdef TRIPLE_BITS
-    dwords = (3 * w + 31) >> 5;
-#else
-    dwords = (w + 31) >> 5;
-#endif
-
- SECOND_PASS:
-
-    flag = (infoRec->CPUToScreenColorExpandFillFlags
-            & CPU_TRANSFER_PAD_QWORD) && ((dwords * h) & 0x01);
-    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                    planemask);
-    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
-                                                      skipleft);
-
-    base = (CARD32 *) infoRec->ColorExpandBase;
-
-#ifndef FIXEDBASE
-    if ((dwords * h) <= infoRec->ColorExpandRange)
-        while (h--) {
-            base = (*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
-            srcp += srcwidth;
-        }
-    else
-#endif
-        while (h--) {
-            (*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
-            srcp += srcwidth;
-        }
-
-    if (flag) {
-        base = (CARD32 *) infoRec->ColorExpandBase;
-        base[0] = 0x00000000;
-    }
-
-    if (SecondPassColor != -1) {
-        h = H;                  /* Reset height */
-        fg = SecondPassColor;
-        SecondPassColor = -1;
-        firstFunc = secondFunc;
-        srcp = src;
-        goto SECOND_PASS;
-    }
-
-    if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-#ifndef FIXEDBASE
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAWriteBitmapScanlineColorExpand3) (
-#else
- EXPNAME(XAAWriteBitmapScanlineColorExpand) (
-#endif
-                                                ScrnInfoPtr pScrn,
-                                                int x, int y, int w, int h,
-                                                unsigned char *src,
-                                                int srcwidth,
-                                                int skipleft,
-                                                int fg, int bg,
-                                                int rop,
-                                                unsigned int planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    unsigned char *srcp = src;
-    int SecondPassColor = -1;
-    int shift = 0, dwords, bufferNo;
-    BitmapScanlineProcPtr firstFunc;
-    BitmapScanlineProcPtr secondFunc;
-
-#ifdef TRIPLE_BITS
-    if ((bg != -1) &&
-        ((infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
-         || ((infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) &&
-             (!CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg != -1) &&
-        (infoRec->
-         ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        if ((rop == GXcopy) && infoRec->SetupForSolidFill) {
-            (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-            (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        }
-        else
-            SecondPassColor = bg;
-        bg = -1;
-    }
-
-#ifdef TRIPLE_BITS
-    if (skipleft) {
-#else
-    if (skipleft &&
-        (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-           LEFT_EDGE_CLIPPING) ||
-         (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-            LEFT_EDGE_CLIPPING_NEGATIVE_X) && (skipleft > x)))) {
-#endif
-        if ((skipleft + ((w + 31) & ~31)) > ((skipleft + w + 31) & ~31)) {
-            /* don't read past the end */
-            firstFunc = BitmapScanline_Shifted_Careful;
-            secondFunc = BitmapScanline_Shifted_Inverted_Careful;
-        }
-        else {
-            firstFunc = BitmapScanline_Shifted;
-            secondFunc = BitmapScanline_Shifted_Inverted;
-        }
-        shift = skipleft;
-        skipleft = 0;
-    }
-    else {
-        firstFunc = BitmapScanline;
-        secondFunc = BitmapScanline_Inverted;
-        w += skipleft;
-        x -= skipleft;
-    }
-
-#ifdef TRIPLE_BITS
-    dwords = (3 * w + 31) >> 5;
-#else
-    dwords = (w + 31) >> 5;
-#endif
-
- SECOND_PASS:
-
-    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                            planemask);
-    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
-                                                              skipleft);
-
-    bufferNo = 0;
-
-    while (h--) {
-        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-        (*firstFunc) ((CARD32 *) srcp, base, dwords, shift);
-        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-        srcp += srcwidth;
-        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-            bufferNo = 0;
-    }
-
-    if (SecondPassColor != -1) {
-        fg = SecondPassColor;
-        SecondPassColor = -1;
-        firstFunc = secondFunc;
-        srcp = src;
-        goto SECOND_PASS;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-#endif
diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyArea.c b/xorg-server/hw/xfree86/xaa/xaaCpyArea.c
deleted file mode 100644
index 0b11b810e..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaCpyArea.c
+++ /dev/null
@@ -1,409 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "migc.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-
-/*
-  Written mostly by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
- */
-
-RegionPtr
-XAACopyArea(DrawablePtr pSrcDrawable,
-            DrawablePtr pDstDrawable,
-            GC * pGC,
-            int srcx, int srcy, int width, int height, int dstx, int dsty)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (pDstDrawable->type == DRAWABLE_WINDOW) {
-        if ((pSrcDrawable->type == DRAWABLE_WINDOW) ||
-            IS_OFFSCREEN_PIXMAP(pSrcDrawable)) {
-            if (infoRec->ScreenToScreenBitBlt &&
-                CHECK_ROP(pGC, infoRec->ScreenToScreenBitBltFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->ScreenToScreenBitBltFlags) &&
-                CHECK_PLANEMASK(pGC, infoRec->ScreenToScreenBitBltFlags))
-                return (XAABitBlt(pSrcDrawable, pDstDrawable,
-                                  pGC, srcx, srcy, width, height, dstx, dsty,
-                                  XAADoBitBlt, 0L));
-        }
-        else {
-            if (infoRec->WritePixmap &&
-                ((pDstDrawable->bitsPerPixel == pSrcDrawable->bitsPerPixel) ||
-                 ((pDstDrawable->bitsPerPixel == 24) &&
-                  (pSrcDrawable->bitsPerPixel == 32) &&
-                  (infoRec->WritePixmapFlags & CONVERT_32BPP_TO_24BPP))) &&
-                CHECK_ROP(pGC, infoRec->WritePixmapFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->WritePixmapFlags) &&
-                CHECK_PLANEMASK(pGC, infoRec->WritePixmapFlags) &&
-                CHECK_NO_GXCOPY(pGC, infoRec->WritePixmapFlags))
-                return (XAABitBlt(pSrcDrawable, pDstDrawable,
-                                  pGC, srcx, srcy, width, height, dstx, dsty,
-                                  XAADoImageWrite, 0L));
-        }
-    }
-    else if (IS_OFFSCREEN_PIXMAP(pDstDrawable)) {
-        if ((pSrcDrawable->type == DRAWABLE_WINDOW) ||
-            IS_OFFSCREEN_PIXMAP(pSrcDrawable)) {
-            if (infoRec->ScreenToScreenBitBlt &&
-                CHECK_ROP(pGC, infoRec->ScreenToScreenBitBltFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->ScreenToScreenBitBltFlags) &&
-                CHECK_PLANEMASK(pGC, infoRec->ScreenToScreenBitBltFlags))
-                return (XAABitBlt(pSrcDrawable, pDstDrawable,
-                                  pGC, srcx, srcy, width, height, dstx, dsty,
-                                  XAADoBitBlt, 0L));
-        }
-    }
-
-    return (XAAFallbackOps.CopyArea(pSrcDrawable, pDstDrawable, pGC,
-                                    srcx, srcy, width, height, dstx, dsty));
-}
-
-void
-XAADoBitBlt(DrawablePtr pSrc,
-            DrawablePtr pDst, GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc)
-{
-    int nbox, careful;
-    BoxPtr pbox, pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
-    DDXPointPtr pptTmp, pptNew1, pptNew2;
-    int xdir, ydir;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    /* XXX we have to err on the side of safety when both are windows,
-     * because we don't know if IncludeInferiors is being used.
-     */
-    careful = ((pSrc == pDst) ||
-               ((pSrc->type == DRAWABLE_WINDOW) &&
-                (pDst->type == DRAWABLE_WINDOW)));
-
-    pbox = RegionRects(prgnDst);
-    nbox = RegionNumRects(prgnDst);
-
-    pboxNew1 = NULL;
-    pptNew1 = NULL;
-    pboxNew2 = NULL;
-    pptNew2 = NULL;
-    if (careful && (pptSrc->y < pbox->y1)) {
-        /* walk source botttom to top */
-        ydir = -1;
-
-        if (nbox > 1) {
-            /* keep ordering in each band, reverse order of bands */
-            pboxNew1 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
-            if (!pboxNew1)
-                return;
-            pptNew1 = (DDXPointPtr) malloc(sizeof(DDXPointRec) * nbox);
-            if (!pptNew1) {
-                free(pboxNew1);
-                return;
-            }
-            pboxBase = pboxNext = pbox + nbox - 1;
-            while (pboxBase >= pbox) {
-                while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1))
-                    pboxNext--;
-                pboxTmp = pboxNext + 1;
-                pptTmp = pptSrc + (pboxTmp - pbox);
-                while (pboxTmp <= pboxBase) {
-                    *pboxNew1++ = *pboxTmp++;
-                    *pptNew1++ = *pptTmp++;
-                }
-                pboxBase = pboxNext;
-            }
-            pboxNew1 -= nbox;
-            pbox = pboxNew1;
-            pptNew1 -= nbox;
-            pptSrc = pptNew1;
-        }
-    }
-    else {
-        /* walk source top to bottom */
-        ydir = 1;
-    }
-
-    if (careful && (pptSrc->x < pbox->x1)) {
-        /* walk source right to left */
-        xdir = -1;
-
-        if (nbox > 1) {
-            /* reverse order of rects in each band */
-            pboxNew2 = (BoxPtr) malloc(sizeof(BoxRec) * nbox);
-            pptNew2 = (DDXPointPtr) malloc(sizeof(DDXPointRec) * nbox);
-            if (!pboxNew2 || !pptNew2) {
-                free(pptNew2);
-                free(pboxNew2);
-                if (pboxNew1) {
-                    free(pptNew1);
-                    free(pboxNew1);
-                }
-                return;
-            }
-            pboxBase = pboxNext = pbox;
-            while (pboxBase < pbox + nbox) {
-                while ((pboxNext < pbox + nbox) &&
-                       (pboxNext->y1 == pboxBase->y1))
-                    pboxNext++;
-                pboxTmp = pboxNext;
-                pptTmp = pptSrc + (pboxTmp - pbox);
-                while (pboxTmp != pboxBase) {
-                    *pboxNew2++ = *--pboxTmp;
-                    *pptNew2++ = *--pptTmp;
-                }
-                pboxBase = pboxNext;
-            }
-            pboxNew2 -= nbox;
-            pbox = pboxNew2;
-            pptNew2 -= nbox;
-            pptSrc = pptNew2;
-        }
-    }
-    else {
-        /* walk source left to right */
-        xdir = 1;
-    }
-
-    (*infoRec->ScreenToScreenBitBlt) (infoRec->pScrn, nbox, pptSrc, pbox,
-                                      xdir, ydir, pGC->alu, pGC->planemask);
-
-    if (pboxNew2) {
-        free(pptNew2);
-        free(pboxNew2);
-    }
-    if (pboxNew1) {
-        free(pptNew1);
-        free(pboxNew1);
-    }
-
-}
-
-void
-XAADoImageWrite(DrawablePtr pSrc,
-                DrawablePtr pDst,
-                GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc)
-{
-    int srcwidth;
-    unsigned char *psrcBase;    /* start of image */
-    unsigned char *srcPntr;     /* index into the image */
-    BoxPtr pbox = RegionRects(prgnDst);
-    int nbox = RegionNumRects(prgnDst);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int Bpp = pSrc->bitsPerPixel >> 3;
-
-    psrcBase = (unsigned char *) ((PixmapPtr) pSrc)->devPrivate.ptr;
-    srcwidth = (int) ((PixmapPtr) pSrc)->devKind;
-
-    for (; nbox; pbox++, pptSrc++, nbox--) {
-        srcPntr = psrcBase + (pptSrc->y * srcwidth) + (pptSrc->x * Bpp);
-
-        (*infoRec->WritePixmap) (infoRec->pScrn, pbox->x1, pbox->y1,
-                                 pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
-                                 srcPntr, srcwidth, pGC->alu, pGC->planemask,
-                                 -1, pSrc->bitsPerPixel, pSrc->depth);
-    }
-}
-
-void
-XAADoImageRead(DrawablePtr pSrc,
-               DrawablePtr pDst,
-               GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc)
-{
-    int dstwidth;
-    unsigned char *pdstBase;    /* start of image */
-    unsigned char *dstPntr;     /* index into the image */
-    BoxPtr pbox = RegionRects(prgnDst);
-    int nbox = RegionNumRects(prgnDst);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int Bpp = pSrc->bitsPerPixel >> 3;  /* wouldn't get here unless both
-                                           src and dst have same bpp */
-
-    pdstBase = (unsigned char *) ((PixmapPtr) pDst)->devPrivate.ptr;
-    dstwidth = (int) ((PixmapPtr) pDst)->devKind;
-
-    for (; nbox; pbox++, pptSrc++, nbox--) {
-        dstPntr = pdstBase + (pbox->y1 * dstwidth) + (pbox->x1 * Bpp);
-
-        (*infoRec->ReadPixmap) (infoRec->pScrn, pptSrc->x, pptSrc->y,
-                                pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
-                                dstPntr, dstwidth, pSrc->bitsPerPixel,
-                                pSrc->depth);
-    }
-}
-
-void
-XAAScreenToScreenBitBlt(ScrnInfoPtr pScrn,
-                        int nbox,
-                        DDXPointPtr pptSrc,
-                        BoxPtr pbox,
-                        int xdir, int ydir, int alu, unsigned int planemask)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int dirsetup;
-
-    if ((!(infoRec->CopyAreaFlags & ONLY_TWO_BITBLT_DIRECTIONS)
-         || (xdir == ydir)) &&
-        (!(infoRec->CopyAreaFlags & ONLY_LEFT_TO_RIGHT_BITBLT)
-         || (xdir == 1))) {
-        (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                xdir, ydir, alu, planemask, -1);
-        for (; nbox; pbox++, pptSrc++, nbox--)
-            (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pptSrc->x,
-                                                      pptSrc->y, pbox->x1,
-                                                      pbox->y1,
-                                                      pbox->x2 - pbox->x1,
-                                                      pbox->y2 - pbox->y1);
-        SET_SYNC_FLAG(infoRec);
-        return;
-    }
-
-    if (infoRec->CopyAreaFlags & ONLY_LEFT_TO_RIGHT_BITBLT) {
-        /*
-         * This is the case of a chip that only supports xdir = 1,
-         * with ydir = 1 or ydir = -1, but we have xdir = -1.
-         */
-        (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                1, ydir, alu, planemask, -1);
-        for (; nbox; pbox++, pptSrc++, nbox--)
-            if (pptSrc->y != pbox->y1 || pptSrc->x >= pbox->x1)
-                /* No problem. Do a xdir = 1 blit instead. */
-                (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                          pptSrc->x, pptSrc->y,
-                                                          pbox->x1, pbox->y1,
-                                                          pbox->x2 - pbox->x1,
-                                                          pbox->y2 - pbox->y1);
-            else {
-                /*
-                 * This is the difficult case. Needs striping into
-                 * non-overlapping horizontal chunks.
-                 */
-                int stripeWidth, w, fullStripes, extra, i;
-
-                stripeWidth = 16;
-                w = pbox->x2 - pbox->x1;
-                if (pbox->x1 - pptSrc->x < stripeWidth)
-                    stripeWidth = pbox->x1 - pptSrc->x;
-                fullStripes = w / stripeWidth;
-                extra = w % stripeWidth;
-
-                /* First, take care of the little bit on the far right */
-                if (extra)
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pptSrc->x +
-                                                              fullStripes *
-                                                              stripeWidth,
-                                                              pptSrc->y,
-                                                              pbox->x1 +
-                                                              fullStripes *
-                                                              stripeWidth,
-                                                              pbox->y1, extra,
-                                                              pbox->y2 -
-                                                              pbox->y1);
-
-                /* Now, take care of the rest of the blit */
-                for (i = fullStripes - 1; i >= 0; i--)
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pptSrc->x +
-                                                              i * stripeWidth,
-                                                              pptSrc->y,
-                                                              pbox->x1 +
-                                                              i * stripeWidth,
-                                                              pbox->y1,
-                                                              stripeWidth,
-                                                              pbox->y2 -
-                                                              pbox->y1);
-            }
-        SET_SYNC_FLAG(infoRec);
-        return;
-    }
-
-    /*
-     * Now the case of a chip that only supports xdir = ydir = 1 or
-     * xdir = ydir = -1, but we have xdir != ydir.
-     */
-    dirsetup = 0;               /* No direction set up yet. */
-    for (; nbox; pbox++, pptSrc++, nbox--) {
-        if (xdir == 1 && pptSrc->y != pbox->y1) {
-            /* Do a xdir = ydir = -1 blit instead. */
-            if (dirsetup != -1) {
-                (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                        -1, -1, alu, planemask,
-                                                        -1);
-                dirsetup = -1;
-            }
-            (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pptSrc->x,
-                                                      pptSrc->y, pbox->x1,
-                                                      pbox->y1,
-                                                      pbox->x2 - pbox->x1,
-                                                      pbox->y2 - pbox->y1);
-        }
-        else if (xdir == -1 && pptSrc->y != pbox->y1) {
-            /* Do a xdir = ydir = 1 blit instead. */
-            if (dirsetup != 1) {
-                (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                        1, 1, alu, planemask,
-                                                        -1);
-                dirsetup = 1;
-            }
-            (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pptSrc->x,
-                                                      pptSrc->y, pbox->x1,
-                                                      pbox->y1,
-                                                      pbox->x2 - pbox->x1,
-                                                      pbox->y2 - pbox->y1);
-        }
-        else if (xdir == 1) {
-            /*
-             * xdir = 1, ydir = -1.
-             * Perform line-by-line xdir = ydir = 1 blits, going up.
-             */
-            int i;
-
-            if (dirsetup != 1) {
-                (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                        1, 1, alu, planemask,
-                                                        -1);
-                dirsetup = 1;
-            }
-            for (i = pbox->y2 - pbox->y1 - 1; i >= 0; i--)
-                (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                          pptSrc->x,
-                                                          pptSrc->y + i,
-                                                          pbox->x1,
-                                                          pbox->y1 + i,
-                                                          pbox->x2 - pbox->x1,
-                                                          1);
-        }
-        else {
-            /*
-             * xdir = -1, ydir = 1.
-             * Perform line-by-line xdir = ydir = -1 blits, going down.
-             */
-            int i;
-
-            if (dirsetup != -1) {
-                (*infoRec->SetupForScreenToScreenCopy) (pScrn,
-                                                        -1, -1, alu, planemask,
-                                                        -1);
-                dirsetup = -1;
-            }
-            for (i = 0; i < pbox->y2 - pbox->y1; i++)
-                (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                          pptSrc->x,
-                                                          pptSrc->y + i,
-                                                          pbox->x1,
-                                                          pbox->y1 + i,
-                                                          pbox->x2 - pbox->x1,
-                                                          1);
-        }
-    }                           /* next box */
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c b/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c
deleted file mode 100644
index b9197e41f..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaCpyPlane.c
+++ /dev/null
@@ -1,204 +0,0 @@
-
-/*
-   A CopyPlane function that handles bitmap->screen copies and
-   sends anything else to the Fallback.
-
-   Also, a PushPixels for solid fill styles.
-
-   Written by Mark Vojkovich (markv@valinux.com)
-
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-#include "servermd.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "mi.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-
-static void XAACopyPlane1toNColorExpand(DrawablePtr pSrc, DrawablePtr pDst,
-                                        GCPtr pGC, RegionPtr rgnDst,
-                                        DDXPointPtr pptSrc);
-static void XAACopyPlaneNtoNColorExpand(DrawablePtr pSrc, DrawablePtr pDst,
-                                        GCPtr pGC, RegionPtr rgnDst,
-                                        DDXPointPtr pptSrc);
-
-static unsigned long TmpBitPlane;
-
-RegionPtr
-XAACopyPlaneColorExpansion(DrawablePtr pSrc,
-                           DrawablePtr pDst,
-                           GCPtr pGC,
-                           int srcx, int srcy,
-                           int width, int height,
-                           int dstx, int dsty, unsigned long bitPlane)
-{
-    if ((pSrc->type == DRAWABLE_PIXMAP) && !XAA_DEPTH_BUG(pGC)) {
-        if (pSrc->bitsPerPixel == 1) {
-            return (XAABitBlt(pSrc, pDst, pGC, srcx, srcy,
-                              width, height, dstx, dsty,
-                              XAACopyPlane1toNColorExpand, bitPlane));
-        }
-        else if (bitPlane < (1 << pDst->depth)) {
-            TmpBitPlane = bitPlane;
-            return (XAABitBlt(pSrc, pDst, pGC, srcx, srcy,
-                              width, height, dstx, dsty,
-                              XAACopyPlaneNtoNColorExpand, bitPlane));
-        }
-    }
-
-    return (XAAFallbackOps.CopyPlane(pSrc, pDst, pGC, srcx, srcy,
-                                     width, height, dstx, dsty, bitPlane));
-}
-
-static void
-XAACopyPlane1toNColorExpand(DrawablePtr pSrc,
-                            DrawablePtr pDst,
-                            GCPtr pGC, RegionPtr rgnDst, DDXPointPtr pptSrc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr pbox = RegionRects(rgnDst);
-    int numrects = RegionNumRects(rgnDst);
-    unsigned char *src = ((PixmapPtr) pSrc)->devPrivate.ptr;
-    int srcwidth = ((PixmapPtr) pSrc)->devKind;
-
-    while (numrects--) {
-        (*infoRec->WriteBitmap) (infoRec->pScrn, pbox->x1, pbox->y1,
-                                 pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
-                                 src + (srcwidth * pptSrc->y) +
-                                 ((pptSrc->x >> 5) << 2), srcwidth,
-                                 pptSrc->x & 31, pGC->fgPixel, pGC->bgPixel,
-                                 pGC->alu, pGC->planemask);
-        pbox++;
-        pptSrc++;
-    }
-}
-
-static void
-XAACopyPlaneNtoNColorExpand(DrawablePtr pSrc,
-                            DrawablePtr pDst,
-                            GCPtr pGC, RegionPtr rgnDst, DDXPointPtr pptSrc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr pbox = RegionRects(rgnDst);
-    int numrects = RegionNumRects(rgnDst);
-    unsigned char *src = ((PixmapPtr) pSrc)->devPrivate.ptr;
-    unsigned char *data, *srcPtr, *dataPtr;
-    int srcwidth = ((PixmapPtr) pSrc)->devKind;
-    int pitch, width, height, h, i, index, offset;
-    int Bpp = pSrc->bitsPerPixel >> 3;
-    unsigned long mask = TmpBitPlane;
-
-    if (TmpBitPlane < (1 << 8)) {
-        offset = 0;
-    }
-    else if (TmpBitPlane < (1 << 16)) {
-        offset = 1;
-        mask >>= 8;
-    }
-    else if (TmpBitPlane < (1 << 24)) {
-        offset = 2;
-        mask >>= 16;
-    }
-    else {
-        offset = 3;
-        mask >>= 24;
-    }
-
-    if (IS_OFFSCREEN_PIXMAP(pSrc))
-        SYNC_CHECK(pSrc);
-
-    while (numrects--) {
-        width = pbox->x2 - pbox->x1;
-        h = height = pbox->y2 - pbox->y1;
-        pitch = BitmapBytePad(width);
-
-        if (!(data = calloc(height, pitch)))
-            goto ALLOC_FAILED;
-
-        dataPtr = data;
-        srcPtr = ((pptSrc->y) * srcwidth) + src + ((pptSrc->x) * Bpp) + offset;
-
-        while (h--) {
-            for (i = index = 0; i < width; i++, index += Bpp) {
-                if (mask & srcPtr[index])
-                    dataPtr[i >> 3] |= (1 << (i & 7));
-            }
-            dataPtr += pitch;
-            srcPtr += srcwidth;
-        }
-
-        (*infoRec->WriteBitmap) (infoRec->pScrn,
-                                 pbox->x1, pbox->y1, width, height, data, pitch,
-                                 0, pGC->fgPixel, pGC->bgPixel, pGC->alu,
-                                 pGC->planemask);
-
-        free(data);
-
- ALLOC_FAILED:
-
-        pbox++;
-        pptSrc++;
-    }
-}
-
-void
-XAAPushPixelsSolidColorExpansion(GCPtr pGC,
-                                 PixmapPtr pBitMap,
-                                 DrawablePtr pDraw,
-                                 int dx, int dy, int xOrg, int yOrg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int MaxBoxes = RegionNumRects(pGC->pCompositeClip);
-    BoxPtr pbox, pClipBoxes;
-    int nboxes, srcx, srcy;
-    xRectangle TheRect;
-    unsigned char *src = pBitMap->devPrivate.ptr;
-    int srcwidth = pBitMap->devKind;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    TheRect.x = xOrg;
-    TheRect.y = yOrg;
-    TheRect.width = dx;
-    TheRect.height = dy;
-
-    if (MaxBoxes > (infoRec->PreAllocSize / sizeof(BoxRec))) {
-        pClipBoxes = malloc(MaxBoxes * sizeof(BoxRec));
-        if (!pClipBoxes)
-            return;
-    }
-    else
-        pClipBoxes = (BoxPtr) infoRec->PreAllocMem;
-
-    nboxes = XAAGetRectClipBoxes(pGC, pClipBoxes, 1, &TheRect);
-    pbox = pClipBoxes;
-
-    while (nboxes--) {
-        srcx = pbox->x1 - xOrg;
-        srcy = pbox->y1 - yOrg;
-        (*infoRec->WriteBitmap) (infoRec->pScrn, pbox->x1, pbox->y1,
-                                 pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
-                                 src + (srcwidth * srcy) + ((srcx >> 5) << 2),
-                                 srcwidth, srcx & 31,
-                                 pGC->fgPixel, -1, pGC->alu, pGC->planemask);
-        pbox++;
-    }
-
-    if (pClipBoxes != (BoxPtr) infoRec->PreAllocMem)
-        free(pClipBoxes);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaCpyWin.c b/xorg-server/hw/xfree86/xaa/xaaCpyWin.c
deleted file mode 100644
index e851f4a37..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaCpyWin.c
+++ /dev/null
@@ -1,78 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "xaawrap.h"
-
-/*
-    Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
-*/
-
-void
-XAACopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
-    DDXPointPtr pptSrc, ppt;
-    RegionRec rgnDst;
-    BoxPtr pbox;
-    int dx, dy, nbox;
-    WindowPtr pwinRoot;
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
-
-    if (!infoRec->pScrn->vtSema || !infoRec->ScreenToScreenBitBlt) {
-        XAA_SCREEN_PROLOGUE(pScreen, CopyWindow);
-        if (infoRec->pScrn->vtSema && infoRec->NeedToSync) {
-            (*infoRec->Sync) (infoRec->pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-        (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
-        XAA_SCREEN_EPILOGUE(pScreen, CopyWindow, XAACopyWindow);
-        return;
-    }
-
-    pwinRoot = pScreen->root;
-
-    RegionNull(&rgnDst);
-
-    dx = ptOldOrg.x - pWin->drawable.x;
-    dy = ptOldOrg.y - pWin->drawable.y;
-    RegionTranslate(prgnSrc, -dx, -dy);
-    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
-
-    pbox = RegionRects(&rgnDst);
-    nbox = RegionNumRects(&rgnDst);
-    if (!nbox || !(pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec)))) {
-        RegionUninit(&rgnDst);
-        return;
-    }
-    ppt = pptSrc;
-
-    while (nbox--) {
-        ppt->x = pbox->x1 + dx;
-        ppt->y = pbox->y1 + dy;
-        ppt++;
-        pbox++;
-    }
-
-    infoRec->ScratchGC.planemask = ~0L;
-    infoRec->ScratchGC.alu = GXcopy;
-
-    XAADoBitBlt((DrawablePtr) pwinRoot, (DrawablePtr) pwinRoot,
-                &(infoRec->ScratchGC), &rgnDst, pptSrc);
-
-    free(pptSrc);
-    RegionUninit(&rgnDst);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaDashLine.c b/xorg-server/hw/xfree86/xaa/xaaDashLine.c
deleted file mode 100644
index c7e52cd0b..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaDashLine.c
+++ /dev/null
@@ -1,353 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include <X11/X.h>
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "miline.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-void
-#ifdef POLYSEGMENT
- XAAPolySegmentDashed(DrawablePtr pDrawable,
-                      GCPtr pGC, int nseg, xSegment * pSeg
-#else
-XAAPolyLinesDashed(DrawablePtr pDrawable, GCPtr pGC, int mode,  /* Origin or Previous */
-                   int npt,     /* number of points */
-                   DDXPointPtr pptInit
-#endif
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
-                                                   XAAGetGCKey());
-    BoxPtr pboxInit = RegionRects(pGC->pCompositeClip);
-    int nboxInit = RegionNumRects(pGC->pCompositeClip);
-    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
-    int xorg = pDrawable->x;
-    int yorg = pDrawable->y;
-    int nbox;
-    BoxPtr pbox;
-
-#ifndef POLYSEGMENT
-    DDXPointPtr ppt;
-#endif
-    unsigned int oc1, oc2;
-    int dmin, dmaj, e, octant;
-    int x1, x2, y1, y2, tmp, len, offset;
-    int PatternLength, PatternOffset;
-
-    if (!nboxInit)
-        return;
-
-    if (infoRec->DashedLineFlags & LINE_LIMIT_COORDS) {
-        int minValX = infoRec->DashedLineLimits.x1;
-        int maxValX = infoRec->DashedLineLimits.x2;
-        int minValY = infoRec->DashedLineLimits.y1;
-        int maxValY = infoRec->DashedLineLimits.y2;
-
-#ifdef POLYSEGMENT
-        int n = nseg;
-        xSegment *s = pSeg;
-
-        while (n--)
-#else
-        int n = npt;
-        int xorgtmp = xorg;
-        int yorgtmp = yorg;
-
-        ppt = pptInit;
-        x2 = ppt->x + xorgtmp;
-        y2 = ppt->y + yorgtmp;
-        while (--n)
-#endif
-        {
-#ifdef POLYSEGMENT
-            x1 = s->x1 + xorg;
-            y1 = s->y1 + yorg;
-            x2 = s->x2 + xorg;
-            y2 = s->y2 + yorg;
-            s++;
-#else
-            x1 = x2;
-            y1 = y2;
-            ++ppt;
-            if (mode == CoordModePrevious) {
-                xorgtmp = x1;
-                yorgtmp = y1;
-            }
-            x2 = ppt->x + xorgtmp;
-            y2 = ppt->y + yorgtmp;
-#endif
-            if (x1 > maxValX || x1 < minValX ||
-                x2 > maxValX || x2 < minValX ||
-                y1 > maxValY || y1 < minValY || y2 > maxValY || y2 < minValY) {
-#ifdef POLYSEGMENT
-                XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);
-#else
-                XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);
-#endif
-                return;
-            }
-        }
-    }
-
-    PatternLength = pGCPriv->DashLength;
-    PatternOffset = pGC->dashOffset % PatternLength;
-
-    (*infoRec->SetupForDashedLine) (infoRec->pScrn, pGC->fgPixel,
-                                    (pGC->lineStyle ==
-                                     LineDoubleDash) ? pGC->bgPixel : -1,
-                                    pGC->alu, pGC->planemask, PatternLength,
-                                    pGCPriv->DashPattern);
-
-#ifdef POLYSEGMENT
-    while (nseg--)
-#else
-    ppt = pptInit;
-    x2 = ppt->x + xorg;
-    y2 = ppt->y + yorg;
-    while (--npt)
-#endif
-    {
-        nbox = nboxInit;
-        pbox = pboxInit;
-
-#ifdef POLYSEGMENT
-        x1 = pSeg->x1 + xorg;
-        y1 = pSeg->y1 + yorg;
-        x2 = pSeg->x2 + xorg;
-        y2 = pSeg->y2 + yorg;
-        pSeg++;
-#else
-        x1 = x2;
-        y1 = y2;
-        ++ppt;
-        if (mode == CoordModePrevious) {
-            xorg = x1;
-            yorg = y1;
-        }
-        x2 = ppt->x + xorg;
-        y2 = ppt->y + yorg;
-#endif
-
-        if (infoRec->SubsequentDashedBresenhamLine) {
-            if ((dmaj = x2 - x1) < 0) {
-                dmaj = -dmaj;
-                octant = XDECREASING;
-            }
-            else
-                octant = 0;
-
-            if ((dmin = y2 - y1) < 0) {
-                dmin = -dmin;
-                octant |= YDECREASING;
-            }
-
-            if (dmin >= dmaj) {
-                tmp = dmin;
-                dmin = dmaj;
-                dmaj = tmp;
-                octant |= YMAJOR;
-            }
-
-            e = -dmaj - ((bias >> octant) & 1);
-            len = dmaj;
-            dmin <<= 1;
-            dmaj <<= 1;
-        }
-        else {                  /* Muffle compiler */
-            dmin = dmaj = e = octant = len = 0;
-        }
-
-        while (nbox--) {
-            oc1 = oc2 = 0;
-            OUTCODES(oc1, x1, y1, pbox);
-            OUTCODES(oc2, x2, y2, pbox);
-            if (!(oc1 | oc2)) { /* uncliped */
-                if (infoRec->SubsequentDashedTwoPointLine) {
-                    (*infoRec->SubsequentDashedTwoPointLine) (infoRec->pScrn,
-                                                              x1, y1, x2, y2,
-#ifdef POLYSEGMENT
-                                                              (pGC->capStyle !=
-                                                               CapNotLast) ? 0 :
-#endif
-                                                              OMIT_LAST,
-                                                              PatternOffset);
-                }
-                else {
-                    (*infoRec->SubsequentDashedBresenhamLine) (infoRec->pScrn,
-                                                               x1, y1, dmaj,
-                                                               dmin, e,
-#ifdef POLYSEGMENT
-                                                               (pGC->capStyle !=
-                                                                CapNotLast)
-                                                               ? (len + 1) :
-#endif
-                                                               len, octant,
-                                                               PatternOffset);
-                }
-                break;
-            }
-            else if (oc1 & oc2) {       /* completely clipped */
-                pbox++;
-            }
-            else if (infoRec->ClippingFlags & HARDWARE_CLIP_DASHED_LINE) {
-                (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                                  pbox->x1, pbox->y1,
-                                                  pbox->x2 - 1, pbox->y2 - 1);
-
-                if (infoRec->SubsequentDashedBresenhamLine) {
-                    (*infoRec->SubsequentDashedBresenhamLine) (infoRec->pScrn,
-                                                               x1, y1, dmaj,
-                                                               dmin, e,
-#ifdef POLYSEGMENT
-                                                               (pGC->capStyle !=
-                                                                CapNotLast)
-                                                               ? (len + 1) :
-#endif
-                                                               len, octant,
-                                                               PatternOffset);
-                }
-                else {
-                    (*infoRec->SubsequentDashedTwoPointLine) (infoRec->pScrn,
-                                                              x1, y1, x2, y2,
-#ifdef POLYSEGMENT
-                                                              (pGC->capStyle !=
-                                                               CapNotLast) ? 0 :
-#endif
-                                                              OMIT_LAST,
-                                                              PatternOffset);
-                }
-                (*infoRec->DisableClipping) (infoRec->pScrn);
-                pbox++;
-            }
-            else {
-                int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
-                int clip1 = 0, clip2 = 0;
-                int err, adx, ady;
-
-                if (octant & YMAJOR) {
-                    ady = dmaj >> 1;
-                    adx = dmin >> 1;
-                }
-                else {
-                    ady = dmin >> 1;
-                    adx = dmaj >> 1;
-                }
-
-                if (miZeroClipLine(pbox->x1, pbox->y1,
-                                   pbox->x2 - 1, pbox->y2 - 1,
-                                   &new_x1, &new_y1, &new_x2, &new_y2,
-                                   adx, ady, &clip1, &clip2,
-                                   octant, bias, oc1, oc2) == -1) {
-                    pbox++;
-                    continue;
-                }
-
-                if (octant & YMAJOR)
-                    len = abs(new_y2 - new_y1);
-                else
-                    len = abs(new_x2 - new_x1);
-#ifdef POLYSEGMENT
-                if (clip2 != 0 || pGC->capStyle != CapNotLast)
-                    len++;
-#else
-                len += (clip2 != 0);
-#endif
-                if (len) {
-                    int abserr, clipdx, clipdy;
-
-                    /* unwind bresenham error term to first point */
-                    if (clip1) {
-                        clipdx = abs(new_x1 - x1);
-                        clipdy = abs(new_y1 - y1);
-
-                        if (octant & YMAJOR)
-                            err = e + clipdy * dmin - clipdx * dmaj;
-                        else
-                            err = e + clipdx * dmin - clipdy * dmaj;
-                    }
-                    else
-                        err = e;
-
-#define range infoRec->DashedBresenhamLineErrorTermBits
-                    abserr = abs(err);
-                    while ((abserr & range) || (dmaj & range) || (dmin & range)) {
-                        dmin >>= 1;
-                        dmaj >>= 1;
-                        abserr >>= 1;
-                        err /= 2;
-                    }
-
-                    if (octant & YMAJOR)
-                        offset = abs(new_y1 - y1);
-                    else
-                        offset = abs(new_x1 - x1);
-
-                    offset += PatternOffset;
-                    offset %= PatternLength;
-
-                    (*infoRec->SubsequentDashedBresenhamLine) (infoRec->pScrn,
-                                                               new_x1, new_y1,
-                                                               dmaj, dmin, err,
-                                                               len, octant,
-                                                               offset);
-                }
-                pbox++;
-            }
-        }                       /* while (nbox--) */
-#ifndef POLYSEGMENT
-        len = abs(y2 - y1);
-        tmp = abs(x2 - x1);
-        PatternOffset += (len > tmp) ? len : tmp;
-        PatternOffset %= PatternLength;
-#endif
-    }                           /* while (nline--) */
-
-#ifndef POLYSEGMENT
-    /* paint the last point if the end style isn't CapNotLast.
-       (Assume that a projecting, butt, or round cap that is one
-       pixel wide is the same as the single pixel of the endpoint.)
-     */
-
-    if ((pGC->capStyle != CapNotLast) &&
-        ((ppt->x + xorg != pptInit->x + pDrawable->x) ||
-         (ppt->y + yorg != pptInit->y + pDrawable->y) ||
-         (ppt == pptInit + 1))) {
-        nbox = nboxInit;
-        pbox = pboxInit;
-        while (nbox--) {
-            if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&
-                (x2 < pbox->x2) && (y2 < pbox->y2)) {
-                if (infoRec->SubsequentDashedTwoPointLine) {
-                    (*infoRec->SubsequentDashedTwoPointLine) (infoRec->pScrn,
-                                                              x2, y2, x2, y2, 0,
-                                                              PatternOffset);
-                }
-                else {
-                    (*infoRec->SubsequentDashedBresenhamLine) (infoRec->pScrn,
-                                                               x2, y2, 2, 0, -1,
-                                                               1, 0,
-                                                               PatternOffset);
-                }
-                break;
-            }
-            else
-                pbox++;
-        }
-    }
-#endif
-
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaFallback.c b/xorg-server/hw/xfree86/xaa/xaaFallback.c
deleted file mode 100644
index f7604ef90..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaFallback.c
+++ /dev/null
@@ -1,281 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "xaawrap.h"
-
-static void
-XAAFillSpansFallback(DrawablePtr pDraw,
-                     GC * pGC,
-                     int nInit,
-                     DDXPointPtr pptInit, int *pwidthInit, int fSorted)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->FillSpans) (pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAASetSpansFallback(DrawablePtr pDraw,
-                    GCPtr pGC,
-                    char *pcharsrc,
-                    register DDXPointPtr ppt,
-                    int *pwidth, int nspans, int fSorted)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->SetSpans) (pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPutImageFallback(DrawablePtr pDraw,
-                    GCPtr pGC,
-                    int depth,
-                    int x, int y, int w, int h,
-                    int leftPad, int format, char *pImage)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
-                           leftPad, format, pImage);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static RegionPtr
-XAACopyAreaFallback(DrawablePtr pSrc,
-                    DrawablePtr pDst,
-                    GC * pGC,
-                    int srcx, int srcy,
-                    int width, int height, int dstx, int dsty)
-{
-    RegionPtr ret;
-
-    XAA_GC_OP_PROLOGUE(pGC);
-    if ((pSrc->type == DRAWABLE_WINDOW) || (pDst->type == DRAWABLE_WINDOW) ||
-        IS_OFFSCREEN_PIXMAP(pSrc) || IS_OFFSCREEN_PIXMAP(pDst)) {
-        SYNC_CHECK(pGC);
-    }
-    ret = (*pGC->ops->CopyArea) (pSrc, pDst,
-                                 pGC, srcx, srcy, width, height, dstx, dsty);
-    XAA_GC_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static RegionPtr
-XAACopyPlaneFallback(DrawablePtr pSrc,
-                     DrawablePtr pDst,
-                     GCPtr pGC,
-                     int srcx, int srcy,
-                     int width, int height,
-                     int dstx, int dsty, unsigned long bitPlane)
-{
-    RegionPtr ret;
-
-    XAA_GC_OP_PROLOGUE(pGC);
-    if ((pSrc->type == DRAWABLE_WINDOW) || (pDst->type == DRAWABLE_WINDOW) ||
-        IS_OFFSCREEN_PIXMAP(pSrc) || IS_OFFSCREEN_PIXMAP(pDst)) {
-        SYNC_CHECK(pGC);
-    }
-    ret = (*pGC->ops->CopyPlane) (pSrc, pDst,
-                                  pGC, srcx, srcy, width, height, dstx, dsty,
-                                  bitPlane);
-    XAA_GC_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static void
-XAAPolyPointFallback(DrawablePtr pDraw,
-                     GCPtr pGC, int mode, int npt, xPoint * pptInit)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyPoint) (pDraw, pGC, mode, npt, pptInit);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolylinesFallback(DrawablePtr pDraw,
-                     GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->Polylines) (pDraw, pGC, mode, npt, pptInit);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolySegmentFallback(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment * pSeg)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolySegment) (pDraw, pGC, nseg, pSeg);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyRectangleFallback(DrawablePtr pDraw,
-                         GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyRectangle) (pDraw, pGC, nRectsInit, pRectsInit);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyArcFallback(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyArc) (pDraw, pGC, narcs, parcs);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAFillPolygonFallback(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyFillRectFallback(DrawablePtr pDraw,
-                        GCPtr pGC, int nrectFill, xRectangle *prectInit)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyFillArcFallback(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, parcs);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static int
-XAAPolyText8Fallback(DrawablePtr pDraw,
-                     GCPtr pGC, int x, int y, int count, char *chars)
-{
-    int ret;
-
-    XAA_GC_OP_PROLOGUE(pGC);
-    SYNC_CHECK(pGC);
-    ret = (*pGC->ops->PolyText8) (pDraw, pGC, x, y, count, chars);
-    XAA_GC_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static int
-XAAPolyText16Fallback(DrawablePtr pDraw,
-                      GCPtr pGC, int x, int y, int count, unsigned short *chars)
-{
-    int ret;
-
-    XAA_GC_OP_PROLOGUE(pGC);
-    SYNC_CHECK(pGC);
-    ret = (*pGC->ops->PolyText16) (pDraw, pGC, x, y, count, chars);
-    XAA_GC_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static void
-XAAImageText8Fallback(DrawablePtr pDraw,
-                      GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->ImageText8) (pDraw, pGC, x, y, count, chars);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAImageText16Fallback(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int x, int y, int count, unsigned short *chars)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->ImageText16) (pDraw, pGC, x, y, count, chars);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAImageGlyphBltFallback(DrawablePtr pDraw,
-                         GCPtr pGC,
-                         int xInit, int yInit,
-                         unsigned int nglyph,
-                         CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->ImageGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                                pglyphBase);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyGlyphBltFallback(DrawablePtr pDraw,
-                        GCPtr pGC,
-                        int xInit, int yInit,
-                        unsigned int nglyph,
-                        CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PolyGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                               pglyphBase);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPushPixelsFallback(GCPtr pGC,
-                      PixmapPtr pBitMap,
-                      DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
-{
-    XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC);
-    SYNC_CHECK(pGC);
-    (*pGC->ops->PushPixels) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
-    XAA_GC_OP_EPILOGUE(pGC);
-}
-
-GCOps XAAFallbackOps = {
-    XAAFillSpansFallback, XAASetSpansFallback,
-    XAAPutImageFallback, XAACopyAreaFallback,
-    XAACopyPlaneFallback, XAAPolyPointFallback,
-    XAAPolylinesFallback, XAAPolySegmentFallback,
-    XAAPolyRectangleFallback, XAAPolyArcFallback,
-    XAAFillPolygonFallback, XAAPolyFillRectFallback,
-    XAAPolyFillArcFallback, XAAPolyText8Fallback,
-    XAAPolyText16Fallback, XAAImageText8Fallback,
-    XAAImageText16Fallback, XAAImageGlyphBltFallback,
-    XAAPolyGlyphBltFallback, XAAPushPixelsFallback,
-};
-
-GCOps *
-XAAGetFallbackOps(void)
-{
-    return &XAAFallbackOps;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaFillArc.c b/xorg-server/hw/xfree86/xaa/xaaFillArc.c
deleted file mode 100644
index fb7e7201f..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaFillArc.c
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright 1996  The XFree86 Project
- *
- * 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 
- * HARM HANEMAAYER 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.
- * 
- * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
- */
-
-/*
- * Filled solid arcs, based on cfbfillarc.c.
- *
- * Fill arc using calls to low-level span fill. Because the math for
- * each span can be done concurrently with the drawing of the span
- * with a graphics coprocessor operation, this is faster than just
- * using miPolyFillArc, which first calculates all the spans and then
- * calls FillSpans.
- *
- * Clipped arcs are dispatched to FillSpans.
- */
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <limits.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "mifillarc.h"
-#include "mi.h"
-
-/*
- * This is based on the integer-math versions from mi. Perhaps on a
- * Pentium, the floating-point (double)-math version is faster.
- */
-
-static void
-XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc * arc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    register int x, y, e;
-    int yk, xk, ym, xm, dx, dy, xorg, yorg;
-    int slw;
-    miFillArcRec info;
-
-    (*infoRec->SetupForSolidFill) (infoRec->pScrn, pGC->fgPixel, pGC->alu,
-                                   pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    MIFILLARCSETUP();
-    if (pGC->miTranslate) {
-        xorg += pDraw->x;
-        yorg += pDraw->y;
-    }
-    while (y > 0) {
-        MIFILLARCSTEP(slw);
-        if (slw > 0) {
-            (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn, xorg - x,
-                                                 yorg - y, slw, 1);
-            if (miFillArcLower(slw))
-                (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn,
-                                                     xorg - x, yorg + y + dy,
-                                                     slw, 1);
-        }
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-#define ADDSPAN(l,r) \
-    if (r >= l) \
-	(*infoRec->SubsequentSolidFillRect)( \
-	    infoRec->pScrn, l, ya, r - l + 1, 1);
-
-#define ADDSLICESPANS(flip) \
-    if (!flip) \
-    { \
-	ADDSPAN(xl, xr); \
-    } \
-    else \
-    { \
-	xc = xorg - x; \
-	ADDSPAN(xc, xr); \
-	xc += slw - 1; \
-	ADDSPAN(xl, xc); \
-    }
-
-static void
-XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc * arc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
-    register int x, y, e;
-    miFillArcRec info;
-    miArcSliceRec slice;
-    int ya, xl, xr, xc;
-
-    (*infoRec->SetupForSolidFill) (infoRec->pScrn, pGC->fgPixel, pGC->alu,
-                                   pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    miFillArcSliceSetup(arc, &slice, pGC);
-    MIFILLARCSETUP();
-    slw = arc->height;
-    if (slice.flip_top || slice.flip_bot)
-        slw += (arc->height >> 1) + 1;
-    if (pGC->miTranslate) {
-        xorg += pDraw->x;
-        yorg += pDraw->y;
-        slice.edge1.x += pDraw->x;
-        slice.edge2.x += pDraw->x;
-    }
-    while (y > 0) {
-        MIFILLARCSTEP(slw);
-        MIARCSLICESTEP(slice.edge1);
-        MIARCSLICESTEP(slice.edge2);
-        if (miFillSliceUpper(slice)) {
-            ya = yorg - y;
-            MIARCSLICEUPPER(xl, xr, slice, slw);
-
-            ADDSLICESPANS(slice.flip_top);
-        }
-        if (miFillSliceLower(slice)) {
-            ya = yorg + y + dy;
-            MIARCSLICELOWER(xl, xr, slice, slw);
-            ADDSLICESPANS(slice.flip_bot);
-        }
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    register xArc *arc;
-    register int i;
-    int x2, y2;
-    BoxRec box;
-    RegionPtr cclip;
-
-    cclip = pGC->pCompositeClip;
-
-    if (!RegionNumRects(cclip))
-        return;
-
-    for (arc = parcs, i = narcs; --i >= 0; arc++) {
-        if (miFillArcEmpty(arc))
-            continue;
-        if (miCanFillArc(arc)) {
-            box.x1 = arc->x + pDraw->x;
-            box.y1 = arc->y + pDraw->y;
-            /*
-             * Because box.x2 and box.y2 get truncated to 16 bits, and the
-             * RECT_IN_REGION test treats the resulting number as a signed
-             * integer, the RECT_IN_REGION test alone can go the wrong way.
-             * This can result in a server crash because the rendering
-             * routines in this file deal directly with cpu addresses
-             * of pixels to be stored, and do not clip or otherwise check
-             * that all such addresses are within their respective pixmaps.
-             * So we only allow the RECT_IN_REGION test to be used for
-             * values that can be expressed correctly in a signed short.
-             */
-            x2 = box.x1 + (int) arc->width + 1;
-            box.x2 = x2;
-            y2 = box.y1 + (int) arc->height + 1;
-            box.y2 = y2;
-            if ((x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
-                (RegionContainsRect(cclip, &box) == rgnIN)) {
-                if ((arc->angle2 >= FULLCIRCLE) || (arc->angle2 <= -FULLCIRCLE))
-                    XAAFillEllipseSolid(pDraw, pGC, arc);
-                else
-                    XAAFillArcSliceSolid(pDraw, pGC, arc);
-                continue;
-            }
-        }
-        miPolyFillArc(pDraw, pGC, 1, arc);
-    }
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaFillPoly.c b/xorg-server/hw/xfree86/xaa/xaaFillPoly.c
deleted file mode 100644
index 0cdedf57e..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaFillPoly.c
+++ /dev/null
@@ -1,991 +0,0 @@
-
-/*
- * Copyright 1996  The XFree86 Project
- *
- * 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 
- * HARM HANEMAAYER 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.
- * 
- */
-
-/*
- * Written by Mark Vojkovich.  Loosly based on an original version
- * written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net) which
- * only did solid rectangles and didn't have trapezoid support.
- *
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "micoord.h"
-
-#include "xaa.h"
-#include "xaalocal.h"
-
-#define POLY_USE_MI		0
-#define POLY_FULLY_CLIPPED	1
-#define POLY_IS_EASY		2
-
-#define Setup(c,x,vertex,dx,dy,e,sign,step,DX) {\
-    x = intToX(vertex); \
-    if ((dy = intToY(c) - y)) { \
-    	DX = dx = intToX(c) - x; \
-	step = 0; \
-    	if (dx >= 0) \
-    	{ \
-	    e = 0; \
-	    sign = 1; \
-	    if (dx >= dy) {\
-	    	step = dx / dy; \
-	    	dx %= dy; \
-	    } \
-    	} \
-    	else \
-    	{ \
-	    e = 1 - dy; \
-	    sign = -1; \
-	    dx = -dx; \
-	    if (dx >= dy) { \
-		step = - (dx / dy); \
-		dx %= dy; \
-	    } \
-    	} \
-    } \
-    x += origin; \
-    vertex = c; \
-}
-
-#define Step(x,dx,dy,e,sign,step) {\
-    x += step; \
-    if ((e += dx) > 0) \
-    { \
-	x += sign; \
-	e -= dy; \
-    } \
-}
-
-#define FixError(x, dx, dy, e, sign, step, h)	{	\
-	   e += (h) * dx;				\
-	   x += (h) * step;				\
-	   if(e > 0) {					\
-		x += e * sign/dy;			\
-		e %= dy;				\
-	   	if(e) {					\
-		   x += sign;				\
-		   e -= dy;				\
-		}					\
-	   } 	 					\
-}
-
-/*
-   XAAIsEasyPoly -
-
-   Checks CoordModeOrigin one rect polygons to see if we need
-   to use Mi.
-   Returns: POLY_USE_MI, POLY_FULLY_CLIPPED or POLY_IS_EASY
-	as well as the pointer to the "top" point and the y
-	extents.
-*/
-
-int
-XAAIsEasyPolygon(DDXPointPtr ptsIn, int count, BoxPtr extents, int origin, DDXPointPtr * topPoint,      /* return */
-                 int *topY, int *bottomY,       /* return */
-                 int shape)
-{
-    int c = 0, vertex1, vertex2;
-
-    *topY = 32767;
-    *bottomY = 0;
-
-    origin -= (origin & 0x8000) << 1;
-    vertex1 = extents->x1 - origin;
-    vertex2 = extents->x2 - origin /* - 0x00010001 */ ;
-    /* I think this was an error in cfb ^ */
-
-    if (shape == Convex) {
-        while (count--) {
-            c = *((int *) ptsIn);
-            if (((c - vertex1) | (vertex2 - c)) & 0x80008000)
-                return POLY_USE_MI;
-
-            c = intToY(c);
-            if (c < *topY) {
-                *topY = c;
-                *topPoint = ptsIn;
-            }
-            ptsIn++;
-            if (c > *bottomY)
-                *bottomY = c;
-        }
-    }
-    else {
-        int yFlip = 0;
-        int dx2, dx1, x1, x2;
-
-        x2 = x1 = -1;
-        dx2 = dx1 = 1;
-
-        while (count--) {
-            c = *((int *) ptsIn);
-            if (((c - vertex1) | (vertex2 - c)) & 0x80008000)
-                return POLY_USE_MI;
-            c = intToY(c);
-            if (c < *topY) {
-                *topY = c;
-                *topPoint = ptsIn;
-            }
-            ptsIn++;
-            if (c > *bottomY)
-                *bottomY = c;
-            if (c == x1)
-                continue;
-            if (dx1 > 0) {
-                if (x2 < 0)
-                    x2 = c;
-                else
-                    dx2 = dx1 = (c - x1) >> 31;
-            }
-            else if ((c - x1) >> 31 != dx1) {
-                dx1 = ~dx1;
-                yFlip++;
-            }
-            x1 = c;
-        }
-        x1 = (x2 - c) >> 31;
-        if (x1 != dx1)
-            yFlip++;
-        if (x1 != dx2)
-            yFlip++;
-        if (yFlip != 2) {
-            if (*topY == *bottomY)
-                return POLY_FULLY_CLIPPED;
-            else
-                return POLY_USE_MI;
-        }
-    }
-    if (*topY == *bottomY)
-        return POLY_FULLY_CLIPPED;
-
-    return POLY_IS_EASY;
-}
-
-void
-XAAFillPolygonSolid(DrawablePtr pDraw,
-                    GCPtr pGC,
-                    int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int origin, vertex1, vertex2;
-    int *vertex1p, *vertex2p, *endp;
-    int x1 = 0, x2 = 0;
-    int dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
-    int DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;
-    int step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;
-    int c, y, maxy, h, yoffset;
-    DDXPointPtr topPoint;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    if (mode == CoordModePrevious) {
-        register DDXPointPtr ppt = ptsIn + 1;
-
-        for (origin = 1; origin < count; origin++, ppt++) {
-            ppt->x += (ppt - 1)->x;
-            ppt->y += (ppt - 1)->y;
-        }
-        mode = CoordModeOrigin;
-    }
-
-    if (RegionNumRects(pGC->pCompositeClip) != 1) {
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    origin = coordToInt(pDraw->x, pDraw->y);
-
-    switch (XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,
-                             origin, &topPoint, &y, &maxy, shape)) {
-    case POLY_USE_MI:
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED:
-        return;
-    }
-
-    endp = (int *) ptsIn + count;
-    vertex2p = vertex1p = (int *) topPoint;
-    origin = pDraw->x;
-    yoffset = pDraw->y;
-    vertex2 = vertex1 = *vertex2p++;
-    if (vertex2p == endp)
-        vertex2p = (int *) ptsIn;
-
-    (*infoRec->SetupForSolidFill) (infoRec->pScrn, pGC->fgPixel, pGC->alu,
-                                   pGC->planemask);
-
-    while (1) {
-        if (y == intToY(vertex1)) {
-            do {
-                if (vertex1p == (int *) ptsIn)
-                    vertex1p = endp;
-                c = *--vertex1p;
-                Setup(c, x1, vertex1, dx1, dy1, e1, sign1, step1, DX1)
-            } while (y >= intToY(vertex1));
-            h = dy1;
-        }
-        else {
-            Step(x1, dx1, dy1, e1, sign1, step1)
-                h = intToY(vertex1) - y;
-        }
-        if (y == intToY(vertex2)) {
-            do {
-                c = *vertex2p++;
-                if (vertex2p == endp)
-                    vertex2p = (int *) ptsIn;
-                Setup(c, x2, vertex2, dx2, dy2, e2, sign2, step2, DX2)
-            } while (y >= intToY(vertex2));
-            if (dy2 < h)
-                h = dy2;
-        }
-        else {
-            Step(x2, dx2, dy2, e2, sign2, step2)
-                if ((c = (intToY(vertex2) - y)) < h)
-                h = c;
-        }
-
-        /* fill spans for this segment */
-        if (DX1 | DX2) {
-            if (infoRec->SubsequentSolidFillTrap && (h > 6)) {
-                if (x1 == x2) {
-                    while (x1 == x2) {
-                        y++;
-                        if (!--h)
-                            break;
-                        Step(x1, dx1, dy1, e1, sign1, step1)
-                            Step(x2, dx2, dy2, e2, sign2, step2)
-                    }
-                    if (y == maxy)
-                        break;
-                    if (!h)
-                        continue;
-                }
-
-                if (x1 < x2)
-                    (*infoRec->SubsequentSolidFillTrap) (infoRec->pScrn,
-                                                         y + yoffset, h,
-                                                         x1, DX1, dy1, e1,
-                                                         x2 - 1, DX2, dy2, e2);
-                else
-                    (*infoRec->SubsequentSolidFillTrap) (infoRec->pScrn,
-                                                         y + yoffset, h,
-                                                         x2, DX2, dy2, e2,
-                                                         x1 - 1, DX1, dy1, e1);
-                y += h;
-                if (--h) {
-                    FixError(x1, dx1, dy1, e1, sign1, step1, h);
-                    FixError(x2, dx2, dy2, e2, sign2, step2, h);
-                    h = 0;
-                }
-            }
-            else {
-                while (1) {
-                    if (x2 > x1)
-                        (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn,
-                                                             x1, y + yoffset,
-                                                             x2 - x1, 1);
-                    else if (x1 > x2)
-                        (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn,
-                                                             x2, y + yoffset,
-                                                             x1 - x2, 1);
-                    y++;
-                    if (!--h)
-                        break;
-                    Step(x1, dx1, dy1, e1, sign1, step1)
-                        Step(x2, dx2, dy2, e2, sign2, step2)
-                }
-            }
-        }
-        else {
-            if (x2 > x1)
-                (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn,
-                                                     x1, y + yoffset, x2 - x1,
-                                                     h);
-            else if (x1 > x2)
-                (*infoRec->SubsequentSolidFillRect) (infoRec->pScrn,
-                                                     x2, y + yoffset, x1 - x2,
-                                                     h);
-
-            y += h;
-            h = 0;
-        }
-        if (y == maxy)
-            break;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillPolygonHelper(ScrnInfoPtr pScrn,
-                     DDXPointPtr ptsIn,
-                     int count,
-                     DDXPointPtr topPoint,
-                     int y,
-                     int maxy,
-                     int origin,
-                     RectFuncPtr RectFunc,
-                     TrapFuncPtr TrapFunc,
-                     int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    int *vertex1p, *vertex2p, *endp;
-    int vertex1, vertex2;
-    int x1 = 0, x2 = 0;
-    int dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
-    int DX1 = 0, DX2 = 0, e1 = 0, e2 = 0;
-    int step1 = 0, step2 = 0, sign1 = 0, sign2 = 0;
-    int c, h, yoffset;
-
-    endp = (int *) ptsIn + count;
-    vertex2p = vertex1p = (int *) topPoint;
-    yoffset = intToY(origin);
-    origin = intToX(origin);
-    vertex2 = vertex1 = *vertex2p++;
-    if (vertex2p == endp)
-        vertex2p = (int *) ptsIn;
-
-    while (1) {
-        if (y == intToY(vertex1)) {
-            do {
-                if (vertex1p == (int *) ptsIn)
-                    vertex1p = endp;
-                c = *--vertex1p;
-                Setup(c, x1, vertex1, dx1, dy1, e1, sign1, step1, DX1)
-            } while (y >= intToY(vertex1));
-            h = dy1;
-        }
-        else {
-            Step(x1, dx1, dy1, e1, sign1, step1)
-                h = intToY(vertex1) - y;
-        }
-        if (y == intToY(vertex2)) {
-            do {
-                c = *vertex2p++;
-                if (vertex2p == endp)
-                    vertex2p = (int *) ptsIn;
-                Setup(c, x2, vertex2, dx2, dy2, e2, sign2, step2, DX2)
-            } while (y >= intToY(vertex2));
-            if (dy2 < h)
-                h = dy2;
-        }
-        else {
-            Step(x2, dx2, dy2, e2, sign2, step2)
-                if ((c = (intToY(vertex2) - y)) < h)
-                h = c;
-        }
-
-        /* fill spans for this segment */
-        if (DX1 | DX2) {
-            if (TrapFunc && (h > 6)) {
-                if (x1 == x2) {
-                    while (x1 == x2) {
-                        y++;
-                        if (!--h)
-                            break;
-                        Step(x1, dx1, dy1, e1, sign1, step1)
-                            Step(x2, dx2, dy2, e2, sign2, step2)
-                    }
-                    if (y == maxy)
-                        break;
-                    if (!h)
-                        continue;
-                }
-
-                if (x1 < x2)
-                    (*TrapFunc) (pScrn, y + yoffset, h,
-                                 x1, DX1, dy1, e1,
-                                 x2 - 1, DX2, dy2, e2, xorg, yorg, pCache);
-                else
-                    (*TrapFunc) (pScrn, y + yoffset, h,
-                                 x2, DX2, dy2, e2,
-                                 x1 - 1, DX1, dy1, e1, xorg, yorg, pCache);
-                y += h;
-                if (--h) {
-                    FixError(x1, dx1, dy1, e1, sign1, step1, h);
-                    FixError(x2, dx2, dy2, e2, sign2, step2, h);
-                    h = 0;
-                }
-            }
-            else {
-                while (1) {
-                    if (x2 > x1)
-                        (*RectFunc) (pScrn,
-                                     x1, y + yoffset, x2 - x1, 1, xorg, yorg,
-                                     pCache);
-                    else if (x1 > x2)
-                        (*RectFunc) (pScrn,
-                                     x2, y + yoffset, x1 - x2, 1, xorg, yorg,
-                                     pCache);
-                    y++;
-                    if (!--h)
-                        break;
-                    Step(x1, dx1, dy1, e1, sign1, step1)
-                        Step(x2, dx2, dy2, e2, sign2, step2)
-                }
-            }
-        }
-        else {
-            if (x2 > x1)
-                (*RectFunc) (pScrn,
-                             x1, y + yoffset, x2 - x1, h, xorg, yorg, pCache);
-            else if (x1 > x2)
-                (*RectFunc) (pScrn,
-                             x2, y + yoffset, x1 - x2, h, xorg, yorg, pCache);
-
-            y += h;
-            h = 0;
-        }
-        if (y == maxy)
-            break;
-    }
-}
-
-        /*****************\
-	|  Solid Helpers  |
-	\*****************/
-
-static void
-SolidTrapHelper(ScrnInfoPtr pScrn,
-                int y, int h,
-                int x1, int dx1, int dy1, int e1,
-                int x2, int dx2, int dy2, int e2,
-                int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentSolidFillTrap) (pScrn,
-                                         y, h, x1, dx1, dy1, e1, x2, dx2, dy2,
-                                         e2);
-}
-
-static void
-SolidRectHelper(ScrnInfoPtr pScrn,
-                int x, int y, int w, int h,
-                int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-}
-
-        /*********************\
-	|  Mono 8x8 Patterns  |
-	\*********************/
-
-static void
-Mono8x8PatternTrapHelper_ScreenOrigin(ScrnInfoPtr pScrn,
-                                      int y, int h,
-                                      int x1, int dx1, int dy1, int e1,
-                                      int x2, int dx2, int dy2, int e2,
-                                      int xorg, int yorg,
-                                      XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentMono8x8PatternFillTrap) (pScrn, xorg, yorg,
-                                                  y, h, x1, dx1, dy1, e1, x2,
-                                                  dx2, dy2, e2);
-}
-
-static void
-Mono8x8PatternRectHelper_ScreenOrigin(ScrnInfoPtr pScrn,
-                                      int x, int y, int w, int h,
-                                      int xorg, int yorg,
-                                      XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,
-                                                  x, y, w, h);
-}
-
-static void
-Mono8x8PatternRectHelper(ScrnInfoPtr pScrn,
-                         int x, int y, int w, int h,
-                         int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    xorg = (x - xorg) & 0x07;
-    yorg = (y - yorg) & 0x07;
-
-    if (!(infoRec->Mono8x8PatternFillFlags &
-          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-        if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-            int patx = pCache->pat0;
-            int paty = pCache->pat1;
-
-            XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                 (infoRec->Mono8x8PatternFillFlags &
-                                  BIT_ORDER_IN_BYTE_MSBFIRST));
-            xorg = patx;
-            yorg = paty;
-        }
-        else {
-            int slot = (yorg << 3) + xorg;
-
-            xorg = pCache->x + pCache->offsets[slot].x;
-            yorg = pCache->y + pCache->offsets[slot].y;
-        }
-    }
-
-    (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn, xorg, yorg,
-                                                  x, y, w, h);
-}
-
-        /****************\
-	|  Cache Expand  |
-	\****************/
-
-static void
-CacheExpandRectHelper(ScrnInfoPtr pScrn,
-                      int X, int Y, int Width, int Height,
-                      int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;
-    int cacheWidth;
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
-        infoRec->CacheColorExpandDensity;
-
-    phaseY = (Y - yorg) % pCache->orig_h;
-    if (phaseY < 0)
-        phaseY += pCache->orig_h;
-    phaseX = (X - xorg) % pCache->orig_w;
-    if (phaseX < 0)
-        phaseX += pCache->orig_w;
-
-    while (1) {
-        w = Width;
-        skipleft = phaseX;
-        x = X;
-        blit_h = pCache->h - phaseY;
-        if (blit_h > Height)
-            blit_h = Height;
-
-        while (1) {
-            blit_w = cacheWidth - skipleft;
-            if (blit_w > w)
-                blit_w = w;
-            (*infoRec->SubsequentScreenToScreenColorExpandFill) (pScrn, x, Y,
-                                                                 blit_w, blit_h,
-                                                                 pCache->x,
-                                                                 pCache->y +
-                                                                 phaseY,
-                                                                 skipleft);
-            w -= blit_w;
-            if (!w)
-                break;
-            x += blit_w;
-            skipleft = (skipleft + blit_w) % pCache->orig_w;
-        }
-        Height -= blit_h;
-        if (!Height)
-            break;
-        Y += blit_h;
-        phaseY = (phaseY + blit_h) % pCache->orig_h;
-    }
-}
-
-        /**************\
-	|  Cache Blit  |
-	\**************/
-
-static void
-CacheBltRectHelper(ScrnInfoPtr pScrn,
-                   int X, int Y, int Width, int Height,
-                   int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, skipleft, w, blit_w, blit_h;
-
-    phaseY = (Y - yorg) % pCache->orig_h;
-    if (phaseY < 0)
-        phaseY += pCache->orig_h;
-    phaseX = (X - xorg) % pCache->orig_w;
-    if (phaseX < 0)
-        phaseX += pCache->orig_w;
-
-    while (1) {
-        w = Width;
-        skipleft = phaseX;
-        x = X;
-        blit_h = pCache->h - phaseY;
-        if (blit_h > Height)
-            blit_h = Height;
-
-        while (1) {
-            blit_w = pCache->w - skipleft;
-            if (blit_w > w)
-                blit_w = w;
-            (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                      pCache->x + skipleft,
-                                                      pCache->y + phaseY, x, Y,
-                                                      blit_w, blit_h);
-            w -= blit_w;
-            if (!w)
-                break;
-            x += blit_w;
-            skipleft = (skipleft + blit_w) % pCache->orig_w;
-        }
-        Height -= blit_h;
-        if (!Height)
-            break;
-        Y += blit_h;
-        phaseY = (phaseY + blit_h) % pCache->orig_h;
-    }
-}
-
-        /**********************\
-	|   Stippled Polygons  |
-	\**********************/
-
-void
-XAAFillPolygonStippled(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-    int origin, type, patx, paty, fg, bg;
-    int y, maxy, xorg, yorg;
-    DDXPointPtr topPoint;
-    XAACacheInfoPtr pCache = NULL;
-    RectFuncPtr RectFunc = NULL;
-    TrapFuncPtr TrapFunc = NULL;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    if (mode == CoordModePrevious) {
-        register DDXPointPtr ppt = ptsIn + 1;
-
-        for (origin = 1; origin < count; origin++, ppt++) {
-            ppt->x += (ppt - 1)->x;
-            ppt->y += (ppt - 1)->y;
-        }
-        mode = CoordModeOrigin;
-    }
-
-    if (RegionNumRects(pGC->pCompositeClip) != 1) {
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    if (pGC->fillStyle == FillStippled) {
-        type = (*infoRec->StippledFillChooser) (pGC);
-        fg = pGC->fgPixel;
-        bg = -1;
-    }
-    else {
-        type = (*infoRec->OpaqueStippledFillChooser) (pGC);
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-    }
-
-    if (!type) {
-        (*XAAFallbackOps.FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    if ((type == DO_COLOR_EXPAND) || (type == DO_COLOR_8x8)) {
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    origin = pDraw->x;
-
-    switch (XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,
-                             origin, &topPoint, &y, &maxy, shape)) {
-    case POLY_USE_MI:
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED:
-        return;
-    }
-
-    xorg = (pDraw->x + pGC->patOrg.x);
-    yorg = (pDraw->y + pGC->patOrg.y);
-
-    if ((fg == bg) && (bg != -1) && infoRec->SetupForSolidFill) {
-
-        (*infoRec->SetupForSolidFill) (infoRec->pScrn, fg,
-                                       pGC->alu, pGC->planemask);
-
-        RectFunc = SolidRectHelper;
-        TrapFunc = infoRec->SubsequentSolidFillTrap ? SolidTrapHelper : NULL;
-    }
-    else
-        switch (type) {
-        case DO_MONO_8x8:
-            patx = pPriv->pattern0;
-            paty = pPriv->pattern1;
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_SCREEN_ORIGIN) {
-                xorg = (-xorg) & 0x07;
-                yorg = (-yorg) & 0x07;
-                if (infoRec->Mono8x8PatternFillFlags &
-                    HARDWARE_PATTERN_PROGRAMMED_BITS) {
-                    if (!(infoRec->Mono8x8PatternFillFlags &
-                          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-                        XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                             (infoRec->Mono8x8PatternFillFlags &
-                                              BIT_ORDER_IN_BYTE_MSBFIRST));
-                        xorg = patx;
-                        yorg = paty;
-                    }
-                }
-                else {
-                    XAACacheInfoPtr pCache =
-                        (*infoRec->CacheMono8x8Pattern) (infoRec->pScrn, patx,
-                                                         paty);
-                    patx = pCache->x;
-                    paty = pCache->y;
-                    if (!(infoRec->Mono8x8PatternFillFlags &
-                          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-                        int slot = (yorg << 3) + xorg;
-
-                        patx += pCache->offsets[slot].x;
-                        paty += pCache->offsets[slot].y;
-                        xorg = patx;
-                        yorg = paty;
-                    }
-                }
-                RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;
-                if (infoRec->SubsequentMono8x8PatternFillTrap)
-                    TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;
-            }
-            else {              /* !HARDWARE_PATTERN_SCREEN_ORIGIN */
-                if (!(infoRec->Mono8x8PatternFillFlags &
-                      HARDWARE_PATTERN_PROGRAMMED_BITS)) {
-                    pCache =
-                        (*infoRec->CacheMono8x8Pattern) (infoRec->pScrn, patx,
-                                                         paty);
-                    patx = pCache->x;
-                    paty = pCache->y;
-                }
-                else {
-                    pCache = &(infoRec->ScratchCacheInfoRec);
-                    pCache->pat0 = patx;
-                    pCache->pat1 = paty;
-                }
-                RectFunc = Mono8x8PatternRectHelper;
-            }
-
-            (*infoRec->SetupForMono8x8PatternFill) (infoRec->pScrn,
-                                                    patx, paty, fg, bg,
-                                                    pGC->alu, pGC->planemask);
-            break;
-        case DO_CACHE_EXPAND:
-            pCache =
-                (*infoRec->CacheMonoStipple) (infoRec->pScrn, pGC->stipple);
-
-            (*infoRec->SetupForScreenToScreenColorExpandFill) (infoRec->pScrn,
-                                                               fg, bg, pGC->alu,
-                                                               pGC->planemask);
-
-            RectFunc = CacheExpandRectHelper;
-            break;
-        case DO_CACHE_BLT:
-            pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                               fg, bg);
-            (*infoRec->SetupForScreenToScreenCopy) (infoRec->pScrn, 1, 1,
-                                                    pGC->alu, pGC->planemask,
-                                                    pCache->trans_color);
-
-            RectFunc = CacheBltRectHelper;
-            break;
-        default:
-            return;
-        }
-
-    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint,
-                         y, maxy, origin, RectFunc, TrapFunc, xorg, yorg,
-                         pCache);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*******************\
-	|   Tiled Polygons  |
-	\*******************/
-
-void
-XAAFillPolygonTiled(DrawablePtr pDraw,
-                    GCPtr pGC,
-                    int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-    int origin, type, patx, paty;
-    int y, maxy, xorg, yorg;
-    DDXPointPtr topPoint;
-    XAACacheInfoPtr pCache = NULL;
-    RectFuncPtr RectFunc = NULL;
-    TrapFuncPtr TrapFunc = NULL;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    if (mode == CoordModePrevious) {
-        register DDXPointPtr ppt = ptsIn + 1;
-
-        for (origin = 1; origin < count; origin++, ppt++) {
-            ppt->x += (ppt - 1)->x;
-            ppt->y += (ppt - 1)->y;
-        }
-        mode = CoordModeOrigin;
-    }
-
-    if (RegionNumRects(pGC->pCompositeClip) != 1) {
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    type = (*infoRec->TiledFillChooser) (pGC);
-
-    if (!type || (type == DO_IMAGE_WRITE)) {
-        (*XAAFallbackOps.FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    if (type == DO_COLOR_8x8) {
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-        return;
-    }
-
-    origin = pDraw->x;
-
-    switch (XAAIsEasyPolygon(ptsIn, count, &pGC->pCompositeClip->extents,
-                             origin, &topPoint, &y, &maxy, shape)) {
-    case POLY_USE_MI:
-        miFillPolygon(pDraw, pGC, shape, mode, count, ptsIn);
-    case POLY_FULLY_CLIPPED:
-        return;
-    }
-
-    xorg = (pDraw->x + pGC->patOrg.x);
-    yorg = (pDraw->y + pGC->patOrg.y);
-
-    switch (type) {
-    case DO_MONO_8x8:
-        patx = pPriv->pattern0;
-        paty = pPriv->pattern1;
-        if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) {
-            xorg = (-xorg) & 0x07;
-            yorg = (-yorg) & 0x07;
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_PROGRAMMED_BITS) {
-                if (!(infoRec->Mono8x8PatternFillFlags &
-                      HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-                    XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                         (infoRec->Mono8x8PatternFillFlags &
-                                          BIT_ORDER_IN_BYTE_MSBFIRST));
-                    xorg = patx;
-                    yorg = paty;
-                }
-            }
-            else {
-                XAACacheInfoPtr pCache =
-                    (*infoRec->CacheMono8x8Pattern) (infoRec->pScrn, patx,
-                                                     paty);
-                patx = pCache->x;
-                paty = pCache->y;
-                if (!(infoRec->Mono8x8PatternFillFlags &
-                      HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-                    int slot = (yorg << 3) + xorg;
-
-                    patx += pCache->offsets[slot].x;
-                    paty += pCache->offsets[slot].y;
-                    xorg = patx;
-                    yorg = paty;
-                }
-            }
-            RectFunc = Mono8x8PatternRectHelper_ScreenOrigin;
-            if (infoRec->SubsequentMono8x8PatternFillTrap)
-                TrapFunc = Mono8x8PatternTrapHelper_ScreenOrigin;
-        }
-        else {                  /* !HARDWARE_PATTERN_SCREEN_ORIGIN */
-            if (!(infoRec->Mono8x8PatternFillFlags &
-                  HARDWARE_PATTERN_PROGRAMMED_BITS)) {
-                pCache =
-                    (*infoRec->CacheMono8x8Pattern) (infoRec->pScrn, patx,
-                                                     paty);
-                patx = pCache->x;
-                paty = pCache->y;
-            }
-            else {
-                pCache = &(infoRec->ScratchCacheInfoRec);
-                pCache->pat0 = patx;
-                pCache->pat1 = paty;
-            }
-            RectFunc = Mono8x8PatternRectHelper;
-        }
-
-        (*infoRec->SetupForMono8x8PatternFill) (infoRec->pScrn,
-                                                patx, paty, pPriv->fg,
-                                                pPriv->bg, pGC->alu,
-                                                pGC->planemask);
-        break;
-    case DO_CACHE_BLT:
-        pCache = (*infoRec->CacheTile) (infoRec->pScrn, pGC->tile.pixmap);
-        (*infoRec->SetupForScreenToScreenCopy) (infoRec->pScrn, 1, 1,
-                                                pGC->alu, pGC->planemask, -1);
-
-        RectFunc = CacheBltRectHelper;
-        break;
-    case DO_PIXMAP_COPY:
-        pCache = &(infoRec->ScratchCacheInfoRec);
-        pCache->x = pPriv->offscreenArea->box.x1;
-        pCache->y = pPriv->offscreenArea->box.y1;
-        pCache->w = pCache->orig_w = pPriv->offscreenArea->box.x2 - pCache->x;
-        pCache->h = pCache->orig_h = pPriv->offscreenArea->box.y2 - pCache->y;
-
-        (*infoRec->SetupForScreenToScreenCopy) (infoRec->pScrn, 1, 1,
-                                                pGC->alu, pGC->planemask, -1);
-
-        RectFunc = CacheBltRectHelper;
-        break;
-    default:
-        return;
-    }
-
-    XAAFillPolygonHelper(infoRec->pScrn, ptsIn, count, topPoint,
-                         y, maxy, origin, RectFunc, TrapFunc, xorg, yorg,
-                         pCache);
-
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaFillRect.c b/xorg-server/hw/xfree86/xaa/xaaFillRect.c
deleted file mode 100644
index ec0fb9df7..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaFillRect.c
+++ /dev/null
@@ -1,1101 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-static void XAARenderSolidRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColor8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderMono8x8Rects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderColorExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheExpandRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderCacheBltRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderImageWriteRects(GCPtr, int, BoxPtr, int, int);
-static void XAARenderPixmapCopyRects(GCPtr, int, BoxPtr, int, int);
-
-void
-XAAPolyFillRect(DrawablePtr pDraw, GCPtr pGC, int nrectFill,    /* number of rectangles to fill */
-                xRectangle *prectInit   /* Pointer to first rectangle to fill */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int xorg = pDraw->x;
-    int yorg = pDraw->y;
-    int type = 0;
-    ClipAndRenderRectsFunc function;
-
-    if ((nrectFill <= 0) || !pGC->planemask)
-        return;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    switch (pGC->fillStyle) {
-    case FillSolid:
-        type = DO_SOLID;
-        break;
-    case FillStippled:
-        type = (*infoRec->StippledFillChooser) (pGC);
-        break;
-    case FillOpaqueStippled:
-        if ((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSolidRects &&
-            CHECK_PLANEMASK(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_ROP(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillSolidRectsFlags) &&
-            CHECK_FG(pGC, infoRec->FillSolidRectsFlags))
-            type = DO_SOLID;
-        else
-            type = (*infoRec->OpaqueStippledFillChooser) (pGC);
-        break;
-    case FillTiled:
-        type = (*infoRec->TiledFillChooser) (pGC);
-        break;
-    }
-
-    switch (type) {
-    case DO_SOLID:
-        function = XAARenderSolidRects;
-        break;
-    case DO_COLOR_8x8:
-        function = XAARenderColor8x8Rects;
-        break;
-    case DO_MONO_8x8:
-        function = XAARenderMono8x8Rects;
-        break;
-    case DO_CACHE_BLT:
-        function = XAARenderCacheBltRects;
-        break;
-    case DO_COLOR_EXPAND:
-        function = XAARenderColorExpandRects;
-        break;
-    case DO_CACHE_EXPAND:
-        function = XAARenderCacheExpandRects;
-        break;
-    case DO_IMAGE_WRITE:
-        function = XAARenderImageWriteRects;
-        break;
-    case DO_PIXMAP_COPY:
-        function = XAARenderPixmapCopyRects;
-        break;
-    default:
-        (*XAAFallbackOps.PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
-        return;
-    }
-
-    if (xorg | yorg) {
-        int n = nrectFill;
-        xRectangle *prect = prectInit;
-
-        while (n--) {
-            prect->x += xorg;
-            prect->y += yorg;
-            prect++;
-        }
-    }
-
-    XAAClipAndRenderRects(pGC, function, nrectFill, prectInit, xorg, yorg);
-}
-
-        /*********************\
-	|     Solid Rects     |
-	\*********************/
-
-static void
-XAARenderSolidRects(GCPtr pGC,
-                    int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillSolidRects) (infoRec->pScrn,
-                                pGC->fgPixel, pGC->alu, pGC->planemask, nboxes,
-                                pClipBoxes);
-}
-
-        /************************\
-	|     Mono 8x8 Rects     |
-	\************************/
-
-static void
-XAARenderMono8x8Rects(GCPtr pGC,
-                      int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr pPriv;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-        fg = pPriv->fg;
-        bg = pPriv->bg;
-        break;
-    default:                   /* Muffle compiler */
-        pPriv = NULL;           /* Kaboom */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillMono8x8PatternRects) (infoRec->pScrn,
-                                         fg, bg, pGC->alu, pGC->planemask,
-                                         nboxes, pClipBoxes, pPriv->pattern0,
-                                         pPriv->pattern1,
-                                         (xorg + pGC->patOrg.x),
-                                         (yorg + pGC->patOrg.y));
-}
-
-        /*************************\
-	|     Color 8x8 Rects     |
-	\*************************/
-
-static void
-XAARenderColor8x8Rects(GCPtr pGC,
-                       int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-    PixmapPtr pPix;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPix = pGC->tile.pixmap;
-        fg = -1;
-        bg = -1;
-        break;
-    default:                   /* Muffle compiler */
-        pPix = NULL;
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    pCache = (*infoRec->CacheColor8x8Pattern) (infoRec->pScrn, pPix, fg, bg);
-    (*infoRec->FillColor8x8PatternRects) (infoRec->pScrn,
-                                          pGC->alu, pGC->planemask, nboxes,
-                                          pClipBoxes, (xorg + pGC->patOrg.x),
-                                          (yorg + pGC->patOrg.y), pCache);
-}
-
-        /****************************\
-	|     Color Expand Rects     |
-	\****************************/
-
-static void
-XAARenderColorExpandRects(GCPtr pGC,
-                          int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillColorExpandRects) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, nboxes,
-                                      pClipBoxes, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-}
-
-        /*************************\
-	|     Cache Blt Rects     |
-	\*************************/
-
-static void
-XAARenderCacheBltRects(GCPtr pGC,
-                       int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, -1);
-        break;
-    case FillOpaqueStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, pGC->bgPixel);
-        break;
-    case FillTiled:
-        pCache = (*infoRec->CacheTile) (infoRec->pScrn, pGC->tile.pixmap);
-        break;
-    default:                   /* Muffle compiler */
-        pCache = NULL;
-        break;
-    }
-
-    (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu,
-                                   pGC->planemask, nboxes, pClipBoxes,
-                                   (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y), pCache);
-}
-
-        /****************************\
-	|     Cache Expand Rects     |
-	\****************************/
-
-static void
-XAARenderCacheExpandRects(GCPtr pGC,
-                          int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillCacheExpandRects) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, nboxes,
-                                      pClipBoxes, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-}
-
-        /***************************\
-	|     Image Write Rects     |
-	\***************************/
-
-static void
-XAARenderImageWriteRects(GCPtr pGC,
-                         int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillImageWriteRects) (infoRec->pScrn, pGC->alu,
-                                     pGC->planemask, nboxes, pClipBoxes,
-                                     (xorg + pGC->patOrg.x),
-                                     (yorg + pGC->patOrg.y), pGC->tile.pixmap);
-}
-
-        /***************************\
-	|     Pixmap Copy Rects     |
-	\***************************/
-
-static void
-XAARenderPixmapCopyRects(GCPtr pGC,
-                         int nboxes, BoxPtr pClipBoxes, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-    pCache->x = pPriv->offscreenArea->box.x1;
-    pCache->y = pPriv->offscreenArea->box.y1;
-    pCache->w = pCache->orig_w = pPriv->offscreenArea->box.x2 - pCache->x;
-    pCache->h = pCache->orig_h = pPriv->offscreenArea->box.y2 - pCache->y;
-    pCache->trans_color = -1;
-
-    (*infoRec->FillCacheBltRects) (infoRec->pScrn, pGC->alu,
-                                   pGC->planemask, nboxes, pClipBoxes,
-                                   (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y), pCache);
-}
-
-        /************\
-	|   Solid    |
-	\************/
-
-void
-XAAFillSolidRects(ScrnInfoPtr pScrn, int fg, int rop, unsigned int planemask, int nBox, /* number of rectangles to fill */
-                  BoxPtr pBox   /* Pointer to first rectangle to fill */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForSolidFill) (pScrn, fg, rop, planemask);
-    while (nBox--) {
-        (*infoRec->SubsequentSolidFillRect) (pScrn, pBox->x1, pBox->y1,
-                                             pBox->x2 - pBox->x1,
-                                             pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*********************\
-	|  8x8 Mono Patterns  |
-	\*********************/
-
-void
-XAAFillMono8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask,
-                                       int nBox,
-                                       BoxPtr pBox,
-                                       int pattern0, int pattern1,
-                                       int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                 (infoRec->Mono8x8PatternFillFlags &
-                                  BIT_ORDER_IN_BYTE_MSBFIRST));
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-    else {
-        XAACacheInfoPtr pCache =
-            (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            int slot = (yorg << 3) + xorg;
-
-            patx += pCache->offsets[slot].x;
-            paty += pCache->offsets[slot].y;
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    while (nBox--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, pBox->x1,
-                                                      pBox->y1,
-                                                      pBox->x2 - pBox->x1,
-                                                      pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillMono8x8PatternRects(ScrnInfoPtr pScrn,
-                           int fg, int bg, int rop,
-                           unsigned int planemask,
-                           int nBox,
-                           BoxPtr pBox,
-                           int pattern0, int pattern1, int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg, yorg;
-    XAACacheInfoPtr pCache = NULL;
-
-    if (!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)) {
-        pCache = (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    while (nBox--) {
-        xorg = (pBox->x1 - xorigin) & 0x07;
-        yorg = (pBox->y1 - yorigin) & 0x07;
-
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_PROGRAMMED_BITS) {
-                patx = pattern0;
-                paty = pattern1;
-                XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                     (infoRec->Mono8x8PatternFillFlags &
-                                      BIT_ORDER_IN_BYTE_MSBFIRST));
-                xorg = patx;
-                yorg = paty;
-            }
-            else {
-                int slot = (yorg << 3) + xorg;
-
-                xorg = patx + pCache->offsets[slot].x;
-                yorg = paty + pCache->offsets[slot].y;
-            }
-        }
-
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, pBox->x1,
-                                                      pBox->y1,
-                                                      pBox->x2 - pBox->x1,
-                                                      pBox->y2 - pBox->y1);
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /**********************\
-	|  8x8 Color Patterns  |
-	\**********************/
-
-void
-XAAFillColor8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int nBox,
-                                        BoxPtr pBox,
-                                        int xorigin, int yorigin,
-                                        XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pCache->x, paty = pCache->y;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (!(infoRec->Color8x8PatternFillFlags &
-          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-        int slot = (yorg << 3) + xorg;
-
-        paty += pCache->offsets[slot].y;
-        patx += pCache->offsets[slot].x;
-        xorg = patx;
-        yorg = paty;
-    }
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, patx, paty,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    while (nBox--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, pBox->x1,
-                                                       pBox->y1,
-                                                       pBox->x2 - pBox->x1,
-                                                       pBox->y2 - pBox->y1);
-        pBox++;
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillColor8x8PatternRects(ScrnInfoPtr pScrn,
-                            int rop,
-                            unsigned int planemask,
-                            int nBox,
-                            BoxPtr pBox,
-                            int xorigin, int yorigin, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int xorg, yorg;
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, pCache->x, pCache->y,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    while (nBox--) {
-        xorg = (pBox->x1 - xorigin) & 0x07;
-        yorg = (pBox->y1 - yorigin) & 0x07;
-
-        if (!(infoRec->Color8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            int slot = (yorg << 3) + xorg;
-
-            yorg = pCache->y + pCache->offsets[slot].y;
-            xorg = pCache->x + pCache->offsets[slot].x;
-        }
-
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, pBox->x1,
-                                                       pBox->y1,
-                                                       pBox->x2 - pBox->x1,
-                                                       pBox->y2 - pBox->y1);
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /***************\
-	|  Cache Blits  |
-	\***************/
-
-void
-XAAFillCacheBltRects(ScrnInfoPtr pScrn,
-                     int rop,
-                     unsigned int planemask,
-                     int nBox,
-                     BoxPtr pBox, int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-
-    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, rop, planemask,
-                                            pCache->trans_color);
-
-    while (nBox--) {
-        y = pBox->y1;
-        phaseY = (y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-        phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        height = pBox->y2 - y;
-        width = pBox->x2 - pBox->x1;
-
-#if 0
-        if (rop == GXcopy) {
-            while (1) {
-                w = width;
-                skipleft = phaseX;
-                x = pBox->x1;
-                blit_h = pCache->h - phaseY;
-                if (blit_h > height)
-                    blit_h = height;
-
-                while (1) {
-                    blit_w = pCache->w - skipleft;
-                    if (blit_w > w)
-                        blit_w = w;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pCache->x +
-                                                              skipleft,
-                                                              pCache->y +
-                                                              phaseY, x, y,
-                                                              blit_w, blit_h);
-                    w -= blit_w;
-                    if (!w)
-                        break;
-                    x += blit_w;
-                    skipleft = (skipleft + blit_w) % pCache->orig_w;
-                    if (blit_w >= pCache->orig_w)
-                        break;
-                }
-
-                /* Expand horizontally */
-                if (w) {
-                    skipleft -= phaseX;
-                    if (skipleft < 0)
-                        skipleft += pCache->orig_w;
-                    blit_w = x - pBox->x1 - skipleft;
-                    while (w) {
-                        if (blit_w > w)
-                            blit_w = w;
-                        (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                                  pBox->x1 +
-                                                                  skipleft, y,
-                                                                  x, y, blit_w,
-                                                                  blit_h);
-                        w -= blit_w;
-                        x += blit_w;
-                        blit_w <<= 1;
-                    }
-                }
-
-                height -= blit_h;
-                if (!height)
-                    break;
-                y += blit_h;
-                phaseY = (phaseY + blit_h) % pCache->orig_h;
-                if (blit_h >= pCache->orig_h)
-                    break;
-            }
-
-            /* Expand vertically */
-            if (height) {
-                blit_w = pBox->x2 - pBox->x1;
-                phaseY -= (pBox->y1 - yorg) % pCache->orig_h;
-                if (phaseY < 0)
-                    phaseY += pCache->orig_h;
-                blit_h = y - pBox->y1 - phaseY;
-                while (height) {
-                    if (blit_h > height)
-                        blit_h = height;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pBox->x1,
-                                                              pBox->y1 + phaseY,
-                                                              pBox->x1, y,
-                                                              blit_w, blit_h);
-                    height -= blit_h;
-                    y += blit_h;
-                    blit_h <<= 1;
-                }
-            }
-        }
-        else
-#endif
-        {
-            while (1) {
-                w = width;
-                skipleft = phaseX;
-                x = pBox->x1;
-                blit_h = pCache->h - phaseY;
-                if (blit_h > height)
-                    blit_h = height;
-
-                while (1) {
-                    blit_w = pCache->w - skipleft;
-                    if (blit_w > w)
-                        blit_w = w;
-                    (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                              pCache->x +
-                                                              skipleft,
-                                                              pCache->y +
-                                                              phaseY, x, y,
-                                                              blit_w, blit_h);
-                    w -= blit_w;
-                    if (!w)
-                        break;
-                    x += blit_w;
-                    skipleft = (skipleft + blit_w) % pCache->orig_w;
-                }
-                height -= blit_h;
-                if (!height)
-                    break;
-                y += blit_h;
-                phaseY = (phaseY + blit_h) % pCache->orig_h;
-            }
-        }
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*******************\
-	|  Cache Expansion  |
-	\*******************/
-
-void
-XAAFillCacheExpandRects(ScrnInfoPtr pScrn,
-                        int fg, int bg, int rop,
-                        unsigned int planemask,
-                        int nBox,
-                        BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, y, phaseY, phaseX, skipleft, height, width, w, blit_w, blit_h;
-    int cacheWidth;
-    XAACacheInfoPtr pCache;
-
-    pCache = (*infoRec->CacheMonoStipple) (pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
-        infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                       planemask);
-
-    while (nBox--) {
-        y = pBox->y1;
-        phaseY = (y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-        phaseX = (pBox->x1 - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        height = pBox->y2 - y;
-        width = pBox->x2 - pBox->x1;
-
-        while (1) {
-            w = width;
-            skipleft = phaseX;
-            x = pBox->x1;
-            blit_h = pCache->h - phaseY;
-            if (blit_h > height)
-                blit_h = height;
-
-            while (1) {
-                blit_w = cacheWidth - skipleft;
-                if (blit_w > w)
-                    blit_w = w;
-                (*infoRec->SubsequentScreenToScreenColorExpandFill) (pScrn, x,
-                                                                     y, blit_w,
-                                                                     blit_h,
-                                                                     pCache->x,
-                                                                     pCache->y +
-                                                                     phaseY,
-                                                                     skipleft);
-                w -= blit_w;
-                if (!w)
-                    break;
-                x += blit_w;
-                skipleft = (skipleft + blit_w) % pCache->orig_w;
-            }
-            height -= blit_h;
-            if (!height)
-                break;
-            y += blit_h;
-            phaseY = (phaseY + blit_h) % pCache->orig_h;
-        }
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /******************\
-	|   Image Writes   |
-	\******************/
-
-/*  This requires all LEFT_EDGE clipping.  You get too many problems
-    with reading past the edge of the pattern otherwise */
-
-static void
-WriteColumn(ScrnInfoPtr pScrn,
-            unsigned char *pSrc,
-            int x, int y, int w, int h,
-            int xoff, int yoff, int pHeight, int srcwidth, int Bpp)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    unsigned char *src;
-    Bool PlusOne = FALSE;
-    int skipleft, dwords;
-
-    pSrc += (Bpp * xoff);
-
-    if ((skipleft = (long) pSrc & 0x03L)) {
-        if (Bpp == 3)
-            skipleft = 4 - skipleft;
-        else
-            skipleft /= Bpp;
-
-        x -= skipleft;
-        w += skipleft;
-
-        if (Bpp == 3)
-            pSrc -= 3 * skipleft;
-        else                    /* is this Alpha friendly ? */
-            pSrc = (unsigned char *) ((long) pSrc & ~0x03L);
-    }
-
-    src = pSrc + (yoff * srcwidth);
-
-    dwords = bytes_to_int32(w * Bpp);
-
-    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
-        ((dwords * h) & 0x01)) {
-        PlusOne = TRUE;
-    }
-
-    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, skipleft);
-
-    if (dwords > infoRec->ImageWriteRange) {
-        while (h--) {
-            XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
-                                    (CARD32 *) src, dwords);
-            src += srcwidth;
-            yoff++;
-            if (yoff >= pHeight) {
-                yoff = 0;
-                src = pSrc;
-            }
-        }
-    }
-    else {
-        if (srcwidth == (dwords << 2)) {
-            int maxLines = infoRec->ImageWriteRange / dwords;
-            int step;
-
-            while (h) {
-                step = pHeight - yoff;
-                if (step > maxLines)
-                    step = maxLines;
-                if (step > h)
-                    step = h;
-
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords * step);
-
-                src += (srcwidth * step);
-                yoff += step;
-                if (yoff >= pHeight) {
-                    yoff = 0;
-                    src = pSrc;
-                }
-                h -= step;
-            }
-        }
-        else {
-            while (h--) {
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords);
-                src += srcwidth;
-                yoff++;
-                if (yoff >= pHeight) {
-                    yoff = 0;
-                    src = pSrc;
-                }
-            }
-        }
-    }
-
-    if (PlusOne) {
-        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
-
-        *base = 0x00000000;
-    }
-}
-
-void
-XAAFillImageWriteRects(ScrnInfoPtr pScrn,
-                       int rop,
-                       unsigned int planemask,
-                       int nBox,
-                       BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, phaseY, phaseX, height, width, blit_w;
-    int pHeight = pPix->drawable.height;
-    int pWidth = pPix->drawable.width;
-    int Bpp = pPix->drawable.bitsPerPixel >> 3;
-    int srcwidth = pPix->devKind;
-
-    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, -1,
-                                    pPix->drawable.bitsPerPixel,
-                                    pPix->drawable.depth);
-
-    while (nBox--) {
-        x = pBox->x1;
-        phaseY = (pBox->y1 - yorg) % pHeight;
-        if (phaseY < 0)
-            phaseY += pHeight;
-        phaseX = (x - xorg) % pWidth;
-        if (phaseX < 0)
-            phaseX += pWidth;
-        height = pBox->y2 - pBox->y1;
-        width = pBox->x2 - x;
-
-        while (1) {
-            blit_w = pWidth - phaseX;
-            if (blit_w > width)
-                blit_w = width;
-
-            WriteColumn(pScrn, pPix->devPrivate.ptr, x, pBox->y1,
-                        blit_w, height, phaseX, phaseY, pHeight, srcwidth, Bpp);
-
-            width -= blit_w;
-            if (!width)
-                break;
-            x += blit_w;
-            phaseX = (phaseX + blit_w) % pWidth;
-        }
-        pBox++;
-    }
-
-    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-        /*************\
-	|  Utilities  |
-	\*************/
-
-void
-XAAClipAndRenderRects(GCPtr pGC,
-                      ClipAndRenderRectsFunc BoxFunc,
-                      int nrectFill, xRectangle *prect, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int Right, Bottom, MaxBoxes;
-    BoxPtr pextent, pboxClipped, pboxClippedBase;
-
-    MaxBoxes = infoRec->PreAllocSize / sizeof(BoxRec);
-    pboxClippedBase = (BoxPtr) infoRec->PreAllocMem;
-    pboxClipped = pboxClippedBase;
-
-    if (RegionNumRects(pGC->pCompositeClip) == 1) {
-        pextent = RegionRects(pGC->pCompositeClip);
-        while (nrectFill--) {
-            pboxClipped->x1 = max(pextent->x1, prect->x);
-            pboxClipped->y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            pboxClipped->x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            pboxClipped->y2 = min(pextent->y2, Bottom);
-
-            prect++;
-            if ((pboxClipped->x1 < pboxClipped->x2) &&
-                (pboxClipped->y1 < pboxClipped->y2)) {
-                pboxClipped++;
-                if (pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-                    (*BoxFunc) (pGC, MaxBoxes, pboxClippedBase, xorg, yorg);
-                    pboxClipped = pboxClippedBase;
-                }
-            }
-        }
-    }
-    else {
-        pextent = RegionExtents(pGC->pCompositeClip);
-        while (nrectFill--) {
-            int n;
-            BoxRec box, *pbox;
-
-            box.x1 = max(pextent->x1, prect->x);
-            box.y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            box.x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            box.y2 = min(pextent->y2, Bottom);
-
-            prect++;
-
-            if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-                continue;
-
-            n = RegionNumRects(pGC->pCompositeClip);
-            pbox = RegionRects(pGC->pCompositeClip);
-
-            /* clip the rectangle to each box in the clip region
-               this is logically equivalent to calling Intersect()
-             */
-            while (n--) {
-                pboxClipped->x1 = max(box.x1, pbox->x1);
-                pboxClipped->y1 = max(box.y1, pbox->y1);
-                pboxClipped->x2 = min(box.x2, pbox->x2);
-                pboxClipped->y2 = min(box.y2, pbox->y2);
-                pbox++;
-
-                /* see if clipping left anything */
-                if (pboxClipped->x1 < pboxClipped->x2 &&
-                    pboxClipped->y1 < pboxClipped->y2) {
-                    pboxClipped++;
-                    if (pboxClipped >= (pboxClippedBase + MaxBoxes)) {
-                        (*BoxFunc) (pGC, MaxBoxes, pboxClippedBase, xorg, yorg);
-                        pboxClipped = pboxClippedBase;
-                    }
-                }
-            }
-        }
-    }
-
-    if (pboxClipped != pboxClippedBase)
-        (*BoxFunc) (pGC, pboxClipped - pboxClippedBase, pboxClippedBase,
-                    xorg, yorg);
-}
-
-int
-XAAGetRectClipBoxes(GCPtr pGC,
-                    BoxPtr pboxClippedBase,
-                    int nrectFill, xRectangle *prectInit)
-{
-    int Right, Bottom;
-    BoxPtr pextent, pboxClipped = pboxClippedBase;
-    xRectangle *prect = prectInit;
-    RegionPtr prgnClip = pGC->pCompositeClip;
-
-    if (RegionNumRects(prgnClip) == 1) {
-        pextent = RegionRects(prgnClip);
-        while (nrectFill--) {
-            pboxClipped->x1 = max(pextent->x1, prect->x);
-            pboxClipped->y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            pboxClipped->x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            pboxClipped->y2 = min(pextent->y2, Bottom);
-
-            prect++;
-            if ((pboxClipped->x1 < pboxClipped->x2) &&
-                (pboxClipped->y1 < pboxClipped->y2)) {
-                pboxClipped++;
-            }
-        }
-    }
-    else {
-        pextent = RegionExtents(prgnClip);
-        while (nrectFill--) {
-            int n;
-            BoxRec box, *pbox;
-
-            box.x1 = max(pextent->x1, prect->x);
-            box.y1 = max(pextent->y1, prect->y);
-
-            Right = (int) prect->x + (int) prect->width;
-            box.x2 = min(pextent->x2, Right);
-
-            Bottom = (int) prect->y + (int) prect->height;
-            box.y2 = min(pextent->y2, Bottom);
-
-            prect++;
-
-            if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
-                continue;
-
-            n = RegionNumRects(prgnClip);
-            pbox = RegionRects(prgnClip);
-
-            /* clip the rectangle to each box in the clip region
-               this is logically equivalent to calling Intersect()
-             */
-            while (n--) {
-                pboxClipped->x1 = max(box.x1, pbox->x1);
-                pboxClipped->y1 = max(box.y1, pbox->y1);
-                pboxClipped->x2 = min(box.x2, pbox->x2);
-                pboxClipped->y2 = min(box.y2, pbox->y2);
-                pbox++;
-
-                /* see if clipping left anything */
-                if (pboxClipped->x1 < pboxClipped->x2 &&
-                    pboxClipped->y1 < pboxClipped->y2) {
-                    pboxClipped++;
-                }
-            }
-        }
-    }
-
-    return pboxClipped - pboxClippedBase;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaGC.c b/xorg-server/hw/xfree86/xaa/xaaGC.c
deleted file mode 100644
index d55f1e445..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaGC.c
+++ /dev/null
@@ -1,564 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "migc.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "xaawrap.h"
-
-static void XAAValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-static void XAAChangeGC(GCPtr pGC, unsigned long mask);
-static void XAACopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
-static void XAADestroyGC(GCPtr pGC);
-static void XAAChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
-static void XAADestroyClip(GCPtr pGC);
-static void XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc);
-
-GCFuncs XAAGCFuncs = {
-    XAAValidateGC, XAAChangeGC, XAACopyGC, XAADestroyGC,
-    XAAChangeClip, XAADestroyClip, XAACopyClip
-};
-
-extern GCOps XAAPixmapOps;
-
-Bool
-XAACreateGC(GCPtr pGC)
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
-                                                   XAAGetGCKey());
-    Bool ret;
-
-    XAA_SCREEN_PROLOGUE(pScreen, CreateGC);
-
-    if ((ret = (*pScreen->CreateGC) (pGC))) {
-        pGCPriv->wrapOps = NULL;
-        pGCPriv->wrapFuncs = pGC->funcs;
-        pGCPriv->XAAOps = &XAAFallbackOps;
-        pGC->funcs = &XAAGCFuncs;
-    }
-
-    XAA_SCREEN_EPILOGUE(pScreen, CreateGC, XAACreateGC);
-
-    return ret;
-}
-
-static void
-XAAValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    XAA_GC_FUNC_PROLOGUE(pGC);
-
-    (*pGC->funcs->ValidateGC) (pGC, changes, pDraw);
-
-    if ((changes & GCPlaneMask) &&
-        ((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) ==
-         infoRec->FullPlanemasks[pGC->depth - 1])) {
-        pGC->planemask = ~0;
-    }
-
-    if (pGC->depth != 32) {
-        /* 0xffffffff is reserved for transparency */
-        if (pGC->bgPixel == 0xffffffff)
-            pGC->bgPixel = 0x7fffffff;
-        if (pGC->fgPixel == 0xffffffff)
-            pGC->fgPixel = 0x7fffffff;
-    }
-
-    if ((pDraw->type == DRAWABLE_PIXMAP) && !IS_OFFSCREEN_PIXMAP(pDraw)) {
-        pGCPriv->flags = OPS_ARE_PIXMAP;
-        pGCPriv->changes |= changes;
-
-        /* make sure we're not using videomemory pixmaps to render
-           onto system memory drawables */
-
-        if ((pGC->fillStyle == FillTiled) &&
-            IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
-            !OFFSCREEN_PIXMAP_LOCKED(pGC->tile.pixmap)) {
-
-            XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-            FBAreaPtr area = pPriv->offscreenArea;
-
-            XAARemoveAreaCallback(area);        /* clobbers pPriv->offscreenArea */
-            xf86FreeOffscreenArea(area);
-        }
-    }
-    else if (!infoRec->pScrn->vtSema && (pDraw->type == DRAWABLE_WINDOW)) {
-        pGCPriv->flags = 0;
-        pGCPriv->changes |= changes;
-    }
-    else {
-        if (!(pGCPriv->flags & OPS_ARE_ACCEL)) {
-            changes |= pGCPriv->changes;
-            pGCPriv->changes = 0;
-        }
-        pGCPriv->flags = OPS_ARE_ACCEL;
-
-#if 1
-        /* Ugh.  If we can't use the blitter on offscreen pixmaps used
-           as tiles, then we need to move them out as cfb can't handle
-           tiles with non-zero origins */
-
-        if ((pGC->fillStyle == FillTiled) &&
-            IS_OFFSCREEN_PIXMAP(pGC->tile.pixmap) &&
-            (DO_PIXMAP_COPY != (*infoRec->TiledFillChooser) (pGC))) {
-
-            XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-            FBAreaPtr area = pPriv->offscreenArea;
-
-            XAARemoveAreaCallback(area);        /* clobbers pPriv->offscreenArea */
-            xf86FreeOffscreenArea(area);
-        }
-#endif
-    }
-
-    XAA_GC_FUNC_EPILOGUE(pGC);
-
-    if (!(pGCPriv->flags & OPS_ARE_ACCEL))
-        return;
-
-    if ((changes & GCTile) && !pGC->tileIsPixel && pGC->tile.pixmap) {
-        XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-        if (pixPriv->flags & DIRTY) {
-            pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
-            pGC->tile.pixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-        }
-    }
-    if ((changes & GCStipple) && pGC->stipple) {
-        XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-
-        if (pixPriv->flags & DIRTY) {
-            pixPriv->flags &= ~(DIRTY | REDUCIBILITY_MASK);
-            pGC->stipple->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-        }
-    }
-
-    /* If our Ops are still the default ones we need to allocate new ones */
-    if (pGC->ops == &XAAFallbackOps) {
-        if (!(pGCPriv->XAAOps = malloc(sizeof(GCOps)))) {
-            pGCPriv->XAAOps = &XAAFallbackOps;
-            return;
-        }
-        /* make a modifiable copy of the default ops */
-        memcpy(pGCPriv->XAAOps, &XAAFallbackOps, sizeof(GCOps));
-        pGC->ops = pGCPriv->XAAOps;
-        changes = ~0;
-    }
-
-    if (!changes)
-        return;
-
-    if ((changes & GCDashList) && infoRec->ComputeDash)
-        infoRec->ComputeDash(pGC);
-
-    if (changes & infoRec->FillSpansMask)
-        (*infoRec->ValidateFillSpans) (pGC, changes, pDraw);
-
-    if (changes & infoRec->SetSpansMask)
-        (*infoRec->ValidateSetSpans) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PutImageMask)
-        (*infoRec->ValidatePutImage) (pGC, changes, pDraw);
-
-    if (changes & infoRec->CopyAreaMask)
-        (*infoRec->ValidateCopyArea) (pGC, changes, pDraw);
-
-    if (changes & infoRec->CopyPlaneMask)
-        (*infoRec->ValidateCopyPlane) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyPointMask)
-        (*infoRec->ValidatePolyPoint) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolylinesMask)
-        (*infoRec->ValidatePolylines) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolySegmentMask)
-        (*infoRec->ValidatePolySegment) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyRectangleMask)
-        (*infoRec->ValidatePolyRectangle) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyArcMask)
-        (*infoRec->ValidatePolyArc) (pGC, changes, pDraw);
-
-    if (changes & infoRec->FillPolygonMask)
-        (*infoRec->ValidateFillPolygon) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyFillRectMask)
-        (*infoRec->ValidatePolyFillRect) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyFillArcMask)
-        (*infoRec->ValidatePolyFillArc) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyGlyphBltMask)
-        (*infoRec->ValidatePolyGlyphBlt) (pGC, changes, pDraw);
-
-    if (changes & infoRec->ImageGlyphBltMask)
-        (*infoRec->ValidateImageGlyphBlt) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyText8Mask)
-        (*infoRec->ValidatePolyText8) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PolyText16Mask)
-        (*infoRec->ValidatePolyText16) (pGC, changes, pDraw);
-
-    if (changes & infoRec->ImageText8Mask)
-        (*infoRec->ValidateImageText8) (pGC, changes, pDraw);
-
-    if (changes & infoRec->ImageText16Mask)
-        (*infoRec->ValidateImageText16) (pGC, changes, pDraw);
-
-    if (changes & infoRec->PushPixelsMask)
-        (*infoRec->ValidatePushPixels) (pGC, changes, pDraw);
-}
-
-static void
-XAADestroyGC(GCPtr pGC)
-{
-    XAA_GC_FUNC_PROLOGUE(pGC);
-
-    if (pGCPriv->XAAOps != &XAAFallbackOps)
-        free(pGCPriv->XAAOps);
-
-    free(pGCPriv->DashPattern);
-    pGCPriv->flags = 0;
-
-    (*pGC->funcs->DestroyGC) (pGC);
-    XAA_GC_FUNC_EPILOGUE(pGC);
-}
-
-static void
-XAAChangeGC(GCPtr pGC, unsigned long mask)
-{
-    XAA_GC_FUNC_PROLOGUE(pGC);
-    (*pGC->funcs->ChangeGC) (pGC, mask);
-    XAA_GC_FUNC_EPILOGUE(pGC);
-
-    /* we have to assume that shared memory pixmaps are dirty 
-       because we can't wrap all operations on them */
-
-    if ((mask & GCTile) && !pGC->tileIsPixel &&
-        PIXMAP_IS_SHARED(pGC->tile.pixmap)) {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-        pPixPriv->flags |= DIRTY;
-    }
-
-    if ((mask & GCStipple) && PIXMAP_IS_SHARED(pGC->stipple)) {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-
-        pPixPriv->flags |= DIRTY;
-    }
-}
-
-static void
-XAACopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
-{
-    XAA_GC_FUNC_PROLOGUE(pGCDst);
-    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
-    XAA_GC_FUNC_EPILOGUE(pGCDst);
-}
-
-static void
-XAAChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
-{
-    XAA_GC_FUNC_PROLOGUE(pGC);
-    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
-    XAA_GC_FUNC_EPILOGUE(pGC);
-}
-
-static void
-XAACopyClip(GCPtr pgcDst, GCPtr pgcSrc)
-{
-    XAA_GC_FUNC_PROLOGUE(pgcDst);
-    (*pgcDst->funcs->CopyClip) (pgcDst, pgcSrc);
-    XAA_GC_FUNC_EPILOGUE(pgcDst);
-}
-
-static void
-XAADestroyClip(GCPtr pGC)
-{
-    XAA_GC_FUNC_PROLOGUE(pGC);
-    (*pGC->funcs->DestroyClip) (pGC);
-    XAA_GC_FUNC_EPILOGUE(pGC);
-}
-
-/**** Pixmap Wrappers ****/
-
-static void
-XAAFillSpansPixmap(DrawablePtr pDraw,
-                   GC * pGC,
-                   int nInit, DDXPointPtr pptInit, int *pwidthInit, int fSorted)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->FillSpans) (pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAASetSpansPixmap(DrawablePtr pDraw,
-                  GCPtr pGC,
-                  char *pcharsrc,
-                  register DDXPointPtr ppt,
-                  int *pwidth, int nspans, int fSorted)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->SetSpans) (pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPutImagePixmap(DrawablePtr pDraw,
-                  GCPtr pGC,
-                  int depth,
-                  int x, int y, int w, int h,
-                  int leftPad, int format, char *pImage)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
-                           leftPad, format, pImage);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static RegionPtr
-XAACopyAreaPixmap(DrawablePtr pSrc,
-                  DrawablePtr pDst,
-                  GC * pGC,
-                  int srcx, int srcy, int width, int height, int dstx, int dsty)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    RegionPtr ret;
-
-    if (infoRec->pScrn->vtSema &&
-        ((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))) {
-        if (infoRec->ReadPixmap && (pGC->alu == GXcopy) &&
-            (pSrc->bitsPerPixel == pDst->bitsPerPixel) &&
-            ((pGC->planemask & infoRec->FullPlanemasks[pSrc->depth - 1])
-             == infoRec->FullPlanemasks[pSrc->depth - 1])) {
-            XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr) (pDst));
-
-            pixPriv->flags |= DIRTY;
-
-            return (XAABitBlt(pSrc, pDst, pGC,
-                              srcx, srcy, width, height, dstx, dsty,
-                              XAADoImageRead, 0L));
-        }
-        else if (infoRec->NeedToSync) {
-            (*infoRec->Sync) (infoRec->pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-    }
-
-    {
-        XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
-        ret = (*pGC->ops->CopyArea) (pSrc, pDst,
-                                     pGC, srcx, srcy, width, height, dstx,
-                                     dsty);
-        XAA_PIXMAP_OP_EPILOGUE(pGC);
-    }
-    return ret;
-}
-
-static RegionPtr
-XAACopyPlanePixmap(DrawablePtr pSrc,
-                   DrawablePtr pDst,
-                   GCPtr pGC,
-                   int srcx, int srcy,
-                   int width, int height,
-                   int dstx, int dsty, unsigned long bitPlane)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    RegionPtr ret;
-
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDst);
-
-    if (infoRec->pScrn->vtSema &&
-        ((pSrc->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pSrc))) {
-        if (infoRec->NeedToSync) {
-            (*infoRec->Sync) (infoRec->pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-    }
-
-    ret = (*pGC->ops->CopyPlane) (pSrc, pDst,
-                                  pGC, srcx, srcy, width, height, dstx, dsty,
-                                  bitPlane);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static void
-XAAPolyPointPixmap(DrawablePtr pDraw,
-                   GCPtr pGC, int mode, int npt, xPoint * pptInit)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyPoint) (pDraw, pGC, mode, npt, pptInit);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolylinesPixmap(DrawablePtr pDraw,
-                   GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->Polylines) (pDraw, pGC, mode, npt, pptInit);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolySegmentPixmap(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment * pSeg)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolySegment) (pDraw, pGC, nseg, pSeg);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyRectanglePixmap(DrawablePtr pDraw,
-                       GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyRectangle) (pDraw, pGC, nRectsInit, pRectsInit);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyArcPixmap(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyArc) (pDraw, pGC, narcs, parcs);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAFillPolygonPixmap(DrawablePtr pDraw,
-                     GCPtr pGC,
-                     int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyFillRectPixmap(DrawablePtr pDraw,
-                      GCPtr pGC, int nrectFill, xRectangle *prectInit)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyFillArcPixmap(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, parcs);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static int
-XAAPolyText8Pixmap(DrawablePtr pDraw,
-                   GCPtr pGC, int x, int y, int count, char *chars)
-{
-    int ret;
-
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    ret = (*pGC->ops->PolyText8) (pDraw, pGC, x, y, count, chars);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static int
-XAAPolyText16Pixmap(DrawablePtr pDraw,
-                    GCPtr pGC, int x, int y, int count, unsigned short *chars)
-{
-    int ret;
-
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    ret = (*pGC->ops->PolyText16) (pDraw, pGC, x, y, count, chars);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-    return ret;
-}
-
-static void
-XAAImageText8Pixmap(DrawablePtr pDraw,
-                    GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageText8) (pDraw, pGC, x, y, count, chars);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAImageText16Pixmap(DrawablePtr pDraw,
-                     GCPtr pGC, int x, int y, int count, unsigned short *chars)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageText16) (pDraw, pGC, x, y, count, chars);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAImageGlyphBltPixmap(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int xInit, int yInit,
-                       unsigned int nglyph,
-                       CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->ImageGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph,
-                                ppci, pglyphBase);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPolyGlyphBltPixmap(DrawablePtr pDraw,
-                      GCPtr pGC,
-                      int xInit, int yInit,
-                      unsigned int nglyph,
-                      CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PolyGlyphBlt) (pDraw, pGC, xInit, yInit, nglyph,
-                               ppci, pglyphBase);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-static void
-XAAPushPixelsPixmap(GCPtr pGC,
-                    PixmapPtr pBitMap,
-                    DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
-{
-    XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw);
-    (*pGC->ops->PushPixels) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
-    XAA_PIXMAP_OP_EPILOGUE(pGC);
-}
-
-GCOps XAAPixmapOps = {
-    XAAFillSpansPixmap, XAASetSpansPixmap,
-    XAAPutImagePixmap, XAACopyAreaPixmap,
-    XAACopyPlanePixmap, XAAPolyPointPixmap,
-    XAAPolylinesPixmap, XAAPolySegmentPixmap,
-    XAAPolyRectanglePixmap, XAAPolyArcPixmap,
-    XAAFillPolygonPixmap, XAAPolyFillRectPixmap,
-    XAAPolyFillArcPixmap, XAAPolyText8Pixmap,
-    XAAPolyText16Pixmap, XAAImageText8Pixmap,
-    XAAImageText16Pixmap, XAAImageGlyphBltPixmap,
-    XAAPolyGlyphBltPixmap, XAAPushPixelsPixmap,
-};
diff --git a/xorg-server/hw/xfree86/xaa/xaaGCmisc.c b/xorg-server/hw/xfree86/xaa/xaaGCmisc.c
deleted file mode 100644
index ca69aae74..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaGCmisc.c
+++ /dev/null
@@ -1,412 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include <X11/fonts/fontstruct.h>
-#include "dixfontstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "migc.h"
-#include "mi.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-
-void
-XAAValidateCopyArea(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (infoRec->CopyArea &&
-        CHECK_PLANEMASK(pGC, infoRec->CopyAreaFlags) &&
-        CHECK_ROP(pGC, infoRec->CopyAreaFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->CopyAreaFlags)
-        )
-        pGC->ops->CopyArea = infoRec->CopyArea;
-    else
-        pGC->ops->CopyArea = XAAFallbackOps.CopyArea;
-}
-
-void
-XAAValidatePutImage(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (infoRec->PutImage &&
-        CHECK_PLANEMASK(pGC, infoRec->PutImageFlags) &&
-        CHECK_ROP(pGC, infoRec->PutImageFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->PutImageFlags) &&
-        CHECK_COLORS(pGC, infoRec->PutImageFlags)
-        )
-        pGC->ops->PutImage = infoRec->PutImage;
-    else
-        pGC->ops->PutImage = XAAFallbackOps.PutImage;
-}
-
-void
-XAAValidateCopyPlane(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (infoRec->CopyPlane &&
-        CHECK_PLANEMASK(pGC, infoRec->CopyPlaneFlags) &&
-        CHECK_ROP(pGC, infoRec->CopyPlaneFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->CopyPlaneFlags) &&
-        CHECK_COLORS(pGC, infoRec->CopyPlaneFlags)
-        )
-        pGC->ops->CopyPlane = infoRec->CopyPlane;
-    else
-        pGC->ops->CopyPlane = XAAFallbackOps.CopyPlane;
-}
-
-void
-XAAValidatePushPixels(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (infoRec->PushPixelsSolid &&
-        (pGC->fillStyle == FillSolid) &&
-        CHECK_PLANEMASK(pGC, infoRec->PushPixelsFlags) &&
-        CHECK_ROP(pGC, infoRec->PushPixelsFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->PushPixelsFlags) &&
-        CHECK_FG(pGC, infoRec->PushPixelsFlags) &&
-        (!(infoRec->PushPixelsFlags & TRANSPARENCY_GXCOPY_ONLY) ||
-         (pGC->alu == GXcopy))
-        )
-        pGC->ops->PushPixels = infoRec->PushPixelsSolid;
-    else
-        pGC->ops->PushPixels = XAAFallbackOps.PushPixels;
-
-}
-
-/* We make the assumption that the FillSpans, PolyFillRect, FillPolygon
-   and PolyFillArc functions are linked in a way that they all have 
-   the same rop/color/planemask restrictions. If the driver provides 
-   a GC level replacement for these, it will need to supply a new 
-   Validate functions if it breaks this assumption */
-
-void
-XAAValidateFillSpans(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (pGC->fillStyle != FillTiled)
-        changes &= ~GCTile;
-    if ((pGC->fillStyle == FillTiled) || (pGC->fillStyle == FillSolid))
-        changes &= ~GCStipple;
-    if (!changes)
-        return;
-
-    pGC->ops->FillSpans = XAAFallbackOps.FillSpans;
-    pGC->ops->PolyFillRect = XAAFallbackOps.PolyFillRect;
-    pGC->ops->FillPolygon = XAAFallbackOps.FillPolygon;
-    pGC->ops->PolyFillArc = XAAFallbackOps.PolyFillArc;
-
-    switch (pGC->fillStyle) {
-    case FillSolid:
-        if (infoRec->FillSpansSolid &&
-            CHECK_PLANEMASK(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_ROP(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_FG(pGC, infoRec->FillSpansSolidFlags)
-            ) {
-            pGC->ops->FillSpans = infoRec->FillSpansSolid;
-            pGC->ops->PolyFillRect = infoRec->PolyFillRectSolid;
-            pGC->ops->FillPolygon = infoRec->FillPolygonSolid;
-            pGC->ops->PolyFillArc = infoRec->PolyFillArcSolid;
-        }
-        break;
-        /* The [Stippled/OpaqueStippled/Tiled]FillChooser 
-           functions do the validating */
-    case FillStippled:
-        if (infoRec->FillSpansStippled) {
-            pGC->ops->FillSpans = infoRec->FillSpansStippled;
-            pGC->ops->PolyFillRect = infoRec->PolyFillRectStippled;
-            if (infoRec->FillPolygonStippled)
-                pGC->ops->FillPolygon = infoRec->FillPolygonStippled;
-            else
-                pGC->ops->FillPolygon = miFillPolygon;
-            pGC->ops->PolyFillArc = miPolyFillArc;
-        }
-        break;
-    case FillOpaqueStippled:
-        if (infoRec->FillSpansOpaqueStippled) {
-            pGC->ops->FillSpans = infoRec->FillSpansOpaqueStippled;
-            pGC->ops->PolyFillRect = infoRec->PolyFillRectOpaqueStippled;
-            if (infoRec->FillPolygonOpaqueStippled)
-                pGC->ops->FillPolygon = infoRec->FillPolygonOpaqueStippled;
-            else
-                pGC->ops->FillPolygon = miFillPolygon;
-            pGC->ops->PolyFillArc = miPolyFillArc;
-        }
-        break;
-    case FillTiled:
-        if (infoRec->FillSpansTiled) {
-            pGC->ops->FillSpans = infoRec->FillSpansTiled;
-            pGC->ops->PolyFillRect = infoRec->PolyFillRectTiled;
-            if (infoRec->FillPolygonTiled)
-                pGC->ops->FillPolygon = infoRec->FillPolygonTiled;
-            else
-                pGC->ops->FillPolygon = miFillPolygon;
-            pGC->ops->PolyFillArc = miPolyFillArc;
-        }
-        break;
-    default:
-        return;
-    }
-}
-
-/* We make the assumption that these Text8/16 and GlyphBlt functions
-   are linked in a way that they all have the same rop/color/planemask
-   restrictions. If the driver provides a GC level replacement for
-   these, it will need to supply a new Validate functions if it breaks
-   this assumption */
-
-void
-XAAValidatePolyGlyphBlt(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    Bool BigFont = FALSE;
-
-    pGC->ops->PolyText8 = XAAFallbackOps.PolyText8;
-    pGC->ops->PolyText16 = XAAFallbackOps.PolyText16;
-    pGC->ops->PolyGlyphBlt = XAAFallbackOps.PolyGlyphBlt;
-
-    if (!pGC->font)
-        return;
-    if (pGC->fillStyle != FillSolid)
-        return;
-
-    if ((FONTMAXBOUNDS(pGC->font, rightSideBearing) -
-         FONTMINBOUNDS(pGC->font, leftSideBearing) > 32))
-        BigFont = TRUE;
-
-    /* no funny business */
-    if ((FONTMINBOUNDS(pGC->font, characterWidth) <= 0) ||
-        ((FONTASCENT(pGC->font) + FONTDESCENT(pGC->font)) <= 0))
-        return;
-
-    /* Check for TE Fonts */
-    if (!TERMINALFONT(pGC->font) || BigFont) {
-        if (infoRec->PolyGlyphBltNonTE &&
-            CHECK_PLANEMASK(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
-            CHECK_ROP(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
-            CHECK_FG(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
-            (!(infoRec->PolyGlyphBltNonTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
-             (pGC->alu == GXcopy))
-            ) {
-            pGC->ops->PolyText8 = infoRec->PolyText8NonTE;
-            pGC->ops->PolyText16 = infoRec->PolyText16NonTE;
-            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltNonTE;
-        }
-    }
-    else {
-        if (infoRec->PolyGlyphBltTE &&
-            CHECK_PLANEMASK(pGC, infoRec->PolyGlyphBltTEFlags) &&
-            CHECK_ROP(pGC, infoRec->PolyGlyphBltTEFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->PolyGlyphBltNonTEFlags) &&
-            CHECK_FG(pGC, infoRec->PolyGlyphBltTEFlags) &&
-            (!(infoRec->PolyGlyphBltTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
-             (pGC->alu == GXcopy))
-            ) {
-            pGC->ops->PolyText8 = infoRec->PolyText8TE;
-            pGC->ops->PolyText16 = infoRec->PolyText16TE;
-            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltTE;
-        }
-    }
-}
-
-void
-XAAValidateImageGlyphBlt(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    Bool BigFont = FALSE;
-
-    pGC->ops->ImageText8 = XAAFallbackOps.ImageText8;
-    pGC->ops->ImageText16 = XAAFallbackOps.ImageText16;
-    pGC->ops->ImageGlyphBlt = XAAFallbackOps.ImageGlyphBlt;
-
-    if (!pGC->font)
-        return;
-
-    if ((FONTMAXBOUNDS(pGC->font, rightSideBearing) -
-         FONTMINBOUNDS(pGC->font, leftSideBearing) > 32))
-        BigFont = TRUE;
-
-    /* no funny business */
-    if ((FONTMINBOUNDS(pGC->font, characterWidth) <= 0) ||
-        ((FONTASCENT(pGC->font) + FONTDESCENT(pGC->font)) <= 0))
-        return;
-
-    /* Check for TE Fonts */
-    if (!TERMINALFONT(pGC->font) || BigFont || (pGC->depth == 32)) {
-        if (infoRec->ImageGlyphBltNonTE &&
-            CHECK_PLANEMASK(pGC, infoRec->ImageGlyphBltNonTEFlags) &&
-            CHECK_FG(pGC, infoRec->ImageGlyphBltNonTEFlags) &&
-            infoRec->SetupForSolidFill &&
-            CHECK_PLANEMASK(pGC, infoRec->SolidFillFlags) &&
-            CHECK_BG(pGC, infoRec->SolidFillFlags)) {
-            pGC->ops->ImageText8 = infoRec->ImageText8NonTE;
-            pGC->ops->ImageText16 = infoRec->ImageText16NonTE;
-            pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltNonTE;
-        }
-    }
-    else if (infoRec->ImageGlyphBltTE &&
-             CHECK_PLANEMASK(pGC, infoRec->ImageGlyphBltTEFlags)) {
-        if (!(infoRec->ImageGlyphBltTEFlags & TRANSPARENCY_ONLY) &&
-            CHECK_COLORS(pGC, infoRec->ImageGlyphBltTEFlags)) {
-            pGC->ops->ImageText8 = infoRec->ImageText8TE;
-            pGC->ops->ImageText16 = infoRec->ImageText16TE;
-            pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltTE;
-        }
-        else {
-            if (CHECK_FG(pGC, infoRec->ImageGlyphBltTEFlags) &&
-                infoRec->SetupForSolidFill &&
-                CHECK_PLANEMASK(pGC, infoRec->SolidFillFlags) &&
-                CHECK_BG(pGC, infoRec->SolidFillFlags)) {
-                pGC->ops->ImageText8 = infoRec->ImageText8TE;
-                pGC->ops->ImageText16 = infoRec->ImageText16TE;
-                pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltTE;
-            }
-        }
-    }
-}
-
-void
-XAAValidatePolylines(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
-                                                   XAAGetGCKey());
-
-    if (pGC->lineStyle == LineSolid)
-        changes &= ~GCDashList;
-    if (!changes)
-        return;
-
-    pGC->ops->PolySegment = XAAFallbackOps.PolySegment;
-    pGC->ops->Polylines = XAAFallbackOps.Polylines;
-    pGC->ops->PolyRectangle = XAAFallbackOps.PolyRectangle;
-    pGC->ops->PolyArc = XAAFallbackOps.PolyArc;
-
-    if ((pGC->ops->FillSpans != XAAFallbackOps.FillSpans) &&
-        (pGC->lineWidth > 0)) {
-
-        pGC->ops->PolyArc = miPolyArc;
-        pGC->ops->PolySegment = miPolySegment;
-        pGC->ops->PolyRectangle = miPolyRectangle;
-        if (pGC->lineStyle == LineSolid)
-            pGC->ops->Polylines = miWideLine;
-        else
-            pGC->ops->Polylines = miWideDash;
-    }
-
-    if ((pGC->lineWidth == 0) && (pGC->fillStyle == FillSolid)) {
-
-        if (pGC->lineStyle == LineSolid) {
-
-            if (infoRec->PolyRectangleThinSolid &&
-                CHECK_PLANEMASK(pGC, infoRec->PolyRectangleThinSolidFlags) &&
-                CHECK_ROP(pGC, infoRec->PolyRectangleThinSolidFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolyRectangleThinSolidFlags) &&
-                CHECK_FG(pGC, infoRec->PolyRectangleThinSolidFlags)) {
-
-                pGC->ops->PolyRectangle = infoRec->PolyRectangleThinSolid;
-            }
-
-            if (infoRec->PolySegmentThinSolid &&
-                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinSolidFlags) &&
-                CHECK_ROP(pGC, infoRec->PolySegmentThinSolidFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinSolidFlags) &&
-                CHECK_FG(pGC, infoRec->PolySegmentThinSolidFlags)) {
-
-                pGC->ops->PolySegment = infoRec->PolySegmentThinSolid;
-            }
-
-            if (infoRec->PolylinesThinSolid &&
-                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinSolidFlags) &&
-                CHECK_ROP(pGC, infoRec->PolylinesThinSolidFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolylinesThinSolidFlags) &&
-                CHECK_FG(pGC, infoRec->PolylinesThinSolidFlags)) {
-
-                pGC->ops->Polylines = infoRec->PolylinesThinSolid;
-            }
-        }
-        else if ((pGC->lineStyle == LineOnOffDash) && pGCPriv->DashPattern) {
-
-            if (infoRec->PolySegmentThinDashed &&
-                !(infoRec->PolySegmentThinDashedFlags & NO_TRANSPARENCY) &&
-                ((pGC->alu == GXcopy) || !(infoRec->PolySegmentThinDashedFlags &
-                                           TRANSPARENCY_GXCOPY_ONLY)) &&
-                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_ROP(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_FG(pGC, infoRec->PolySegmentThinDashedFlags)) {
-
-                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
-            }
-
-            if (infoRec->PolylinesThinDashed &&
-                !(infoRec->PolylinesThinDashedFlags & NO_TRANSPARENCY) &&
-                ((pGC->alu == GXcopy) || !(infoRec->PolylinesThinDashedFlags &
-                                           TRANSPARENCY_GXCOPY_ONLY)) &&
-                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_ROP(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_FG(pGC, infoRec->PolylinesThinDashedFlags)) {
-
-                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
-            }
-
-            if (pGC->ops->Polylines != XAAFallbackOps.Polylines)
-                pGC->ops->PolyRectangle = miPolyRectangle;
-
-        }
-        else if (pGCPriv->DashPattern && (pGC->depth != 32)) {
-            /* LineDoubleDash */
-            if (infoRec->PolySegmentThinDashed &&
-                !(infoRec->PolySegmentThinDashedFlags & TRANSPARENCY_ONLY) &&
-                CHECK_PLANEMASK(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_ROP(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolySegmentThinDashedFlags) &&
-                CHECK_COLORS(pGC, infoRec->PolySegmentThinDashedFlags)) {
-
-                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
-            }
-
-            if (infoRec->PolylinesThinDashed &&
-                !(infoRec->PolylinesThinDashedFlags & TRANSPARENCY_ONLY) &&
-                CHECK_PLANEMASK(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_ROP(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_ROPSRC(pGC, infoRec->PolylinesThinDashedFlags) &&
-                CHECK_COLORS(pGC, infoRec->PolylinesThinDashedFlags)) {
-
-                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
-            }
-
-            if (pGC->ops->Polylines != XAAFallbackOps.Polylines)
-                pGC->ops->PolyRectangle = miPolyRectangle;
-
-        }
-    }
-
-    if (infoRec->PolylinesWideSolid &&
-        (pGC->lineWidth > 0) &&
-        (pGC->fillStyle == FillSolid) &&
-        (pGC->lineStyle == LineSolid) &&
-        CHECK_PLANEMASK(pGC, infoRec->PolylinesWideSolidFlags) &&
-        CHECK_ROP(pGC, infoRec->PolylinesWideSolidFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->PolylinesWideSolidFlags) &&
-        CHECK_FG(pGC, infoRec->PolylinesWideSolidFlags)) {
-
-        pGC->ops->Polylines = infoRec->PolylinesWideSolid;
-    }
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaImage.c b/xorg-server/hw/xfree86/xaa/xaaImage.c
deleted file mode 100644
index 4457c9efa..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaImage.c
+++ /dev/null
@@ -1,534 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-#include "servermd.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "mi.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-void
-XAAMoveDWORDS_FixedBase(register CARD32 *dest,
-                        register CARD32 *src, register int dwords)
-{
-    while (dwords & ~0x03) {
-        *dest = *src;
-        *dest = *(src + 1);
-        *dest = *(src + 2);
-        *dest = *(src + 3);
-        dwords -= 4;
-        src += 4;
-    }
-
-    if (!dwords)
-        return;
-    *dest = *src;
-    if (dwords == 1)
-        return;
-    *dest = *(src + 1);
-    if (dwords == 2)
-        return;
-    *dest = *(src + 2);
-}
-
-void
-XAAMoveDWORDS(register CARD32 *dest, register CARD32 *src, register int dwords)
-{
-    while (dwords & ~0x03) {
-        *dest = *src;
-        *(dest + 1) = *(src + 1);
-        *(dest + 2) = *(src + 2);
-        *(dest + 3) = *(src + 3);
-        src += 4;
-        dest += 4;
-        dwords -= 4;
-    }
-    if (!dwords)
-        return;
-    *dest = *src;
-    if (dwords == 1)
-        return;
-    *(dest + 1) = *(src + 1);
-    if (dwords == 2)
-        return;
-    *(dest + 2) = *(src + 2);
-}
-
-void
-XAAMoveDWORDS_FixedSrc(register CARD32 *dest,
-                       register CARD32 *src, register int dwords)
-{
-    while (dwords & ~0x03) {
-        *dest = *src;
-        *(dest + 1) = *src;
-        *(dest + 2) = *src;
-        *(dest + 3) = *src;
-        dest += 4;
-        dwords -= 4;
-    }
-    if (!dwords)
-        return;
-    *dest = *src;
-    if (dwords == 1)
-        return;
-    *(dest + 1) = *src;
-    if (dwords == 2)
-        return;
-    *(dest + 2) = *src;
-}
-
-static void
-XAAWritePixmap32To24(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *srcInit, int srcwidth,       /* bytes */
-                     int rop, unsigned int planemask, int trans)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int count, dwords = bytes_to_int32(w * 3);
-    CARD32 *src, *dst;
-    Bool PlusOne = FALSE;
-
-    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
-        ((dwords * h) & 0x01)) {
-        PlusOne = TRUE;
-    }
-
-    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, trans, 24, 24);
-    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, 0);
-
-    if (dwords > infoRec->ImageWriteRange) {
-        dst = (CARD32 *) infoRec->ImageWriteBase;
-        while (h--) {
-            src = (CARD32 *) srcInit;
-            count = w;
-
-            while (count >= 4) {
-                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
-                *dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
-                *dst = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);
-                src += 4;
-                count -= 4;
-            }
-            switch (count) {
-            case 0:
-                break;
-            case 1:
-                *dst = src[0];
-                break;
-            case 2:
-                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
-                *dst = src[1] >> 8;
-                break;
-            default:
-                *dst = (src[0] & 0x00ffffff) | (src[1] << 24);
-                *dst = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
-                *dst = src[2] >> 16;
-                break;
-            }
-            srcInit += srcwidth;
-        }
-    }
-    else {
-        while (h--) {
-            dst = (CARD32 *) infoRec->ImageWriteBase;
-            src = (CARD32 *) srcInit;
-            count = w;
-
-            while (count >= 4) {
-                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
-                dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
-                dst[2] = ((src[2] >> 16) & 0x000000ff) | (src[3] << 8);
-                dst += 3;
-                src += 4;
-                count -= 4;
-            }
-            switch (count) {
-            case 0:
-                break;
-            case 1:
-                dst[0] = src[0];
-                break;
-            case 2:
-                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
-                dst[1] = src[1] >> 8;
-                break;
-            default:
-                dst[0] = (src[0] & 0x00ffffff) | (src[1] << 24);
-                dst[1] = ((src[1] >> 8) & 0x0000ffff) | (src[2] << 16);
-                dst[2] = src[2] >> 16;
-                break;
-            }
-            srcInit += srcwidth;
-        }
-    }
-
-    if (PlusOne) {
-        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
-
-        *base = 0x00000000;
-    }
-
-    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-
-}
-
-void
-XAAWritePixmap(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *src, int srcwidth, /* bytes */
-               int rop, unsigned int planemask, int trans, int bpp, int depth)
-{
-    XAAInfoRecPtr infoRec;
-    int dwords, skipleft, Bpp;
-    Bool beCareful, PlusOne;
-
-    if ((bpp == 32) && (pScrn->bitsPerPixel == 24)) {
-        XAAWritePixmap32To24(pScrn, x, y, w, h, src, srcwidth,
-                             rop, planemask, trans);
-        return;
-    }
-
-    infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    beCareful = PlusOne = FALSE;
-    Bpp = bpp >> 3;
-
-    if ((skipleft = (long) src & 0x03L)) {
-        if (!(infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING)) {
-            skipleft = 0;
-            beCareful = TRUE;
-            goto BAD_ALIGNMENT;
-        }
-
-        if (Bpp == 3)
-            skipleft = 4 - skipleft;
-        else
-            skipleft /= Bpp;
-
-        if ((x < skipleft) && !(infoRec->ImageWriteFlags &
-                                LEFT_EDGE_CLIPPING_NEGATIVE_X)) {
-            skipleft = 0;
-            beCareful = TRUE;
-            goto BAD_ALIGNMENT;
-        }
-
-        x -= skipleft;
-        w += skipleft;
-
-        if (Bpp == 3)
-            src -= 3 * skipleft;
-        else                    /* is this Alpha friendly ? */
-            src = (unsigned char *) ((long) src & ~0x03L);
-    }
-
- BAD_ALIGNMENT:
-
-    dwords = bytes_to_int32(w * Bpp);
-
-    if ((infoRec->ImageWriteFlags & CPU_TRANSFER_PAD_QWORD) &&
-        ((dwords * h) & 0x01)) {
-        PlusOne = TRUE;
-    }
-
-    (*infoRec->SetupForImageWrite) (pScrn, rop, planemask, trans, bpp, depth);
-    (*infoRec->SubsequentImageWriteRect) (pScrn, x, y, w, h, skipleft);
-
-    if (beCareful) {
-        /* in cases with bad alignment we have to be careful not
-           to read beyond the end of the source */
-        if (((x * Bpp) + (dwords << 2)) > srcwidth)
-            h--;
-        else
-            beCareful = FALSE;
-    }
-
-    if (dwords > infoRec->ImageWriteRange) {
-        while (h--) {
-            XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
-                                    (CARD32 *) src, dwords);
-            src += srcwidth;
-        }
-        if (beCareful) {
-            int shift = ((long) src & 0x03L) << 3;
-
-            if (--dwords)
-                XAAMoveDWORDS_FixedBase((CARD32 *) infoRec->ImageWriteBase,
-                                        (CARD32 *) src, dwords);
-            src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
-            *((CARD32 *) infoRec->ImageWriteBase) = *((CARD32 *) src) >> shift;
-        }
-    }
-    else {
-        if (srcwidth == (dwords << 2)) {
-            int decrement = infoRec->ImageWriteRange / dwords;
-
-            while (h > decrement) {
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords * decrement);
-                src += (srcwidth * decrement);
-                h -= decrement;
-            }
-            if (h) {
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords * h);
-                if (beCareful)
-                    src += (srcwidth * h);
-            }
-        }
-        else {
-            while (h--) {
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords);
-                src += srcwidth;
-            }
-        }
-
-        if (beCareful) {
-            int shift = ((long) src & 0x03L) << 3;
-
-            if (--dwords)
-                XAAMoveDWORDS((CARD32 *) infoRec->ImageWriteBase,
-                              (CARD32 *) src, dwords);
-            src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
-
-            ((CARD32 *) infoRec->ImageWriteBase)[dwords] =
-                *((CARD32 *) src) >> shift;
-        }
-    }
-
-    if (PlusOne) {
-        CARD32 *base = (CARD32 *) infoRec->ImageWriteBase;
-
-        *base = 0x00000000;
-    }
-
-    if (infoRec->ImageWriteFlags & SYNC_AFTER_IMAGE_WRITE)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAWritePixmapScanline(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned char *src, int srcwidth, /* bytes */
-                       int rop,
-                       unsigned int planemask, int trans, int bpp, int depth)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int dwords, skipleft, bufferNo = 0, Bpp = bpp >> 3;
-    Bool beCareful = FALSE;
-    CARD32 *base;
-
-    if ((skipleft = (long) src & 0x03L)) {
-        if (!(infoRec->ScanlineImageWriteFlags & LEFT_EDGE_CLIPPING)) {
-            skipleft = 0;
-            beCareful = TRUE;
-            goto BAD_ALIGNMENT;
-        }
-
-        if (Bpp == 3)
-            skipleft = 4 - skipleft;
-        else
-            skipleft /= Bpp;
-
-        if ((x < skipleft) && !(infoRec->ScanlineImageWriteFlags &
-                                LEFT_EDGE_CLIPPING_NEGATIVE_X)) {
-            skipleft = 0;
-            beCareful = TRUE;
-            goto BAD_ALIGNMENT;
-        }
-
-        x -= skipleft;
-        w += skipleft;
-
-        if (Bpp == 3)
-            src -= 3 * skipleft;
-        else
-            src = (unsigned char *) ((long) src & ~0x03L);
-    }
-
- BAD_ALIGNMENT:
-
-    dwords = bytes_to_int32(w * Bpp);
-
-    (*infoRec->SetupForScanlineImageWrite) (pScrn, rop, planemask, trans, bpp,
-                                            depth);
-    (*infoRec->SubsequentScanlineImageWriteRect) (pScrn, x, y, w, h, skipleft);
-
-    if (beCareful) {
-        /* in cases with bad alignment we have to be careful not
-           to read beyond the end of the source */
-        if (((x * Bpp) + (dwords << 2)) > srcwidth)
-            h--;
-        else
-            beCareful = FALSE;
-    }
-
-    while (h--) {
-        base = (CARD32 *) infoRec->ScanlineImageWriteBuffers[bufferNo];
-        XAAMoveDWORDS(base, (CARD32 *) src, dwords);
-        (*infoRec->SubsequentImageWriteScanline) (pScrn, bufferNo++);
-        src += srcwidth;
-        if (bufferNo >= infoRec->NumScanlineImageWriteBuffers)
-            bufferNo = 0;
-    }
-
-    if (beCareful) {
-        int shift = ((long) src & 0x03L) << 3;
-
-        base = (CARD32 *) infoRec->ScanlineImageWriteBuffers[bufferNo];
-        if (--dwords)
-            XAAMoveDWORDS(base, (CARD32 *) src, dwords);
-        src = (unsigned char *) ((long) (src + (dwords << 2)) & ~0x03L);
-
-        base[dwords] = *((CARD32 *) src) >> shift;
-        (*infoRec->SubsequentImageWriteScanline) (pScrn, bufferNo);
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAPutImage(DrawablePtr pDraw,
-            GCPtr pGC,
-            int depth,
-            int x, int y, int w, int h, int leftPad, int format, char *pImage)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int bpp = BitsPerPixel(depth);
-    Bool depthBug = FALSE;
-
-    if (!w || !h)
-        return;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    depthBug = XAA_DEPTH_BUG(pGC);
-
-    if (((format == ZPixmap) && infoRec->WritePixmap &&
-         ((pDraw->bitsPerPixel == bpp) ||
-          ((pDraw->bitsPerPixel == 24) && (bpp == 32) &&
-           (infoRec->WritePixmapFlags & CONVERT_32BPP_TO_24BPP))) &&
-         CHECK_ROP(pGC, infoRec->WritePixmapFlags) &&
-         CHECK_ROPSRC(pGC, infoRec->WritePixmapFlags) &&
-         CHECK_PLANEMASK(pGC, infoRec->WritePixmapFlags) &&
-         CHECK_NO_GXCOPY(pGC, infoRec->WritePixmapFlags)) ||
-        ((format == XYBitmap) && !depthBug && infoRec->WriteBitmap &&
-         CHECK_ROP(pGC, infoRec->WriteBitmapFlags) &&
-         CHECK_ROPSRC(pGC, infoRec->WriteBitmapFlags) &&
-         CHECK_PLANEMASK(pGC, infoRec->WriteBitmapFlags) &&
-         CHECK_COLORS(pGC, infoRec->WriteBitmapFlags) &&
-         !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)) ||
-        ((format == XYPixmap) && !depthBug && infoRec->WriteBitmap &&
-         CHECK_ROP(pGC, infoRec->WriteBitmapFlags) &&
-         CHECK_ROPSRC(pGC, infoRec->WriteBitmapFlags) &&
-         !(infoRec->WriteBitmapFlags & NO_PLANEMASK) &&
-         !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))) {
-
-        int MaxBoxes = RegionNumRects(pGC->pCompositeClip);
-        BoxPtr pbox, pClipBoxes;
-        int nboxes, srcx, srcy, srcwidth;
-        xRectangle TheRect;
-
-        TheRect.x = pDraw->x + x;
-        TheRect.y = pDraw->y + y;
-        TheRect.width = w;
-        TheRect.height = h;
-
-        if (MaxBoxes > (infoRec->PreAllocSize / sizeof(BoxRec))) {
-            pClipBoxes = malloc(MaxBoxes * sizeof(BoxRec));
-            if (!pClipBoxes)
-                return;
-        }
-        else
-            pClipBoxes = (BoxPtr) infoRec->PreAllocMem;
-
-        nboxes = XAAGetRectClipBoxes(pGC, pClipBoxes, 1, &TheRect);
-        pbox = pClipBoxes;
-
-        if (format == XYBitmap) {
-            srcwidth = BitmapBytePad(leftPad + w);
-            while (nboxes--) {
-                srcx = pbox->x1 - TheRect.x + leftPad;
-                srcy = pbox->y1 - TheRect.y;
-                (*infoRec->WriteBitmap) (infoRec->pScrn, pbox->x1, pbox->y1,
-                                         pbox->x2 - pbox->x1,
-                                         pbox->y2 - pbox->y1,
-                                         (unsigned char *) pImage +
-                                         (srcwidth * srcy) + ((srcx >> 5) << 2),
-                                         srcwidth, srcx & 31, pGC->fgPixel,
-                                         pGC->bgPixel, pGC->alu,
-                                         pGC->planemask);
-                pbox++;
-            }
-        }
-        else if (format == ZPixmap) {
-            int Bpp = bpp >> 3;
-
-            srcwidth = PixmapBytePad(leftPad + w, depth);
-            while (nboxes--) {
-                srcx = pbox->x1 - TheRect.x + leftPad;
-                srcy = pbox->y1 - TheRect.y;
-                (*infoRec->WritePixmap) (infoRec->pScrn, pbox->x1, pbox->y1,
-                                         pbox->x2 - pbox->x1,
-                                         pbox->y2 - pbox->y1,
-                                         (unsigned char *) pImage +
-                                         (srcwidth * srcy) + (srcx * Bpp),
-                                         srcwidth, pGC->alu, pGC->planemask, -1,
-                                         Bpp << 3, depth);
-                pbox++;
-            }
-        }
-        else {                  /* XYPixmap */
-            int depth = pGC->depth;
-            int numBox, increment;
-            unsigned long i, mask;
-            BoxPtr pntBox;
-
-            srcwidth = BitmapBytePad(w + leftPad);
-            increment = h * srcwidth;
-            i = 1 << (depth - 1);
-            mask = ~0;
-
-            if ((infoRec->pScrn->overlayFlags & OVERLAY_8_32_PLANAR) &&
-                (pGC->depth == 8)) {
-                i = 0x80000000;
-                mask = 0xff000000;
-            }
-
-            for (; i & mask; i >>= 1, pImage += increment) {
-                if (i & pGC->planemask) {
-                    pntBox = pbox;
-                    numBox = nboxes;
-                    while (numBox--) {
-                        srcx = pntBox->x1 - TheRect.x + leftPad;
-                        srcy = pntBox->y1 - TheRect.y;
-                        (*infoRec->WriteBitmap) (infoRec->pScrn,
-                                                 pntBox->x1, pntBox->y1,
-                                                 pntBox->x2 - pntBox->x1,
-                                                 pntBox->y2 - pntBox->y1,
-                                                 (unsigned char *) pImage +
-                                                 (srcwidth * srcy) +
-                                                 ((srcx >> 5) << 2), srcwidth,
-                                                 srcx & 31, ~0, 0, pGC->alu, i);
-                        pntBox++;
-                    }
-                }
-            }
-
-        }
-
-        if (pClipBoxes != (BoxPtr) infoRec->PreAllocMem)
-            free(pClipBoxes);
-    }
-    else
-        XAAFallbackOps.PutImage(pDraw, pGC, depth, x, y, w, h, leftPad,
-                                format, pImage);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaInit.c b/xorg-server/hw/xfree86/xaa/xaaInit.c
deleted file mode 100644
index f146f3adf..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaInit.c
+++ /dev/null
@@ -1,635 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "miline.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "xf86fbman.h"
-#include "servermd.h"
-#ifdef COMPOSITE
-#include "cw.h"
-#endif
-
-#define MAX_PREALLOC_MEM	65536   /* MUST be >= 1024 */
-
-#define MIN_OFFPIX_SIZE		(320*200)
-
-static Bool XAACloseScreen(ScreenPtr pScreen);
-static void XAAGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
-                        unsigned int format, unsigned long planemask,
-                        char *pdstLine);
-static void XAAGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
-                        int *pwidth, int nspans, char *pdstStart);
-static PixmapPtr XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
-                                 unsigned usage_hint);
-static Bool XAADestroyPixmap(PixmapPtr pPixmap);
-static Bool XAAEnterVT(ScrnInfoPtr pScrn);
-static void XAALeaveVT(ScrnInfoPtr pScrn);
-static int XAASetDGAMode(ScrnInfoPtr pScrn, int num, DGADevicePtr devRet);
-static void XAAEnableDisableFBAccess(ScrnInfoPtr pScrn, Bool enable);
-static Bool XAAChangeWindowAttributes(WindowPtr pWin, unsigned long mask);
-
-static DevPrivateKeyRec XAAScreenKeyRec;
-
-#define XAAScreenKey (&XAAScreenKeyRec)
-static DevPrivateKeyRec XAAGCKeyRec;
-
-#define XAAGCKey (&XAAGCKeyRec)
-static DevPrivateKeyRec XAAPixmapKeyRec;
-
-#define XAAPixmapKey (&XAAPixmapKeyRec)
-
-DevPrivateKey
-XAAGetScreenKey(void)
-{
-    return XAAScreenKey;
-}
-
-DevPrivateKey
-XAAGetGCKey(void)
-{
-    return XAAGCKey;
-}
-
-DevPrivateKey
-XAAGetPixmapKey(void)
-{
-    return XAAPixmapKey;
-}
-
-/* temp kludge */
-static Bool SwitchedOut = FALSE;
-
-XAAInfoRecPtr
-XAACreateInfoRec(void)
-{
-    XAAInfoRecPtr infoRec;
-
-    infoRec = calloc(1, sizeof(XAAInfoRec));
-    if (infoRec)
-        infoRec->CachePixelGranularity = -1;
-
-    return infoRec;
-}
-
-void
-XAADestroyInfoRec(XAAInfoRecPtr infoRec)
-{
-    if (!infoRec)
-        return;
-
-    if (infoRec->ClosePixmapCache)
-        (*infoRec->ClosePixmapCache) (xf86ScrnToScreen(infoRec->pScrn));
-
-    free(infoRec->PreAllocMem);
-
-    free(infoRec->PixmapCachePrivate);
-
-    free(infoRec);
-}
-
-Bool
-XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
-{
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAScreenPtr pScreenPriv;
-    int i;
-    PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
-
-    /* Return successfully if no acceleration wanted */
-    if (!infoRec)
-        return TRUE;
-
-    if (!dixRegisterPrivateKey(&XAAGCKeyRec, PRIVATE_GC, sizeof(XAAGCRec)))
-        return FALSE;
-
-    if (!dixRegisterPrivateKey
-        (&XAAPixmapKeyRec, PRIVATE_PIXMAP, sizeof(XAAPixmapRec)))
-        return FALSE;
-
-    if (!dixRegisterPrivateKey(&XAAScreenKeyRec, PRIVATE_SCREEN, 0))
-        return FALSE;
-
-    if (!(pScreenPriv = malloc(sizeof(XAAScreenRec))))
-        return FALSE;
-
-    dixSetPrivate(&pScreen->devPrivates, XAAScreenKey, pScreenPriv);
-
-    if (!xf86FBManagerRunning(pScreen))
-        infoRec->Flags &= ~(PIXMAP_CACHE | OFFSCREEN_PIXMAPS);
-    if (!(infoRec->Flags & LINEAR_FRAMEBUFFER))
-        infoRec->Flags &= ~OFFSCREEN_PIXMAPS;
-
-    if (!infoRec->FullPlanemask) {      /* for backwards compatibility */
-        infoRec->FullPlanemask = (1 << pScrn->depth) - 1;
-        infoRec->FullPlanemasks[pScrn->depth - 1] = infoRec->FullPlanemask;
-    }
-
-    for (i = 0; i < 32; i++) {
-        if (!infoRec->FullPlanemasks[i])        /* keep any set by caller */
-            infoRec->FullPlanemasks[i] = (1 << (i + 1)) - 1;
-    }
-
-    if (!XAAInitAccel(pScreen, infoRec))
-        return FALSE;
-    pScreenPriv->AccelInfoRec = infoRec;
-    infoRec->ScratchGC.pScreen = pScreen;
-
-    if (!infoRec->GetImage)
-        infoRec->GetImage = XAAGetImage;
-    if (!infoRec->GetSpans)
-        infoRec->GetSpans = XAAGetSpans;
-    if (!infoRec->CopyWindow)
-        infoRec->CopyWindow = XAACopyWindow;
-
-    pScreenPriv->CreateGC = pScreen->CreateGC;
-    pScreen->CreateGC = XAACreateGC;
-    pScreenPriv->CloseScreen = pScreen->CloseScreen;
-    pScreen->CloseScreen = XAACloseScreen;
-    pScreenPriv->GetImage = pScreen->GetImage;
-    pScreen->GetImage = infoRec->GetImage;
-    pScreenPriv->GetSpans = pScreen->GetSpans;
-    pScreen->GetSpans = infoRec->GetSpans;
-    pScreenPriv->CopyWindow = pScreen->CopyWindow;
-    pScreen->CopyWindow = infoRec->CopyWindow;
-    pScreenPriv->CreatePixmap = pScreen->CreatePixmap;
-    pScreen->CreatePixmap = XAACreatePixmap;
-    pScreenPriv->DestroyPixmap = pScreen->DestroyPixmap;
-    pScreen->DestroyPixmap = XAADestroyPixmap;
-    pScreenPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
-    pScreen->ChangeWindowAttributes = XAAChangeWindowAttributes;
-
-    pScreenPriv->EnterVT = pScrn->EnterVT;
-    pScrn->EnterVT = XAAEnterVT;
-    pScreenPriv->LeaveVT = pScrn->LeaveVT;
-    pScrn->LeaveVT = XAALeaveVT;
-    pScreenPriv->SetDGAMode = pScrn->SetDGAMode;
-    pScrn->SetDGAMode = XAASetDGAMode;
-    pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
-    pScrn->EnableDisableFBAccess = XAAEnableDisableFBAccess;
-
-    pScreenPriv->WindowExposures = pScreen->WindowExposures;
-    if (ps) {
-        pScreenPriv->Composite = ps->Composite;
-        ps->Composite = XAAComposite;
-        pScreenPriv->Glyphs = ps->Glyphs;
-        ps->Glyphs = XAAGlyphs;
-    }
-    if (pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
-        XAASetupOverlay8_32Planar(pScreen);
-
-    infoRec->PreAllocMem = malloc(MAX_PREALLOC_MEM);
-    if (infoRec->PreAllocMem)
-        infoRec->PreAllocSize = MAX_PREALLOC_MEM;
-
-    if (infoRec->Flags & PIXMAP_CACHE)
-        xf86RegisterFreeBoxCallback(pScreen, infoRec->InitPixmapCache,
-                                    (pointer) infoRec);
-
-    if (infoRec->Flags & MICROSOFT_ZERO_LINE_BIAS)
-        miSetZeroLineBias(pScreen, OCTANT1 | OCTANT2 | OCTANT3 | OCTANT4);
-
-#ifdef COMPOSITE
-    /* Initialize the composite wrapper.  This needs to happen after the
-     * wrapping above (so it comes before us), but before all other extensions,
-     * so it doesn't confuse them. (particularly damage).
-     */
-    miInitializeCompositeWrapper(pScreen);
-#endif
-
-    return TRUE;
-}
-
-static Bool
-XAACloseScreen(ScreenPtr pScreen)
-{
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAScreenPtr pScreenPriv =
-        (XAAScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    pScrn->EnterVT = pScreenPriv->EnterVT;
-    pScrn->LeaveVT = pScreenPriv->LeaveVT;
-    pScrn->EnableDisableFBAccess = pScreenPriv->EnableDisableFBAccess;
-
-    pScreen->CreateGC = pScreenPriv->CreateGC;
-    pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    pScreen->GetImage = pScreenPriv->GetImage;
-    pScreen->GetSpans = pScreenPriv->GetSpans;
-    pScreen->CopyWindow = pScreenPriv->CopyWindow;
-    pScreen->WindowExposures = pScreenPriv->WindowExposures;
-    pScreen->CreatePixmap = pScreenPriv->CreatePixmap;
-    pScreen->DestroyPixmap = pScreenPriv->DestroyPixmap;
-    pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;
-
-    /* We leave it up to the client to free the XAAInfoRec */
-
-    free((pointer) pScreenPriv);
-
-    return (*pScreen->CloseScreen) (pScreen);
-}
-
-static void
-XAAGetImage(DrawablePtr pDraw,
-            int sx, int sy, int w, int h,
-            unsigned int format, unsigned long planemask, char *pdstLine)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = infoRec->pScrn;
-
-    if (pScrn->vtSema &&
-        ((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) {
-        if (infoRec->ReadPixmap && (format == ZPixmap) &&
-            ((planemask & infoRec->FullPlanemasks[pDraw->depth - 1]) ==
-             infoRec->FullPlanemasks[pDraw->depth - 1]) &&
-            (pDraw->bitsPerPixel == BitsPerPixel(pDraw->depth))) {
-            (*infoRec->ReadPixmap) (pScrn,
-                                    sx + pDraw->x, sy + pDraw->y, w, h,
-                                    (unsigned char *) pdstLine,
-                                    PixmapBytePad(w, pDraw->depth),
-                                    pDraw->bitsPerPixel, pDraw->depth);
-            return;
-        }
-        SYNC_CHECK(pDraw);
-    }
-
-    XAA_SCREEN_PROLOGUE(pScreen, GetImage);
-    (*pScreen->GetImage) (pDraw, sx, sy, w, h, format, planemask, pdstLine);
-    XAA_SCREEN_EPILOGUE(pScreen, GetImage, XAAGetImage);
-}
-
-static void
-XAAGetSpans(DrawablePtr pDraw,
-            int wMax, DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-
-    XAA_SCREEN_PROLOGUE(pScreen, GetSpans);
-    if (xf86ScreenToScrn(pScreen)->vtSema &&
-        ((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) {
-        SYNC_CHECK(pDraw);
-    }
-    (*pScreen->GetSpans) (pDraw, wMax, ppt, pwidth, nspans, pdstStart);
-    XAA_SCREEN_EPILOGUE(pScreen, GetSpans, XAAGetSpans);
-}
-
-static int
-XAAPixmapBPP(ScreenPtr pScreen, int depth)
-{
-    PixmapPtr pPix;
-    int bpp;
-    DestroyPixmapProcPtr destroyPixmap;
-
-    XAA_SCREEN_PROLOGUE(pScreen, CreatePixmap);
-    pPix = (*pScreen->CreatePixmap) (pScreen, 1, 1, depth,
-                                     CREATE_PIXMAP_USAGE_SCRATCH);
-    XAA_SCREEN_EPILOGUE(pScreen, CreatePixmap, XAACreatePixmap);
-    if (!pPix)
-        return 0;
-    bpp = pPix->drawable.bitsPerPixel;
-    destroyPixmap = pScreen->DestroyPixmap;
-    XAA_SCREEN_PROLOGUE(pScreen, DestroyPixmap);
-    (*pScreen->DestroyPixmap) (pPix);
-    XAA_SCREEN_EPILOGUE(pScreen, DestroyPixmap, destroyPixmap);
-    return bpp;
-}
-
-static void
-XAAInitializeOffscreenDepths(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    int d, dep;
-
-    infoRec->offscreenDepthsInitialized = TRUE;
-    infoRec->offscreenDepths = 0;
-    if (infoRec->Flags & OFFSCREEN_PIXMAPS) {
-        for (d = 0; d < pScreen->numDepths; d++) {
-            dep = pScreen->allowedDepths[d].depth;
-            if (XAAPixmapBPP(pScreen, dep) == pScrn->bitsPerPixel)
-                infoRec->offscreenDepths |= (1 << (dep - 1));
-        }
-    }
-}
-
-static PixmapPtr
-XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned usage_hint)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAPixmapPtr pPriv;
-    PixmapPtr pPix = NULL;
-    int size = w * h;
-
-    if (w > 32767 || h > 32767)
-        return NullPixmap;
-
-    if (!infoRec->offscreenDepthsInitialized)
-        XAAInitializeOffscreenDepths(pScreen);
-
-    if (pScrn->vtSema &&
-        (usage_hint != CREATE_PIXMAP_USAGE_GLYPH_PICTURE) &&
-        (infoRec->offscreenDepths & (1 << (depth - 1))) &&
-        (size >= MIN_OFFPIX_SIZE) && !SwitchedOut &&
-        (!infoRec->maxOffPixWidth || (w <= infoRec->maxOffPixWidth)) &&
-        (!infoRec->maxOffPixHeight || (h <= infoRec->maxOffPixHeight))) {
-        PixmapLinkPtr pLink;
-        PixmapPtr pScreenPix;
-        FBAreaPtr area;
-        int gran = 0;
-
-        switch (pScrn->bitsPerPixel) {
-        case 24:
-        case 8:
-            gran = 4;
-            break;
-        case 16:
-            gran = 2;
-            break;
-        case 32:
-            gran = 1;
-            break;
-        default:
-            break;
-        }
-
-        if (BITMAP_SCANLINE_PAD == 64)
-            gran *= 2;
-
-        if (!(area = xf86AllocateOffscreenArea(pScreen, w, h, gran, 0,
-                                               XAARemoveAreaCallback, NULL))) {
-            goto BAILOUT;
-        }
-
-        if (!(pLink = malloc(sizeof(PixmapLink)))) {
-            xf86FreeOffscreenArea(area);
-            goto BAILOUT;
-        }
-
-        XAA_SCREEN_PROLOGUE(pScreen, CreatePixmap);
-        pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, depth, usage_hint);
-        XAA_SCREEN_EPILOGUE(pScreen, CreatePixmap, XAACreatePixmap);
-
-        if (!pPix) {
-            free(pLink);
-            xf86FreeOffscreenArea(area);
-            goto BAILOUT;
-        }
-
-        pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
-
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-        pPix->drawable.x = area->box.x1;
-        pPix->drawable.y = area->box.y1;
-        pPix->drawable.width = w;
-        pPix->drawable.height = h;
-        pPix->drawable.bitsPerPixel = pScrn->bitsPerPixel;
-        pPix->devKind = pScreenPix->devKind;
-        pPix->devPrivate.ptr = pScreenPix->devPrivate.ptr;
-        area->devPrivate.ptr = pPix;
-
-        pPriv->flags = OFFSCREEN;
-        pPriv->offscreenArea = area;
-        pPriv->freeData = FALSE;
-
-        pLink->next = infoRec->OffscreenPixmaps;
-        pLink->pPix = pPix;
-        infoRec->OffscreenPixmaps = pLink;
-        return pPix;
-    }
- BAILOUT:
-    XAA_SCREEN_PROLOGUE(pScreen, CreatePixmap);
-    pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint);
-    XAA_SCREEN_EPILOGUE(pScreen, CreatePixmap, XAACreatePixmap);
-
-    if (pPix) {
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-        pPriv->flags = 0;
-        pPriv->offscreenArea = NULL;
-        pPriv->freeData = FALSE;
-        if (!w || !h)           /* either scratch or shared memory */
-            pPriv->flags |= SHARED_PIXMAP;
-    }
-
-    return pPix;
-}
-
-static Bool
-XAADestroyPixmap(PixmapPtr pPix)
-{
-    ScreenPtr pScreen = pPix->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-    Bool ret;
-
-    if (pPix->refcnt == 1) {
-        if (pPriv->flags & OFFSCREEN) {
-            if (pPriv->flags & DGA_PIXMAP)
-                free(pPriv->offscreenArea);
-            else {
-                FBAreaPtr area = pPriv->offscreenArea;
-                PixmapLinkPtr pLink = infoRec->OffscreenPixmaps;
-                PixmapLinkPtr prev = NULL;
-
-                while (pLink->pPix != pPix) {
-                    prev = pLink;
-                    pLink = pLink->next;
-                }
-
-                if (prev)
-                    prev->next = pLink->next;
-                else
-                    infoRec->OffscreenPixmaps = pLink->next;
-
-                if (!area)
-                    area = pLink->area;
-
-                xf86FreeOffscreenArea(area);
-                pPriv->offscreenArea = NULL;
-                free(pLink);
-            }
-        }
-
-        if (pPriv->freeData) {  /* pixmaps that were once in video ram */
-            free(pPix->devPrivate.ptr);
-            pPix->devPrivate.ptr = NULL;
-        }
-    }
-
-    XAA_SCREEN_PROLOGUE(pScreen, DestroyPixmap);
-    ret = (*pScreen->DestroyPixmap) (pPix);
-    XAA_SCREEN_EPILOGUE(pScreen, DestroyPixmap, XAADestroyPixmap);
-
-    return ret;
-}
-
-static Bool
-XAAChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    Bool ret;
-
-    XAA_SCREEN_PROLOGUE(pScreen, ChangeWindowAttributes);
-    ret = (*pScreen->ChangeWindowAttributes) (pWin, mask);
-    XAA_SCREEN_EPILOGUE(pScreen, ChangeWindowAttributes,
-                        XAAChangeWindowAttributes);
-
-    /* we have to assume that shared memory pixmaps are dirty
-       because we can't wrap operations on them */
-
-    if ((mask & CWBackPixmap) && (pWin->backgroundState == BackgroundPixmap) &&
-        PIXMAP_IS_SHARED(pWin->background.pixmap)) {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->background.pixmap);
-
-        pPixPriv->flags |= DIRTY;
-    }
-    if ((mask & CWBorderPixmap) && !(pWin->borderIsPixel) &&
-        PIXMAP_IS_SHARED(pWin->border.pixmap)) {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->border.pixmap);
-
-        pPixPriv->flags |= DIRTY;
-    }
-
-    return ret;
-}
-
-/*  These two aren't really needed for anything */
-
-static Bool
-XAAEnterVT(ScrnInfoPtr pScrn)
-{
-    Bool ret;
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    XAAScreenPtr pScreenPriv =
-        (XAAScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    pScrn->EnterVT = pScreenPriv->EnterVT;
-    ret = ((*pScreenPriv->EnterVT) (pScrn));
-    pScreenPriv->EnterVT = pScrn->EnterVT;
-    pScrn->EnterVT = XAAEnterVT;
-    return ret;
-}
-
-static void
-XAALeaveVT(ScrnInfoPtr pScrn)
-{
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    XAAScreenPtr pScreenPriv =
-        (XAAScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-    XAAInfoRecPtr infoRec = pScreenPriv->AccelInfoRec;
-
-    if (infoRec->NeedToSync) {
-        (*infoRec->Sync) (infoRec->pScrn);
-        infoRec->NeedToSync = FALSE;
-    }
-
-    pScrn->LeaveVT = pScreenPriv->LeaveVT;
-    (*pScreenPriv->LeaveVT) (pScrn);
-    pScreenPriv->LeaveVT = pScrn->LeaveVT;
-    pScrn->LeaveVT = XAALeaveVT;
-}
-
-typedef struct {
-    Bool UsingPixmapCache;
-    Bool CanDoColor8x8;
-    Bool CanDoMono8x8;
-} SavedCacheState, *SavedCacheStatePtr;
-
-static int
-XAASetDGAMode(ScrnInfoPtr pScrn, int num, DGADevicePtr devRet)
-{
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAScreenPtr pScreenPriv =
-        (XAAScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-    int ret;
-
-    if (!num && infoRec->dgaSaves) {    /* restore old pixmap cache state */
-        SavedCacheStatePtr state = (SavedCacheStatePtr) infoRec->dgaSaves;
-
-        infoRec->UsingPixmapCache = state->UsingPixmapCache;
-        infoRec->CanDoColor8x8 = state->CanDoColor8x8;
-        infoRec->CanDoMono8x8 = state->CanDoMono8x8;
-        free(infoRec->dgaSaves);
-        infoRec->dgaSaves = NULL;
-    }
-
-    ret = (*pScreenPriv->SetDGAMode) (pScrn, num, devRet);
-    if (ret != Success)
-        return ret;
-
-    if (num && devRet->pPix) {  /* accelerate this pixmap */
-        XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(devRet->pPix);
-        FBAreaPtr area;
-
-        if ((area = malloc(sizeof(FBArea)))) {
-            area->pScreen = pScreen;
-            area->box.x1 = 0;
-            area->box.x2 = 0;
-            area->box.y1 = devRet->mode->pixmapWidth;
-            area->box.y2 = devRet->mode->pixmapHeight;
-            area->granularity = 0;
-            area->MoveAreaCallback = 0;
-            area->RemoveAreaCallback = 0;
-            area->devPrivate.ptr = 0;
-
-            pixPriv->flags |= OFFSCREEN | DGA_PIXMAP;
-            pixPriv->offscreenArea = area;
-
-            if (!infoRec->dgaSaves) {   /* save pixmap cache state */
-                SavedCacheStatePtr state = malloc(sizeof(SavedCacheState));
-
-                state->UsingPixmapCache = infoRec->UsingPixmapCache;
-                state->CanDoColor8x8 = infoRec->CanDoColor8x8;
-                state->CanDoMono8x8 = infoRec->CanDoMono8x8;
-                infoRec->dgaSaves = (char *) state;
-
-                infoRec->UsingPixmapCache = FALSE;
-                if (infoRec->PixmapCacheFlags & CACHE_MONO_8x8)
-                    infoRec->CanDoMono8x8 = FALSE;
-                if (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8)
-                    infoRec->CanDoColor8x8 = FALSE;
-            }
-        }
-    }
-
-    return ret;
-}
-
-static void
-XAAEnableDisableFBAccess(ScrnInfoPtr pScrn, Bool enable)
-{
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAScreenPtr pScreenPriv =
-        (XAAScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    if (!enable) {
-        if ((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))
-            XAAMoveOutOffscreenPixmaps(pScreen);
-        if (infoRec->Flags & PIXMAP_CACHE)
-            XAAInvalidatePixmapCache(pScreen);
-        SwitchedOut = TRUE;
-    }
-
-    (*pScreenPriv->EnableDisableFBAccess) (pScrn, enable);
-
-    if (enable) {
-        if ((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))
-            XAAMoveInOffscreenPixmaps(pScreen);
-        SwitchedOut = FALSE;
-    }
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaInitAccel.c b/xorg-server/hw/xfree86/xaa/xaaInitAccel.c
deleted file mode 100644
index a36e0b71b..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaInitAccel.c
+++ /dev/null
@@ -1,1571 +0,0 @@
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xf86fbman.h"
-#include "servermd.h"
-
-/*
- * XAA Config options
- */
-
-typedef enum {
-    XAAOPT_SCREEN_TO_SCREEN_COPY,
-    XAAOPT_SOLID_FILL_RECT,
-    XAAOPT_SOLID_FILL_TRAP,
-    XAAOPT_SOLID_TWO_POINT_LINE,
-    XAAOPT_SOLID_BRESENHAM_LINE,
-    XAAOPT_SOLID_HORVERT_LINE,
-    XAAOPT_DASHED_TWO_POINT_LINE,
-    XAAOPT_DASHED_BRESENHAM_LINE,
-    XAAOPT_MONO_8x8_PATTERN_FILL_RECT,
-    XAAOPT_MONO_8x8_PATTERN_FILL_TRAP,
-    XAAOPT_COL_8x8_PATTERN_FILL_RECT,
-    XAAOPT_COL_8x8_PATTERN_FILL_TRAP,
-    XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL,
-    XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
-    XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL,
-    XAAOPT_IMAGE_WRITE_RECT,
-    XAAOPT_SCANLINE_IMAGE_WRITE_RECT,
-    XAAOPT_WRITE_BITMAP,
-    XAAOPT_WRITE_PIXMAP,
-    XAAOPT_PIXMAP_CACHE,
-    XAAOPT_OFFSCREEN_PIXMAPS,
-    XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE
-} XAAOpts;
-
-static const OptionInfoRec XAAOptions[] = {
-    {XAAOPT_SCREEN_TO_SCREEN_COPY, "XaaNoScreenToScreenCopy",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SOLID_FILL_RECT, "XaaNoSolidFillRect",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SOLID_FILL_TRAP, "XaaNoSolidFillTrap",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SOLID_TWO_POINT_LINE, "XaaNoSolidTwoPointLine",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SOLID_BRESENHAM_LINE, "XaaNoSolidBresenhamLine",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SOLID_HORVERT_LINE, "XaaNoSolidHorVertLine",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_DASHED_TWO_POINT_LINE, "XaaNoDashedTwoPointLine",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_DASHED_BRESENHAM_LINE, "XaaNoDashedBresenhamLine",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_MONO_8x8_PATTERN_FILL_RECT, "XaaNoMono8x8PatternFillRect",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_MONO_8x8_PATTERN_FILL_TRAP, "XaaNoMono8x8PatternFillTrap",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_COL_8x8_PATTERN_FILL_RECT, "XaaNoColor8x8PatternFillRect",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_COL_8x8_PATTERN_FILL_TRAP, "XaaNoColor8x8PatternFillTrap",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL, "XaaNoCPUToScreenColorExpandFill",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
-     "XaaNoScanlineCPUToScreenColorExpandFill",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL, "XaaNoScreenToScreenColorExpandFill",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_IMAGE_WRITE_RECT, "XaaNoImageWriteRect",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_SCANLINE_IMAGE_WRITE_RECT, "XaaNoScanlineImageWriteRect",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_WRITE_BITMAP, "XaaNoWriteBitmap",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_WRITE_PIXMAP, "XaaNoWritePixmap",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_PIXMAP_CACHE, "XaaNoPixmapCache",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_OFFSCREEN_PIXMAPS, "XaaNoOffscreenPixmaps",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE, "XaaOffscreenPixmaps",
-     OPTV_BOOLEAN, {0}, FALSE},
-    {-1, NULL,
-     OPTV_NONE, {0}, FALSE}
-};
-
-static XF86ModuleVersionInfo xaaVersRec = {
-    "xaa",
-    MODULEVENDORSTRING,
-    MODINFOSTRING1,
-    MODINFOSTRING2,
-    XORG_VERSION_CURRENT,
-    XAA_VERSION_MAJOR,
-    XAA_VERSION_MINOR,
-    XAA_VERSION_RELEASE,
-    ABI_CLASS_VIDEODRV,         /* requires the video driver ABI */
-    ABI_VIDEODRV_VERSION,
-    MOD_CLASS_NONE,
-    {0, 0, 0, 0}
-};
-
-_X_EXPORT XF86ModuleData xaaModuleData = { &xaaVersRec, NULL, NULL };
-
-Bool
-XAAInitAccel(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
-{
-    int index = pScreen->myNum;
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    Bool HaveScreenToScreenCopy = FALSE;
-    Bool HaveColorExpansion = FALSE;
-    Bool HaveScanlineColorExpansion = FALSE;
-    Bool HaveSolidFillRect = FALSE;
-    Bool HaveMono8x8PatternFillRect = FALSE;
-    Bool HaveColor8x8PatternFillRect = FALSE;
-    Bool HaveSolidFillTrap = FALSE;
-    Bool HaveMono8x8PatternFillTrap = FALSE;
-    Bool HaveColor8x8PatternFillTrap = FALSE;
-    Bool HaveSolidTwoPointLine = FALSE;
-    Bool HaveSolidBresenhamLine = FALSE;
-    Bool HaveSolidHorVertLine = FALSE;
-    Bool HaveDashedTwoPointLine = FALSE;
-    Bool HaveDashedBresenhamLine = FALSE;
-    Bool HaveImageWriteRect = FALSE;
-    Bool HaveScanlineImageWriteRect = FALSE;
-    Bool HaveScreenToScreenColorExpandFill = FALSE;
-    OptionInfoPtr options;
-    int is_shared = 0;
-    int i;
-
-    options = xnfalloc(sizeof(XAAOptions));
-    (void) memcpy(options, XAAOptions, sizeof(XAAOptions));
-    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, options);
-
-    infoRec->pScrn = pScrn;
-    infoRec->NeedToSync = FALSE;
-
-    /* must have a Sync function */
-    if (!infoRec->Sync)
-        return FALSE;
-    for (i = 0; i < pScrn->numEntities; i++) {
-        if (xf86IsEntityShared(pScrn->entityList[i]))
-            is_shared = 1;
-    }
-
-    /* If this PCI entity has IS_SHARED_ACCEL set in entityProp
-     * then a RestoreAccelState function is required
-     */
-    if (!infoRec->RestoreAccelState && is_shared)
-        return FALSE;
-
-    if (infoRec->RestoreAccelState) {
-        if (!XAAInitStateWrap(pScreen, infoRec))
-            return FALSE;
-    }
-
-    if (serverGeneration == 1)
-        xf86DrvMsg(index, X_INFO,
-                   "Using XFree86 Acceleration Architecture (XAA)\n");
-
-    /************** Low Level *************/
-
-    if (!infoRec->SetClippingRectangle || !infoRec->DisableClipping) {
-        infoRec->ClippingFlags = 0;
-        infoRec->SetClippingRectangle = NULL;
-        infoRec->DisableClipping = NULL;
-    }
-
-    /**** CopyArea ****/
-
-    if (infoRec->SetupForScreenToScreenCopy &&
-        infoRec->SubsequentScreenToScreenCopy &&
-        !xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COPY, FALSE)) {
-        HaveScreenToScreenCopy = TRUE;
-    }
-    else {
-        infoRec->ScreenToScreenCopyFlags = 0;
-        infoRec->SetupForScreenToScreenCopy = NULL;
-        infoRec->SubsequentScreenToScreenCopy = NULL;
-    }
-
-    /**** Solid Filled Rects ****/
-
-    if (infoRec->SetupForSolidFill && infoRec->SubsequentSolidFillRect &&
-        !xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_RECT, FALSE)) {
-        HaveSolidFillRect = TRUE;
-        if (infoRec->SubsequentSolidFillTrap &&
-            !xf86ReturnOptValBool(options, XAAOPT_SOLID_FILL_TRAP, FALSE))
-            HaveSolidFillTrap = TRUE;
-        else
-            infoRec->SubsequentSolidFillTrap = NULL;
-    }
-    else {
-        infoRec->SolidFillFlags = 0;
-        infoRec->SetupForSolidFill = NULL;
-        infoRec->SubsequentSolidFillRect = NULL;
-        infoRec->SubsequentSolidFillTrap = NULL;
-    }
-
-    /**** Solid lines ****/
-
-    if (infoRec->SetupForSolidLine) {
-        if (infoRec->SubsequentSolidTwoPointLine &&
-            !xf86ReturnOptValBool(options, XAAOPT_SOLID_TWO_POINT_LINE, FALSE))
-            HaveSolidTwoPointLine = TRUE;
-        if (infoRec->SubsequentSolidBresenhamLine &&
-            !xf86ReturnOptValBool(options, XAAOPT_SOLID_BRESENHAM_LINE,
-                                  FALSE)) {
-            HaveSolidBresenhamLine = TRUE;
-
-            if (infoRec->SolidBresenhamLineErrorTermBits)
-                infoRec->SolidBresenhamLineErrorTermBits =
-                    ~((1 << infoRec->SolidBresenhamLineErrorTermBits) - 1);
-        }
-
-        if (infoRec->SubsequentSolidHorVertLine &&
-            !xf86ReturnOptValBool(options, XAAOPT_SOLID_HORVERT_LINE, FALSE))
-            HaveSolidHorVertLine = TRUE;
-        else if (HaveSolidTwoPointLine) {
-            infoRec->SubsequentSolidHorVertLine = XAASolidHorVertLineAsTwoPoint;
-            HaveSolidHorVertLine = TRUE;
-        }
-        else if (HaveSolidBresenhamLine) {
-            infoRec->SubsequentSolidHorVertLine =
-                XAASolidHorVertLineAsBresenham;
-            HaveSolidHorVertLine = TRUE;
-        }
-    }
-
-    /* XXX Should this also check for XAAOPT_SOLID_HORVERT_LINE? */
-    if (!HaveSolidTwoPointLine &&
-        !HaveSolidBresenhamLine && !HaveSolidHorVertLine && HaveSolidFillRect) {
-        infoRec->SetupForSolidLine = infoRec->SetupForSolidFill;
-        infoRec->SubsequentSolidHorVertLine = XAASolidHorVertLineAsRects;
-        infoRec->SolidLineFlags = infoRec->SolidFillFlags;
-        HaveSolidHorVertLine = TRUE;
-    }
-
-    if (!HaveSolidTwoPointLine)
-        infoRec->SubsequentSolidTwoPointLine = NULL;
-    if (!HaveSolidBresenhamLine)
-        infoRec->SubsequentSolidBresenhamLine = NULL;
-    if (!HaveSolidHorVertLine)
-        infoRec->SubsequentSolidHorVertLine = NULL;
-
-    /* Disable all if nothing left over */
-    if (!HaveSolidTwoPointLine &&
-        !HaveSolidBresenhamLine && !HaveSolidHorVertLine) {
-        infoRec->SolidLineFlags = 0;
-        infoRec->SetupForSolidLine = NULL;
-    }
-
-    /**** 8x8 Mono Pattern Filled Rects ****/
-
-    if (infoRec->SetupForMono8x8PatternFill &&
-        infoRec->SubsequentMono8x8PatternFillRect &&
-        !xf86ReturnOptValBool(options,
-                              XAAOPT_MONO_8x8_PATTERN_FILL_RECT, FALSE)) {
-        HaveMono8x8PatternFillRect = TRUE;
-        if (infoRec->SubsequentMono8x8PatternFillTrap &&
-            !xf86ReturnOptValBool(options,
-                                  XAAOPT_MONO_8x8_PATTERN_FILL_TRAP, FALSE))
-            HaveMono8x8PatternFillTrap = TRUE;
-
-        if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-            infoRec->CanDoMono8x8 = TRUE;
-        }
-        else {                  /* others require caching */
-            int min_pitch;
-
-            infoRec->PixmapCacheFlags |= CACHE_MONO_8x8;
-
-            switch (pScrn->bitsPerPixel) {
-            case 32:
-                min_pitch = 2;
-                break;
-            case 24:
-                min_pitch = 3;
-                break;
-            case 16:
-                min_pitch = 4;
-                break;
-            default:
-                min_pitch = 8;
-                break;
-            }
-
-            if (min_pitch > infoRec->MonoPatternPitch)
-                infoRec->MonoPatternPitch = min_pitch;
-
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
-                if (!infoRec->CacheWidthMono8x8Pattern ||
-                    !infoRec->CacheHeightMono8x8Pattern) {
-                    infoRec->CacheWidthMono8x8Pattern =
-                        infoRec->MonoPatternPitch;
-                    infoRec->CacheHeightMono8x8Pattern = 1;
-                }
-            }
-            else {
-                int numPerLine = 128 / infoRec->MonoPatternPitch;
-
-                if (!infoRec->CacheWidthMono8x8Pattern ||
-                    !infoRec->CacheHeightMono8x8Pattern) {
-                    infoRec->CacheWidthMono8x8Pattern =
-                        numPerLine * infoRec->MonoPatternPitch;
-                    infoRec->CacheHeightMono8x8Pattern =
-                        (64 + numPerLine - 1) / numPerLine;
-                }
-            }
-        }
-    }
-    else {
-        infoRec->Mono8x8PatternFillFlags = 0;
-        infoRec->SetupForMono8x8PatternFill = NULL;
-        infoRec->SubsequentMono8x8PatternFillRect = NULL;
-    }
-
-    /**** Dashed lines ****/
-
-    if (infoRec->SetupForDashedLine && infoRec->DashPatternMaxLength) {
-        if (infoRec->SubsequentDashedTwoPointLine &&
-            !xf86ReturnOptValBool(options, XAAOPT_DASHED_TWO_POINT_LINE, FALSE))
-            HaveDashedTwoPointLine = TRUE;
-        if (infoRec->SubsequentDashedBresenhamLine &&
-            !xf86ReturnOptValBool(options, XAAOPT_DASHED_BRESENHAM_LINE,
-                                  FALSE)) {
-            HaveDashedBresenhamLine = TRUE;
-
-            if (infoRec->DashedBresenhamLineErrorTermBits)
-                infoRec->DashedBresenhamLineErrorTermBits =
-                    ~((1 << infoRec->DashedBresenhamLineErrorTermBits) - 1);
-        }
-    }
-
-    if (!HaveDashedTwoPointLine)
-        infoRec->SubsequentDashedTwoPointLine = NULL;
-    if (!HaveDashedBresenhamLine)
-        infoRec->SubsequentDashedBresenhamLine = NULL;
-
-    /* Disable all if nothing left over */
-    if (!HaveDashedTwoPointLine && !HaveDashedBresenhamLine) {
-        infoRec->DashedLineFlags = 0;
-        infoRec->SetupForDashedLine = NULL;
-    }
-
-    /**** 8x8 Color Pattern Filled Rects ****/
-
-    if (infoRec->SetupForColor8x8PatternFill &&
-        infoRec->SubsequentColor8x8PatternFillRect &&
-        !xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_RECT,
-                              FALSE)) {
-        HaveColor8x8PatternFillRect = TRUE;
-        if (infoRec->SubsequentColor8x8PatternFillTrap &&
-            !xf86ReturnOptValBool(options, XAAOPT_COL_8x8_PATTERN_FILL_TRAP,
-                                  FALSE))
-            HaveColor8x8PatternFillTrap = TRUE;
-        else
-            infoRec->SubsequentColor8x8PatternFillTrap = NULL;
-
-        infoRec->PixmapCacheFlags |= CACHE_COLOR_8x8;
-
-        if (infoRec->Color8x8PatternFillFlags &
-            HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
-            if (!infoRec->CacheWidthColor8x8Pattern ||
-                !infoRec->CacheHeightColor8x8Pattern) {
-                infoRec->CacheWidthColor8x8Pattern = 64;
-                infoRec->CacheHeightColor8x8Pattern = 1;
-            }
-        }
-        else {
-            if (!infoRec->CacheWidthColor8x8Pattern ||
-                !infoRec->CacheHeightColor8x8Pattern) {
-                infoRec->CacheWidthColor8x8Pattern = 128;
-                infoRec->CacheHeightColor8x8Pattern = 8;
-            }
-        }
-    }
-    else {
-        infoRec->Color8x8PatternFillFlags = 0;
-        infoRec->SetupForColor8x8PatternFill = NULL;
-        infoRec->SubsequentColor8x8PatternFillRect = NULL;
-        infoRec->SubsequentColor8x8PatternFillTrap = NULL;
-    }
-
-    /**** Color Expansion ****/
-
-    if (infoRec->SetupForCPUToScreenColorExpandFill &&
-        infoRec->ColorExpandBase &&
-        infoRec->SubsequentCPUToScreenColorExpandFill &&
-        !xf86ReturnOptValBool(options, XAAOPT_CPU_TO_SCREEN_COL_EXP_FILL,
-                              FALSE)) {
-        int dwordsNeeded = pScrn->virtualX;
-
-        infoRec->ColorExpandRange >>= 2;        /* convert to DWORDS */
-        HaveColorExpansion = TRUE;
-
-        if (infoRec->CPUToScreenColorExpandFillFlags &
-            LEFT_EDGE_CLIPPING_NEGATIVE_X)
-            dwordsNeeded += 31;
-        dwordsNeeded = (dwordsNeeded + 31) >> 5;
-        if (dwordsNeeded > infoRec->ColorExpandRange)
-            infoRec->CPUToScreenColorExpandFillFlags |= CPU_TRANSFER_BASE_FIXED;
-    }
-    else {
-        infoRec->CPUToScreenColorExpandFillFlags = 0;
-        infoRec->SetupForCPUToScreenColorExpandFill = NULL;
-        infoRec->SubsequentCPUToScreenColorExpandFill = NULL;
-    }
-
-    /**** Scanline Color Expansion ****/
-
-    if (infoRec->SetupForScanlineCPUToScreenColorExpandFill &&
-        infoRec->SubsequentScanlineCPUToScreenColorExpandFill &&
-        infoRec->SubsequentColorExpandScanline &&
-        infoRec->ScanlineColorExpandBuffers &&
-        (infoRec->NumScanlineColorExpandBuffers > 0) &&
-        !xf86ReturnOptValBool(options,
-                              XAAOPT_SCANLINE_CPU_TO_SCREEN_COL_EXP_FILL,
-                              FALSE)) {
-        HaveScanlineColorExpansion = TRUE;
-    }
-    else {
-        infoRec->ScanlineCPUToScreenColorExpandFillFlags = 0;
-        infoRec->SetupForScanlineCPUToScreenColorExpandFill = NULL;
-        infoRec->SubsequentScanlineCPUToScreenColorExpandFill = NULL;
-        infoRec->SubsequentColorExpandScanline = NULL;
-    }
-
-    /**** Screen to Screen Color Expansion ****/
-
-    if (infoRec->SetupForScreenToScreenColorExpandFill &&
-        infoRec->SubsequentScreenToScreenColorExpandFill &&
-        !xf86ReturnOptValBool(options, XAAOPT_SCREEN_TO_SCREEN_COL_EXP_FILL,
-                              FALSE)) {
-        HaveScreenToScreenColorExpandFill = TRUE;
-        if (!infoRec->CacheColorExpandDensity)
-            infoRec->CacheColorExpandDensity = 1;
-    }
-    else {
-        infoRec->ScreenToScreenColorExpandFillFlags = 0;
-        infoRec->SetupForScreenToScreenColorExpandFill = NULL;
-        infoRec->SubsequentScreenToScreenColorExpandFill = NULL;
-    }
-
-    /**** Image Writes ****/
-
-    if (infoRec->SetupForImageWrite && infoRec->ImageWriteBase &&
-        infoRec->SubsequentImageWriteRect &&
-        !xf86ReturnOptValBool(options, XAAOPT_IMAGE_WRITE_RECT, FALSE)) {
-
-        infoRec->ImageWriteRange >>= 2; /* convert to DWORDS */
-        if (infoRec->ImageWriteFlags & CPU_TRANSFER_BASE_FIXED)
-            infoRec->ImageWriteRange = 0;
-        HaveImageWriteRect = TRUE;
-    }
-    else {
-        infoRec->ImageWriteFlags = 0;
-        infoRec->SetupForImageWrite = NULL;
-        infoRec->SubsequentImageWriteRect = NULL;
-    }
-
-    /**** Scanline Image Writes ****/
-
-    if (infoRec->SetupForScanlineImageWrite &&
-        infoRec->SubsequentScanlineImageWriteRect &&
-        infoRec->SubsequentImageWriteScanline &&
-        infoRec->ScanlineImageWriteBuffers &&
-        (infoRec->NumScanlineImageWriteBuffers > 0) &&
-        !xf86ReturnOptValBool(options, XAAOPT_SCANLINE_IMAGE_WRITE_RECT,
-                              FALSE)) {
-        HaveScanlineImageWriteRect = TRUE;
-    }
-    else {
-        infoRec->ScanlineImageWriteFlags = 0;
-        infoRec->SetupForScanlineImageWrite = NULL;
-        infoRec->SubsequentScanlineImageWriteRect = NULL;
-        infoRec->SubsequentImageWriteScanline = NULL;
-    }
-
-#ifndef __i386__
-    /* XAA makes some unaligned accesses when clipping is not available */
-#define CLIP_FLAGS (LEFT_EDGE_CLIPPING | LEFT_EDGE_CLIPPING_NEGATIVE_X)
-    if (HaveImageWriteRect &&
-        ((infoRec->ImageWriteFlags & CLIP_FLAGS) != CLIP_FLAGS)) {
-        HaveImageWriteRect = FALSE;
-    }
-    if (HaveScanlineImageWriteRect &&
-        ((infoRec->ScanlineImageWriteFlags & CLIP_FLAGS) != CLIP_FLAGS)) {
-        HaveScanlineImageWriteRect = FALSE;
-    }
-#endif
-
-    if (serverGeneration == 1) {
-        if (HaveScreenToScreenCopy)
-            xf86ErrorF("\tScreen to screen bit blits\n");
-        if (HaveSolidFillRect)
-            xf86ErrorF("\tSolid filled rectangles\n");
-        if (HaveSolidFillTrap)
-            xf86ErrorF("\tSolid filled trapezoids\n");
-        if (HaveMono8x8PatternFillRect)
-            xf86ErrorF("\t8x8 mono pattern filled rectangles\n");
-        if (HaveMono8x8PatternFillTrap)
-            xf86ErrorF("\t8x8 mono pattern filled trapezoids\n");
-        if (HaveColor8x8PatternFillRect)
-            xf86ErrorF("\t8x8 color pattern filled rectangles\n");
-        if (HaveColor8x8PatternFillTrap)
-            xf86ErrorF("\t8x8 color pattern filled trapezoids\n");
-
-        if (HaveColorExpansion)
-            xf86ErrorF("\tCPU to Screen color expansion\n");
-        else if (HaveScanlineColorExpansion)
-            xf86ErrorF("\tIndirect CPU to Screen color expansion\n");
-
-        if (HaveScreenToScreenColorExpandFill)
-            xf86ErrorF("\tScreen to Screen color expansion\n");
-
-        if (HaveSolidTwoPointLine || HaveSolidBresenhamLine)
-            xf86ErrorF("\tSolid Lines\n");
-        else if (HaveSolidHorVertLine)
-            xf86ErrorF("\tSolid Horizontal and Vertical Lines\n");
-
-        if (HaveDashedTwoPointLine || HaveDashedBresenhamLine)
-            xf86ErrorF("\tDashed Lines\n");
-
-        if (HaveImageWriteRect)
-            xf86ErrorF("\tImage Writes\n");
-        else if (HaveScanlineImageWriteRect)
-            xf86ErrorF("\tScanline Image Writes\n");
-
-    }
-
-#define XAAMSG(s) do { if (serverGeneration == 1) xf86ErrorF(s); } while (0)
-
-    if ((infoRec->Flags & OFFSCREEN_PIXMAPS) && HaveScreenToScreenCopy &&
-        xf86ReturnOptValBool(options,
-                             XAAOPT_HAS_DUMB_INVERTED_OPTION_SENSE, FALSE)) {
-        XAAMSG("\tOffscreen Pixmaps\n");
-    }
-    else {
-        infoRec->Flags &= ~OFFSCREEN_PIXMAPS;
-    }
-
-    /************** Mid Level *************/
-
-    /**** ScreenToScreenBitBlt ****/
-
-    if (infoRec->ScreenToScreenBitBlt) {
-        XAAMSG("\tDriver provided ScreenToScreenBitBlt replacement\n");
-    }
-    else if (HaveScreenToScreenCopy) {
-        infoRec->ScreenToScreenBitBlt = XAAScreenToScreenBitBlt;
-        infoRec->ScreenToScreenBitBltFlags = infoRec->ScreenToScreenCopyFlags;
-    }
-
-    /**** FillSolidRects ****/
-
-    if (infoRec->FillSolidRects) {
-        XAAMSG("\tDriver provided FillSolidRects replacement\n");
-    }
-    else if (HaveSolidFillRect) {
-        infoRec->FillSolidRects = XAAFillSolidRects;
-        infoRec->FillSolidRectsFlags = infoRec->SolidFillFlags;
-    }
-
-    /**** FillSolidSpans ****/
-
-    if (infoRec->FillSolidSpans) {
-        XAAMSG("\tDriver provided FillSolidSpans replacement\n");
-    }
-    else if (HaveSolidFillRect) {
-        infoRec->FillSolidSpans = XAAFillSolidSpans;
-        infoRec->FillSolidSpansFlags = infoRec->SolidFillFlags;
-    }
-
-    /**** FillMono8x8PatternRects ****/
-
-    if (infoRec->FillMono8x8PatternRects) {
-        XAAMSG("\tDriver provided FillMono8x8PatternRects replacement\n");
-    }
-    else if (HaveMono8x8PatternFillRect) {
-        infoRec->FillMono8x8PatternRects =
-            (infoRec->
-             Mono8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
-            XAAFillMono8x8PatternRectsScreenOrigin : XAAFillMono8x8PatternRects;
-
-        infoRec->FillMono8x8PatternRectsFlags =
-            infoRec->Mono8x8PatternFillFlags;
-    }
-
-    /**** FillMono8x8PatternSpans ****/
-
-    if (infoRec->FillMono8x8PatternSpans) {
-        XAAMSG("\tDriver provided FillMono8x8PatternSpans replacement\n");
-    }
-    else if (HaveMono8x8PatternFillRect) {
-        infoRec->FillMono8x8PatternSpans =
-            (infoRec->
-             Mono8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
-            XAAFillMono8x8PatternSpansScreenOrigin : XAAFillMono8x8PatternSpans;
-
-        infoRec->FillMono8x8PatternSpansFlags =
-            infoRec->Mono8x8PatternFillFlags;
-    }
-
-    /**** FillColor8x8Rects ****/
-
-    if (infoRec->FillColor8x8PatternRects) {
-        XAAMSG("\tDriver provided FillColor8x8PatternRects replacement\n");
-    }
-    else if (HaveColor8x8PatternFillRect) {
-        infoRec->FillColor8x8PatternRects =
-            (infoRec->
-             Color8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
-            XAAFillColor8x8PatternRectsScreenOrigin :
-            XAAFillColor8x8PatternRects;
-
-        infoRec->FillColor8x8PatternRectsFlags =
-            infoRec->Color8x8PatternFillFlags;
-    }
-
-    /**** FillColor8x8Spans ****/
-
-    if (infoRec->FillColor8x8PatternSpans) {
-        XAAMSG("\tDriver provided FillColor8x8PatternSpans replacement\n");
-    }
-    else if (HaveColor8x8PatternFillRect) {
-        infoRec->FillColor8x8PatternSpans =
-            (infoRec->
-             Color8x8PatternFillFlags & HARDWARE_PATTERN_SCREEN_ORIGIN) ?
-            XAAFillColor8x8PatternSpansScreenOrigin :
-            XAAFillColor8x8PatternSpans;
-
-        infoRec->FillColor8x8PatternSpansFlags =
-            infoRec->Color8x8PatternFillFlags;
-    }
-
-    /**** FillCacheBltRects ****/
-
-    if (infoRec->FillCacheBltRects) {
-        XAAMSG("\tDriver provided FillCacheBltRects replacement\n");
-    }
-    else if (HaveScreenToScreenCopy) {
-        infoRec->FillCacheBltRects = XAAFillCacheBltRects;
-        infoRec->FillCacheBltRectsFlags = infoRec->ScreenToScreenCopyFlags;
-    }
-
-    /**** FillCacheBltSpans ****/
-
-    if (infoRec->FillCacheBltSpans) {
-        XAAMSG("\tDriver provided FillCacheBltSpans replacement\n");
-    }
-    else if (HaveScreenToScreenCopy) {
-        infoRec->FillCacheBltSpans = XAAFillCacheBltSpans;
-        infoRec->FillCacheBltSpansFlags = infoRec->ScreenToScreenCopyFlags;
-    }
-
-    /**** FillCacheExpandRects ****/
-
-    if (infoRec->FillCacheExpandRects) {
-        XAAMSG("\tDriver provided FillCacheExpandRects replacement\n");
-    }
-    else if (HaveScreenToScreenColorExpandFill) {
-        infoRec->FillCacheExpandRects = XAAFillCacheExpandRects;
-        infoRec->FillCacheExpandRectsFlags =
-            infoRec->ScreenToScreenColorExpandFillFlags;
-    }
-
-    /**** FillCacheExpandSpans ****/
-
-    if (infoRec->FillCacheExpandSpans) {
-        XAAMSG("\tDriver provided FillCacheExpandSpans replacement\n");
-    }
-    else if (HaveScreenToScreenColorExpandFill) {
-        infoRec->FillCacheExpandSpans = XAAFillCacheExpandSpans;
-        infoRec->FillCacheExpandSpansFlags =
-            infoRec->ScreenToScreenColorExpandFillFlags;
-    }
-
-    /**** FillColorExpandRects ****/
-
-    if (infoRec->FillColorExpandRects) {
-        XAAMSG("\tDriver provided FillColorExpandRects replacement\n");
-    }
-    else if (HaveColorExpansion) {
-        if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRects3MSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRects3MSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRects3LSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRects3LSBFirst;
-            }
-        }
-        else {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRectsMSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRectsMSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRectsLSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandRects =
-                        XAAFillColorExpandRectsLSBFirst;
-            }
-        }
-        infoRec->FillColorExpandRectsFlags =
-            infoRec->CPUToScreenColorExpandFillFlags;
-    }
-    else if (HaveScanlineColorExpansion) {
-        if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-            TRIPLE_BITS_24BPP) {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->FillColorExpandRects =
-                    XAAFillScanlineColorExpandRects3MSBFirst;
-            else
-                infoRec->FillColorExpandRects =
-                    XAAFillScanlineColorExpandRects3LSBFirst;
-        }
-        else {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->FillColorExpandRects =
-                    XAAFillScanlineColorExpandRectsMSBFirst;
-            else
-                infoRec->FillColorExpandRects =
-                    XAAFillScanlineColorExpandRectsLSBFirst;
-        }
-        infoRec->FillColorExpandRectsFlags =
-            infoRec->ScanlineCPUToScreenColorExpandFillFlags;
-    }
-
-    /**** FillColorExpandSpans ****/
-
-    if (infoRec->FillColorExpandSpans) {
-        XAAMSG("\tDriver provided FillColorExpandSpans replacement\n");
-    }
-    else if (HaveColorExpansion) {
-        if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpans3MSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpans3MSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpans3LSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpans3LSBFirst;
-            }
-        }
-        else {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpansMSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpansMSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpansLSBFirstFixedBase;
-                else
-                    infoRec->FillColorExpandSpans =
-                        XAAFillColorExpandSpansLSBFirst;
-            }
-        }
-        infoRec->FillColorExpandSpansFlags =
-            infoRec->CPUToScreenColorExpandFillFlags;
-    }
-    else if (HaveScanlineColorExpansion) {
-        if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-            TRIPLE_BITS_24BPP) {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->FillColorExpandSpans =
-                    XAAFillScanlineColorExpandSpans3MSBFirst;
-            else
-                infoRec->FillColorExpandSpans =
-                    XAAFillScanlineColorExpandSpans3LSBFirst;
-        }
-        else {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->FillColorExpandSpans =
-                    XAAFillScanlineColorExpandSpansMSBFirst;
-            else
-                infoRec->FillColorExpandSpans =
-                    XAAFillScanlineColorExpandSpansLSBFirst;
-        }
-        infoRec->FillColorExpandSpansFlags =
-            infoRec->ScanlineCPUToScreenColorExpandFillFlags;
-    }
-
-    /**** FillImageWriteRects ****/
-
-    if (infoRec->FillImageWriteRects) {
-        XAAMSG("\tDriver provided FillImageWriteRects replacement\n");
-    }
-    else if (HaveImageWriteRect &&
-             (infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
-             (infoRec->ImageWriteFlags & LEFT_EDGE_CLIPPING)) {
-        infoRec->FillImageWriteRects = XAAFillImageWriteRects;
-        infoRec->FillImageWriteRectsFlags = infoRec->ImageWriteFlags;
-    }
-
-    /**** WriteBitmap ****/
-
-    if (infoRec->WriteBitmap &&
-        !xf86ReturnOptValBool(options, XAAOPT_WRITE_BITMAP, FALSE)) {
-        XAAMSG("\tDriver provided WriteBitmap replacement\n");
-    }
-    else if (HaveColorExpansion) {
-        if (infoRec->CPUToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP) {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->WriteBitmap =
-                        XAAWriteBitmapColorExpand3MSBFirstFixedBase;
-                else
-                    infoRec->WriteBitmap = XAAWriteBitmapColorExpand3MSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->WriteBitmap =
-                        XAAWriteBitmapColorExpand3LSBFirstFixedBase;
-                else
-                    infoRec->WriteBitmap = XAAWriteBitmapColorExpand3LSBFirst;
-            }
-        }
-        else {
-            if (infoRec->CPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->WriteBitmap =
-                        XAAWriteBitmapColorExpandMSBFirstFixedBase;
-                else
-                    infoRec->WriteBitmap = XAAWriteBitmapColorExpandMSBFirst;
-            }
-            else {
-                if (infoRec->CPUToScreenColorExpandFillFlags &
-                    CPU_TRANSFER_BASE_FIXED)
-                    infoRec->WriteBitmap =
-                        XAAWriteBitmapColorExpandLSBFirstFixedBase;
-                else
-                    infoRec->WriteBitmap = XAAWriteBitmapColorExpandLSBFirst;
-            }
-        }
-        infoRec->WriteBitmapFlags = infoRec->CPUToScreenColorExpandFillFlags;
-    }
-    else if (HaveScanlineColorExpansion) {
-        if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-            TRIPLE_BITS_24BPP) {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->WriteBitmap =
-                    XAAWriteBitmapScanlineColorExpand3MSBFirst;
-            else
-                infoRec->WriteBitmap =
-                    XAAWriteBitmapScanlineColorExpand3LSBFirst;
-        }
-        else {
-            if (infoRec->ScanlineCPUToScreenColorExpandFillFlags &
-                BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->WriteBitmap =
-                    XAAWriteBitmapScanlineColorExpandMSBFirst;
-            else
-                infoRec->WriteBitmap =
-                    XAAWriteBitmapScanlineColorExpandLSBFirst;
-        }
-        infoRec->WriteBitmapFlags =
-            infoRec->ScanlineCPUToScreenColorExpandFillFlags;
-    }
-    else
-        infoRec->WriteBitmap = NULL;
-
-    /**** TE Glyphs ****/
-
-    if (infoRec->TEGlyphRenderer) {
-        XAAMSG("\tDriver provided TEGlyphRenderer replacement\n");
-    }
-    else if (HaveColorExpansion) {
-        infoRec->TEGlyphRendererFlags =
-            infoRec->CPUToScreenColorExpandFillFlags;
-
-        if (infoRec->TEGlyphRendererFlags & TRIPLE_BITS_24BPP) {
-            if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
-                    infoRec->TEGlyphRenderer =
-                        XAATEGlyphRenderer3MSBFirstFixedBase;
-                else
-                    infoRec->TEGlyphRenderer = XAATEGlyphRenderer3MSBFirst;
-            }
-            else {
-                if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
-                    infoRec->TEGlyphRenderer =
-                        XAATEGlyphRenderer3LSBFirstFixedBase;
-                else
-                    infoRec->TEGlyphRenderer = XAATEGlyphRenderer3LSBFirst;
-            }
-
-            if (!HaveSolidFillRect &&
-                (infoRec->TEGlyphRendererFlags & RGB_EQUAL)) {
-                infoRec->TEGlyphRendererFlags &= ~RGB_EQUAL;
-                XAAMSG("WARNING:  TEGlyphRenderer cannot support RGB_EQUAL"
-                       " without solid fills\n");
-            }
-        }
-        else {
-            if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
-                if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
-                    infoRec->TEGlyphRenderer =
-                        XAATEGlyphRendererMSBFirstFixedBase;
-                else
-                    infoRec->TEGlyphRenderer = XAATEGlyphRendererMSBFirst;
-            }
-            else {
-                if (infoRec->TEGlyphRendererFlags & CPU_TRANSFER_BASE_FIXED)
-                    infoRec->TEGlyphRenderer =
-                        XAATEGlyphRendererLSBFirstFixedBase;
-                else
-                    infoRec->TEGlyphRenderer = XAATEGlyphRendererLSBFirst;
-            }
-        }
-
-        if (!HaveSolidFillRect &&
-            (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
-            infoRec->TEGlyphRendererFlags &= ~TRANSPARENCY_ONLY;
-            XAAMSG("WARNING:  TEGlyphRenderer cannot support TRANPARENCY_ONLY"
-                   " without solid fills\n");
-        }
-
-    }
-    else if (HaveScanlineColorExpansion) {
-        infoRec->TEGlyphRendererFlags =
-            infoRec->ScanlineCPUToScreenColorExpandFillFlags;
-
-        if (infoRec->TEGlyphRendererFlags & TRIPLE_BITS_24BPP) {
-            if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->TEGlyphRenderer = XAATEGlyphRendererScanline3MSBFirst;
-            else
-                infoRec->TEGlyphRenderer = XAATEGlyphRendererScanline3LSBFirst;
-
-            if (!HaveSolidFillRect &&
-                (infoRec->TEGlyphRendererFlags & RGB_EQUAL)) {
-                infoRec->TEGlyphRendererFlags &= ~RGB_EQUAL;
-                XAAMSG("WARNING:  TEGlyphRenderer cannot support RGB_EQUAL"
-                       " without solid fills\n");
-            }
-        }
-        else {
-            if (infoRec->TEGlyphRendererFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
-                infoRec->TEGlyphRenderer = XAATEGlyphRendererScanlineMSBFirst;
-            else
-                infoRec->TEGlyphRenderer = XAATEGlyphRendererScanlineLSBFirst;
-        }
-
-        if (!HaveSolidFillRect &&
-            (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
-            infoRec->TEGlyphRendererFlags &= ~TRANSPARENCY_ONLY;
-            XAAMSG("WARNING:  TEGlyphRenderer cannot support TRANPARENCY_ONLY"
-                   " without solid fills\n");
-        }
-    }
-
-    /**** NonTE Glyphs ****/
-
-    if (infoRec->NonTEGlyphRenderer) {
-        XAAMSG("\tDriver provided NonTEGlyphRenderer replacement\n");
-    }
-    else if (infoRec->WriteBitmap &&
-             !(infoRec->WriteBitmapFlags & NO_TRANSPARENCY)) {
-        infoRec->NonTEGlyphRenderer = XAANonTEGlyphRenderer;
-        infoRec->NonTEGlyphRendererFlags = infoRec->WriteBitmapFlags;
-    }
-
-    /**** WritePixmap ****/
-
-    if (infoRec->WritePixmap &&
-        !xf86ReturnOptValBool(options, XAAOPT_WRITE_PIXMAP, FALSE)) {
-        XAAMSG("\tDriver provided WritePixmap replacement\n");
-    }
-    else if (HaveImageWriteRect) {
-        infoRec->WritePixmap = XAAWritePixmap;
-        infoRec->WritePixmapFlags =
-            infoRec->ImageWriteFlags | CONVERT_32BPP_TO_24BPP;
-    }
-    else if (HaveScanlineImageWriteRect) {
-        infoRec->WritePixmap = XAAWritePixmapScanline;
-        infoRec->WritePixmapFlags = infoRec->ScanlineImageWriteFlags;
-    }
-    else
-        infoRec->WritePixmap = NULL;
-
-    /**** ReadPixmap ****/
-
-    if (infoRec->ReadPixmap) {
-        XAAMSG("\tDriver provided ReadPixmap replacement\n");
-    }
-
-    /************** GC Level *************/
-
-    /**** CopyArea ****/
-
-    if (infoRec->CopyArea) {
-        XAAMSG("\tDriver provided GC level CopyArea replacement\n");
-    }
-    else if (infoRec->ScreenToScreenBitBlt) {
-        infoRec->CopyArea = XAACopyArea;
-        infoRec->CopyAreaFlags = infoRec->ScreenToScreenBitBltFlags;
-
-        /* most GC level primitives use one mid-level primitive so
-           the GC level primitive gets the mid-level primitive flag
-           and we use that at GC validation time.  But CopyArea uses
-           more than one mid-level primitive so we have to essentially
-           do a GC validation every time that primitive is used.
-           The CopyAreaFlags would only be used for filtering out the
-           common denominators.  Here we assume that if you don't do
-           ScreenToScreenBitBlt you aren't going to do the others.
-           We also assume that ScreenToScreenBitBlt has the least
-           restrictions. */
-    }
-
-    if (infoRec->CopyPlane) {
-        XAAMSG("\tDriver provided GC level CopyPlane replacement\n");
-    }
-    else if (infoRec->WriteBitmap &&
-             !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY)) {
-        infoRec->CopyPlane = XAACopyPlaneColorExpansion;
-        infoRec->CopyPlaneFlags = infoRec->WriteBitmapFlags;
-    }
-
-    if (infoRec->PushPixelsSolid) {
-        XAAMSG("\tDriver provided GC level PushPixelsSolid replacement\n");
-    }
-    else if (infoRec->WriteBitmap &&
-             !(infoRec->WriteBitmapFlags & NO_TRANSPARENCY)) {
-        infoRec->PushPixelsSolid = XAAPushPixelsSolidColorExpansion;
-        infoRec->PushPixelsFlags = infoRec->WriteBitmapFlags;
-    }
-
-    if (infoRec->FillSolidRects) {
-        if (!infoRec->PolyFillRectSolid) {
-            infoRec->PolyFillRectSolid = XAAPolyFillRect;
-            infoRec->PolyFillRectSolidFlags = infoRec->FillSolidRectsFlags;
-        }
-    }
-    if (infoRec->FillSolidSpans) {
-        if (!infoRec->FillSpansSolid) {
-            infoRec->FillSpansSolid = XAAFillSpans;
-            infoRec->FillSpansSolidFlags = infoRec->FillSolidSpansFlags;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
-        infoRec->FillCacheBltRects || infoRec->FillColorExpandRects ||
-        infoRec->FillCacheExpandRects) {
-        if (!infoRec->PolyFillRectStippled) {
-
-            infoRec->PolyFillRectStippled = XAAPolyFillRect;
-            infoRec->PolyFillRectStippledFlags = 0;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
-        infoRec->FillCacheBltSpans || infoRec->FillColorExpandSpans ||
-        infoRec->FillCacheExpandSpans) {
-        if (!infoRec->FillSpansStippled) {
-
-            infoRec->FillSpansStippled = XAAFillSpans;
-            infoRec->FillSpansStippledFlags = 0;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
-        infoRec->FillCacheBltRects || infoRec->FillColorExpandRects ||
-        infoRec->FillCacheExpandRects) {
-        if (!infoRec->PolyFillRectOpaqueStippled) {
-
-            infoRec->PolyFillRectOpaqueStippled = XAAPolyFillRect;
-            infoRec->PolyFillRectOpaqueStippledFlags = 0;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
-        infoRec->FillCacheBltSpans || infoRec->FillColorExpandSpans ||
-        infoRec->FillCacheExpandSpans) {
-        if (!infoRec->FillSpansOpaqueStippled) {
-
-            infoRec->FillSpansOpaqueStippled = XAAFillSpans;
-            infoRec->FillSpansOpaqueStippledFlags = 0;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternRects || infoRec->FillColor8x8PatternRects ||
-        infoRec->FillCacheBltRects || infoRec->FillImageWriteRects) {
-        if (!infoRec->PolyFillRectTiled) {
-
-            infoRec->PolyFillRectTiled = XAAPolyFillRect;
-            infoRec->PolyFillRectTiledFlags = 0;
-        }
-    }
-
-    if (infoRec->FillMono8x8PatternSpans || infoRec->FillColor8x8PatternSpans ||
-        infoRec->FillCacheBltSpans) {
-        if (!infoRec->FillSpansTiled) {
-
-            infoRec->FillSpansTiled = XAAFillSpans;
-            infoRec->FillSpansTiledFlags = 0;
-        }
-    }
-
-    if (infoRec->TEGlyphRenderer &&
-        !(infoRec->TEGlyphRendererFlags & NO_TRANSPARENCY)) {
-
-        if (!infoRec->PolyText8TE) {
-            infoRec->PolyText8TE = XAAPolyText8TEColorExpansion;
-            infoRec->PolyText8TEFlags = infoRec->TEGlyphRendererFlags;
-        }
-
-        if (!infoRec->PolyText16TE) {
-            infoRec->PolyText16TE = XAAPolyText16TEColorExpansion;
-            infoRec->PolyText16TEFlags = infoRec->TEGlyphRendererFlags;
-        }
-
-        if (!infoRec->PolyGlyphBltTE) {
-            infoRec->PolyGlyphBltTE = XAAPolyGlyphBltTEColorExpansion;
-            infoRec->PolyGlyphBltTEFlags = infoRec->TEGlyphRendererFlags;
-        }
-    }
-
-    if (infoRec->TEGlyphRenderer &&
-        !(infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
-
-        if (!infoRec->ImageText8TE) {
-            infoRec->ImageText8TE = XAAImageText8TEColorExpansion;
-            infoRec->ImageText8TEFlags = infoRec->TEGlyphRendererFlags;
-        }
-
-        if (!infoRec->ImageText16TE) {
-            infoRec->ImageText16TE = XAAImageText16TEColorExpansion;
-            infoRec->ImageText16TEFlags = infoRec->TEGlyphRendererFlags;
-        }
-
-        if (!infoRec->ImageGlyphBltTE) {
-            infoRec->ImageGlyphBltTE = XAAImageGlyphBltTEColorExpansion;
-            infoRec->ImageGlyphBltTEFlags = infoRec->TEGlyphRendererFlags;
-        }
-    }
-
-    if (infoRec->NonTEGlyphRenderer) {
-        if (!infoRec->PolyText8NonTE) {
-            infoRec->PolyText8NonTE = XAAPolyText8NonTEColorExpansion;
-            infoRec->PolyText8NonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-
-        if (!infoRec->PolyText16NonTE) {
-            infoRec->PolyText16NonTE = XAAPolyText16NonTEColorExpansion;
-            infoRec->PolyText16NonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-        if (!infoRec->PolyGlyphBltNonTE) {
-            infoRec->PolyGlyphBltNonTE = XAAPolyGlyphBltNonTEColorExpansion;
-            infoRec->PolyGlyphBltNonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-    }
-
-    if (infoRec->NonTEGlyphRenderer && HaveSolidFillRect) {
-        if (!infoRec->ImageText8NonTE) {
-            infoRec->ImageText8NonTE = XAAImageText8NonTEColorExpansion;
-            infoRec->ImageText8NonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-
-        if (!infoRec->ImageText16NonTE) {
-            infoRec->ImageText16NonTE = XAAImageText16NonTEColorExpansion;
-            infoRec->ImageText16NonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-
-        if (!infoRec->ImageGlyphBltNonTE) {
-            infoRec->ImageGlyphBltNonTE = XAAImageGlyphBltNonTEColorExpansion;
-            infoRec->ImageGlyphBltNonTEFlags = infoRec->NonTEGlyphRendererFlags;
-        }
-    }
-
-    if (!infoRec->PolyRectangleThinSolid && HaveSolidHorVertLine) {
-        infoRec->PolyRectangleThinSolid = XAAPolyRectangleThinSolid;
-        infoRec->PolyRectangleThinSolidFlags = infoRec->SolidLineFlags;
-    }
-
-    if (!infoRec->FillPolygonSolid && HaveSolidFillRect) {
-        infoRec->FillPolygonSolid = XAAFillPolygonSolid;
-        infoRec->FillPolygonSolidFlags = infoRec->SolidFillFlags;
-    }
-
-    if (!infoRec->FillPolygonStippled && (HaveMono8x8PatternFillRect ||
-                                          HaveScreenToScreenColorExpandFill ||
-                                          HaveScreenToScreenCopy)) {
-        infoRec->FillPolygonStippled = XAAFillPolygonStippled;
-        infoRec->FillPolygonStippledFlags = infoRec->SolidFillFlags;
-    }
-
-    if (!infoRec->FillPolygonOpaqueStippled && (HaveMono8x8PatternFillRect ||
-                                                HaveScreenToScreenColorExpandFill
-                                                || HaveScreenToScreenCopy)) {
-        infoRec->FillPolygonOpaqueStippled = XAAFillPolygonStippled;
-        infoRec->FillPolygonOpaqueStippledFlags = infoRec->SolidFillFlags;
-    }
-
-    if (!infoRec->FillPolygonTiled && (HaveMono8x8PatternFillRect ||
-                                       HaveScreenToScreenColorExpandFill ||
-                                       HaveScreenToScreenCopy)) {
-        infoRec->FillPolygonTiled = XAAFillPolygonTiled;
-        infoRec->FillPolygonTiledFlags = infoRec->SolidFillFlags;
-    }
-
-    if (!infoRec->PolyFillArcSolid && HaveSolidFillRect) {
-        infoRec->PolyFillArcSolid = XAAPolyFillArcSolid;
-        infoRec->PolyFillArcSolidFlags = infoRec->SolidFillFlags;
-    }
-
-    if (!infoRec->PolylinesWideSolid && HaveSolidFillRect) {
-        infoRec->PolylinesWideSolid = XAAPolylinesWideSolid;
-        infoRec->PolylinesWideSolidFlags =
-            infoRec->SolidFillFlags | GXCOPY_ONLY;
-    }
-
-    if (!infoRec->PutImage && (infoRec->WritePixmap ||
-                               (infoRec->WriteBitmap &&
-                                !(infoRec->
-                                  WriteBitmapFlags & TRANSPARENCY_ONLY)))) {
-        infoRec->PutImage = XAAPutImage;
-
-        /* See comment for CopyArea above.  But here we make fewer 
-           assumptions.  The driver can provide the PutImageFlags if
-           it wants too */
-    }
-
-    if (HaveSolidHorVertLine &&
-        (HaveSolidBresenhamLine || (HaveSolidTwoPointLine &&
-                                    (infoRec->
-                                     ClippingFlags &
-                                     HARDWARE_CLIP_SOLID_LINE)))) {
-        if (!infoRec->PolylinesThinSolid) {
-            infoRec->PolylinesThinSolid = XAAPolyLines;
-            infoRec->PolylinesThinSolidFlags = infoRec->SolidLineFlags;
-        }
-        if (!infoRec->PolySegmentThinSolid) {
-            infoRec->PolySegmentThinSolid = XAAPolySegment;
-            infoRec->PolySegmentThinSolidFlags = infoRec->SolidLineFlags;
-        }
-    }
-
-    if (HaveDashedBresenhamLine || (HaveDashedTwoPointLine &&
-                                    (infoRec->
-                                     ClippingFlags &
-                                     HARDWARE_CLIP_DASHED_LINE))) {
-        if (!infoRec->PolylinesThinDashed) {
-            infoRec->PolylinesThinDashed = XAAPolyLinesDashed;
-            infoRec->PolylinesThinDashedFlags = infoRec->DashedLineFlags;
-        }
-        if (!infoRec->PolySegmentThinDashed) {
-            infoRec->PolySegmentThinDashed = XAAPolySegmentDashed;
-            infoRec->PolySegmentThinDashedFlags = infoRec->DashedLineFlags;
-        }
-    }
-
-    if (infoRec->PolylinesThinDashed || infoRec->PolySegmentThinDashed) {
-        if (!infoRec->ComputeDash)
-            infoRec->ComputeDash = XAAComputeDash;
-    }
-
-    {
-        Bool haveTexture = infoRec->CPUToScreenTextureFormats &&
-            infoRec->CPUToScreenTextureDstFormats &&
-            infoRec->SetupForCPUToScreenTexture2 &&
-            infoRec->SubsequentCPUToScreenTexture;
-        Bool haveAlphaTexture = infoRec->CPUToScreenAlphaTextureFormats &&
-            infoRec->CPUToScreenAlphaTextureDstFormats &&
-            infoRec->SetupForCPUToScreenAlphaTexture2 &&
-            infoRec->SubsequentCPUToScreenAlphaTexture;
-
-        if (!infoRec->Composite && (haveTexture || haveAlphaTexture))
-            infoRec->Composite = XAADoComposite;
-
-        if (!infoRec->Glyphs && infoRec->WriteBitmap &&
-            !(infoRec->WriteBitmapFlags & NO_TRANSPARENCY)) {
-            infoRec->Glyphs = XAADoGlyphs;
-        }
-    }
-
-    /************  Validation Functions **************/
-
-    if (!infoRec->ValidateCopyArea && infoRec->CopyArea) {
-        infoRec->CopyAreaMask = GCWhenForced;
-        if ((infoRec->CopyAreaFlags & GXCOPY_ONLY) ||
-            (infoRec->CopyAreaFlags & ROP_NEEDS_SOURCE))
-            infoRec->CopyAreaMask |= GCFunction;
-        if (infoRec->CopyAreaFlags & NO_PLANEMASK)
-            infoRec->CopyAreaMask |= GCPlaneMask;
-        infoRec->ValidateCopyArea = XAAValidateCopyArea;
-    }
-
-    if (!infoRec->ValidateCopyPlane && infoRec->CopyPlane) {
-        infoRec->CopyPlaneMask = GCWhenForced;
-        if ((infoRec->CopyPlaneFlags & GXCOPY_ONLY) ||
-            (infoRec->CopyPlaneFlags & ROP_NEEDS_SOURCE))
-            infoRec->CopyPlaneMask |= GCFunction;
-        if (infoRec->CopyPlaneFlags & NO_PLANEMASK)
-            infoRec->CopyPlaneMask |= GCPlaneMask;
-        if (infoRec->CopyPlaneFlags & RGB_EQUAL)
-            infoRec->CopyPlaneMask |= GCForeground | GCBackground;
-        infoRec->ValidateCopyPlane = XAAValidateCopyPlane;
-    }
-
-    if (!infoRec->ValidatePutImage && infoRec->PutImage) {
-        infoRec->PutImageMask = GCWhenForced;
-        if ((infoRec->PutImageFlags & GXCOPY_ONLY) ||
-            (infoRec->PutImageFlags & ROP_NEEDS_SOURCE))
-            infoRec->PutImageMask |= GCFunction;
-        if (infoRec->PutImageFlags & NO_PLANEMASK)
-            infoRec->PutImageMask |= GCPlaneMask;
-        if (infoRec->PutImageFlags & RGB_EQUAL)
-            infoRec->PutImageMask |= GCForeground | GCBackground;
-        infoRec->ValidatePutImage = XAAValidatePutImage;
-    }
-
-    if (!infoRec->ValidatePushPixels && infoRec->PushPixelsSolid) {
-        infoRec->PushPixelsMask = GCFillStyle;
-        if ((infoRec->PushPixelsFlags & GXCOPY_ONLY) ||
-            (infoRec->PushPixelsFlags & ROP_NEEDS_SOURCE) ||
-            (infoRec->PushPixelsFlags & TRANSPARENCY_GXCOPY_ONLY))
-            infoRec->PushPixelsMask |= GCFunction;
-        if (infoRec->PushPixelsFlags & NO_PLANEMASK)
-            infoRec->PushPixelsMask |= GCPlaneMask;
-        if (infoRec->PushPixelsFlags & RGB_EQUAL)
-            infoRec->PushPixelsMask |= GCForeground;
-        infoRec->ValidatePushPixels = XAAValidatePushPixels;
-    }
-
-    /* By default XAA assumes the FillSpans, PolyFillRects, FillPolygon
-       and PolyFillArcs have the same restrictions.  If you supply GC 
-       level replacements for any of these and alter this relationship 
-       you may need to supply replacement validation routines */
-
-    if (!infoRec->ValidateFillSpans &&
-        (infoRec->FillSpansSolid || infoRec->FillSpansStippled ||
-         infoRec->FillSpansOpaqueStippled || infoRec->FillSpansTiled)) {
-
-        int compositeFlags = infoRec->FillSpansSolidFlags |
-            infoRec->FillSpansStippledFlags |
-            infoRec->FillSpansOpaqueStippledFlags |
-            infoRec->FillSpansTiledFlags;
-
-        infoRec->FillSpansMask = GCFillStyle | GCTile | GCStipple;
-
-        if ((compositeFlags & GXCOPY_ONLY) ||
-            (compositeFlags & ROP_NEEDS_SOURCE))
-            infoRec->FillSpansMask |= GCFunction;
-        if (compositeFlags & NO_PLANEMASK)
-            infoRec->FillSpansMask |= GCPlaneMask;
-        if (compositeFlags & RGB_EQUAL)
-            infoRec->FillSpansMask |= GCForeground;
-        infoRec->ValidateFillSpans = XAAValidateFillSpans;
-    }
-
-    /* By default XAA only provides Validations for the GlyphBlt
-       functions and not the text higher up. This is because the
-       Text8/16 and GlyphBlt are linked.  If you break this linkage,
-       you may need to have the driver supply its own Validation
-       routines */
-
-    if (!infoRec->ValidatePolyGlyphBlt &&
-        (infoRec->PolyGlyphBltTE || infoRec->PolyGlyphBltNonTE)) {
-        int compositeFlags = infoRec->PolyGlyphBltTEFlags |
-            infoRec->PolyGlyphBltNonTEFlags;
-
-        infoRec->PolyGlyphBltMask = GCFillStyle | GCFont;
-        if ((compositeFlags & GXCOPY_ONLY) ||
-            (compositeFlags & ROP_NEEDS_SOURCE) ||
-            (infoRec->PolyGlyphBltNonTEFlags & TRANSPARENCY_GXCOPY_ONLY))
-            infoRec->PolyGlyphBltMask |= GCFunction;
-        if (compositeFlags & NO_PLANEMASK)
-            infoRec->PolyGlyphBltMask |= GCPlaneMask;
-        if (compositeFlags & RGB_EQUAL)
-            infoRec->PolyGlyphBltMask |= GCForeground;
-        infoRec->ValidatePolyGlyphBlt = XAAValidatePolyGlyphBlt;
-    }
-
-    if (!infoRec->ValidateImageGlyphBlt &&
-        (infoRec->ImageGlyphBltTE || infoRec->ImageGlyphBltNonTE)) {
-        int compositeFlags = infoRec->ImageGlyphBltTEFlags |
-            infoRec->ImageGlyphBltNonTEFlags;
-
-        if (infoRec->ImageGlyphBltNonTE)
-            compositeFlags |= infoRec->SolidFillFlags;
-
-        infoRec->ImageGlyphBltMask = GCFont;
-        if (compositeFlags & NO_PLANEMASK)
-            infoRec->ImageGlyphBltMask |= GCPlaneMask;
-        if (compositeFlags & RGB_EQUAL)
-            infoRec->ImageGlyphBltMask |= GCForeground | GCBackground;
-        infoRec->ValidateImageGlyphBlt = XAAValidateImageGlyphBlt;
-    }
-
-    /* By default XAA only provides a Validation function for the 
-       Polylines and does segments and polylines at the same time */
-
-    if (!infoRec->ValidatePolylines && infoRec->ValidateFillSpans) {
-        int compositeFlags = infoRec->PolyRectangleThinSolidFlags |
-            infoRec->PolylinesWideSolidFlags |
-            infoRec->PolylinesThinSolidFlags |
-            infoRec->PolySegmentThinSolidFlags |
-            infoRec->PolySegmentThinDashedFlags |
-            infoRec->PolylinesThinDashedFlags;
-
-        infoRec->ValidatePolylines = XAAValidatePolylines;
-        infoRec->PolylinesMask =
-            infoRec->FillSpansMask | GCLineStyle | GCLineWidth;
-
-        if (infoRec->PolySegmentThinDashed || infoRec->PolylinesThinDashed)
-            infoRec->PolylinesMask |= GCDashList;
-        if (compositeFlags & NO_PLANEMASK)
-            infoRec->PolylinesMask |= GCPlaneMask;
-        if ((compositeFlags & GXCOPY_ONLY) ||
-            (compositeFlags & ROP_NEEDS_SOURCE))
-            infoRec->PolylinesMask |= GCFunction;
-        if (compositeFlags & RGB_EQUAL)
-            infoRec->PolylinesMask |= GCForeground;
-    }
-
-    /**** Fill choosers ****/
-
-    if (!infoRec->StippledFillChooser)
-        infoRec->StippledFillChooser = XAAStippledFillChooser;
-
-    if (!infoRec->OpaqueStippledFillChooser)
-        infoRec->OpaqueStippledFillChooser = XAAOpaqueStippledFillChooser;
-
-    if (!infoRec->TiledFillChooser)
-        infoRec->TiledFillChooser = XAATiledFillChooser;
-
-    /**** Setup the pixmap cache ****/
-
-    if (infoRec->WriteBitmapToCache) {
-    }
-    else if (infoRec->WriteBitmap &&
-             !(infoRec->WriteBitmapFlags & TRANSPARENCY_ONLY))
-        infoRec->WriteBitmapToCache = XAAWriteBitmapToCache;
-    else if (infoRec->Flags & LINEAR_FRAMEBUFFER)
-        infoRec->WriteBitmapToCache = XAAWriteBitmapToCacheLinear;
-    else
-        infoRec->PixmapCacheFlags |= DO_NOT_BLIT_STIPPLES;
-
-    if (infoRec->WritePixmapToCache) {
-    }
-    else if (infoRec->WritePixmap && !(infoRec->WritePixmapFlags & NO_GXCOPY))
-        infoRec->WritePixmapToCache = XAAWritePixmapToCache;
-    else if (infoRec->Flags & LINEAR_FRAMEBUFFER)
-        infoRec->WritePixmapToCache = XAAWritePixmapToCacheLinear;
-    else
-        infoRec->Flags &= ~PIXMAP_CACHE;
-
-    if (xf86ReturnOptValBool(options, XAAOPT_PIXMAP_CACHE, FALSE))
-        infoRec->Flags &= ~PIXMAP_CACHE;
-
-    if (infoRec->WriteMono8x8PatternToCache) {
-    }
-    else if (infoRec->PixmapCacheFlags & CACHE_MONO_8x8) {
-        if (infoRec->WritePixmapToCache)
-            infoRec->WriteMono8x8PatternToCache = XAAWriteMono8x8PatternToCache;
-        else
-            infoRec->PixmapCacheFlags &= ~CACHE_MONO_8x8;
-    }
-
-    if (infoRec->WriteColor8x8PatternToCache) {
-    }
-    else if (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8) {
-        if (infoRec->WritePixmapToCache && infoRec->WriteBitmapToCache)
-            infoRec->WriteColor8x8PatternToCache =
-                XAAWriteColor8x8PatternToCache;
-        else
-            infoRec->PixmapCacheFlags &= ~CACHE_COLOR_8x8;
-    }
-
-    if (infoRec->CachePixelGranularity < 0) {
-        switch (pScrn->bitsPerPixel) {
-        case 24:
-        case 8:
-            infoRec->CachePixelGranularity = 4;
-            break;
-        case 16:
-            infoRec->CachePixelGranularity = 2;
-            break;
-        case 32:
-            infoRec->CachePixelGranularity = 1;
-            break;
-        default:
-            break;
-        }
-
-        if (BITMAP_SCANLINE_PAD == 64)
-            infoRec->CachePixelGranularity *= 2;
-    }
-
-    free(options);
-
-    if (!infoRec->CacheTile && infoRec->WritePixmapToCache)
-        infoRec->CacheTile = XAACacheTile;
-    if (!infoRec->CacheMonoStipple && infoRec->WritePixmapToCache)
-        infoRec->CacheMonoStipple = XAACacheMonoStipple;
-    if (!infoRec->CacheStipple && infoRec->WriteBitmapToCache)
-        infoRec->CacheStipple = XAACacheStipple;
-    if (!infoRec->CacheMono8x8Pattern && infoRec->WriteMono8x8PatternToCache)
-        infoRec->CacheMono8x8Pattern = XAACacheMono8x8Pattern;
-    if (!infoRec->CacheColor8x8Pattern && infoRec->WriteColor8x8PatternToCache)
-        infoRec->CacheColor8x8Pattern = XAACacheColor8x8Pattern;
-
-    if ((infoRec->Flags & PIXMAP_CACHE) && !infoRec->InitPixmapCache) {
-        infoRec->InitPixmapCache = XAAInitPixmapCache;
-        infoRec->ClosePixmapCache = XAAClosePixmapCache;
-    }
-
-    return TRUE;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaLine.c b/xorg-server/hw/xfree86/xaa/xaaLine.c
deleted file mode 100644
index d7c60975e..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaLine.c
+++ /dev/null
@@ -1,422 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <stdlib.h>
-
-#include <X11/X.h>
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "miline.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-void
-#ifdef POLYSEGMENT
- XAAPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment * pSeg
-#else
-XAAPolyLines(DrawablePtr pDrawable, GCPtr pGC, int mode,        /* Origin or Previous */
-             int npt,           /* number of points */
-             DDXPointPtr pptInit
-#endif
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr pboxInit = RegionRects(pGC->pCompositeClip);
-    int nboxInit = RegionNumRects(pGC->pCompositeClip);
-    unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
-    int xorg = pDrawable->x;
-    int yorg = pDrawable->y;
-    int nbox;
-    BoxPtr pbox;
-
-#ifndef POLYSEGMENT
-    DDXPointPtr ppt;
-#endif
-    int x1, x2, y1, y2, tmp, len;
-
-    if (!nboxInit)
-        return;
-
-    if (infoRec->SolidLineFlags & LINE_LIMIT_COORDS) {
-        int minValX = infoRec->SolidLineLimits.x1;
-        int maxValX = infoRec->SolidLineLimits.x2;
-        int minValY = infoRec->SolidLineLimits.y1;
-        int maxValY = infoRec->SolidLineLimits.y2;
-
-#ifdef POLYSEGMENT
-        int n = nseg;
-        xSegment *s = pSeg;
-
-        while (n--)
-#else
-        int n = npt;
-        int xorgtmp = xorg;
-        int yorgtmp = yorg;
-
-        ppt = pptInit;
-        x2 = ppt->x + xorgtmp;
-        y2 = ppt->y + yorgtmp;
-        while (--n)
-#endif
-        {
-#ifdef POLYSEGMENT
-            x1 = s->x1 + xorg;
-            y1 = s->y1 + yorg;
-            x2 = s->x2 + xorg;
-            y2 = s->y2 + yorg;
-            s++;
-#else
-            x1 = x2;
-            y1 = y2;
-            ++ppt;
-            if (mode == CoordModePrevious) {
-                xorgtmp = x1;
-                yorgtmp = y1;
-            }
-            x2 = ppt->x + xorgtmp;
-            y2 = ppt->y + yorgtmp;
-#endif
-            if (x1 > maxValX || x1 < minValX ||
-                x2 > maxValX || x2 < minValX ||
-                y1 > maxValY || y1 < minValY || y2 > maxValY || y2 < minValY) {
-#ifdef POLYSEGMENT
-                XAAFallbackOps.PolySegment(pDrawable, pGC, nseg, pSeg);
-#else
-                XAAFallbackOps.Polylines(pDrawable, pGC, mode, npt, pptInit);
-#endif
-                return;
-            }
-        }
-    }
-
-    (*infoRec->SetupForSolidLine) (infoRec->pScrn, pGC->fgPixel,
-                                   pGC->alu, pGC->planemask);
-
-#ifdef POLYSEGMENT
-    while (nseg--)
-#else
-    ppt = pptInit;
-    x2 = ppt->x + xorg;
-    y2 = ppt->y + yorg;
-    while (--npt)
-#endif
-    {
-        nbox = nboxInit;
-        pbox = pboxInit;
-
-#ifdef POLYSEGMENT
-        x1 = pSeg->x1 + xorg;
-        y1 = pSeg->y1 + yorg;
-        x2 = pSeg->x2 + xorg;
-        y2 = pSeg->y2 + yorg;
-        pSeg++;
-#else
-        x1 = x2;
-        y1 = y2;
-        ++ppt;
-        if (mode == CoordModePrevious) {
-            xorg = x1;
-            yorg = y1;
-        }
-        x2 = ppt->x + xorg;
-        y2 = ppt->y + yorg;
-#endif
-
-        if (x1 == x2) {         /* vertical line */
-            /* make the line go top to bottom of screen, keeping
-               endpoint semantics
-             */
-            if (y1 > y2) {
-                tmp = y2;
-                y2 = y1 + 1;
-                y1 = tmp + 1;
-#ifdef POLYSEGMENT
-                if (pGC->capStyle != CapNotLast)
-                    y1--;
-#endif
-            }
-#ifdef POLYSEGMENT
-            else if (pGC->capStyle != CapNotLast)
-                y2++;
-#endif
-            /* get to first band that might contain part of line */
-            while (nbox && (pbox->y2 <= y1)) {
-                pbox++;
-                nbox--;
-            }
-
-            /* stop when lower edge of box is beyond end of line */
-            while (nbox && (y2 >= pbox->y1)) {
-                if ((x1 >= pbox->x1) && (x1 < pbox->x2)) {
-                    tmp = max(y1, pbox->y1);
-                    len = min(y2, pbox->y2) - tmp;
-                    if (len)
-                        (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                                x1, tmp, len,
-                                                                DEGREES_270);
-                }
-                nbox--;
-                pbox++;
-            }
-#ifndef POLYSEGMENT
-            y2 = ppt->y + yorg;
-#endif
-        }
-        else if (y1 == y2) {    /* horizontal line */
-            /* force line from left to right, keeping endpoint semantics */
-            if (x1 > x2) {
-                tmp = x2;
-                x2 = x1 + 1;
-                x1 = tmp + 1;
-#ifdef POLYSEGMENT
-                if (pGC->capStyle != CapNotLast)
-                    x1--;
-#endif
-            }
-#ifdef POLYSEGMENT
-            else if (pGC->capStyle != CapNotLast)
-                x2++;
-#endif
-
-            /* find the correct band */
-            while (nbox && (pbox->y2 <= y1)) {
-                pbox++;
-                nbox--;
-            }
-
-            /* try to draw the line, if we haven't gone beyond it */
-            if (nbox && (pbox->y1 <= y1)) {
-                int orig_y = pbox->y1;
-
-                /* when we leave this band, we're done */
-                while (nbox && (orig_y == pbox->y1)) {
-                    if (pbox->x2 <= x1) {
-                        /* skip boxes until one might contain start point */
-                        nbox--;
-                        pbox++;
-                        continue;
-                    }
-
-                    /* stop if left of box is beyond right of line */
-                    if (pbox->x1 >= x2) {
-                        nbox = 0;
-                        break;
-                    }
-
-                    tmp = max(x1, pbox->x1);
-                    len = min(x2, pbox->x2) - tmp;
-                    if (len)
-                        (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                                tmp, y1, len,
-                                                                DEGREES_0);
-                    nbox--;
-                    pbox++;
-                }
-            }
-#ifndef POLYSEGMENT
-            x2 = ppt->x + xorg;
-#endif
-        }
-        else {                  /* sloped line */
-            unsigned int oc1, oc2;
-            int dmin, dmaj, e, octant;
-
-            if (infoRec->SubsequentSolidBresenhamLine) {
-                if ((dmaj = x2 - x1) < 0) {
-                    dmaj = -dmaj;
-                    octant = XDECREASING;
-                }
-                else
-                    octant = 0;
-
-                if ((dmin = y2 - y1) < 0) {
-                    dmin = -dmin;
-                    octant |= YDECREASING;
-                }
-
-                if (dmin >= dmaj) {
-                    tmp = dmin;
-                    dmin = dmaj;
-                    dmaj = tmp;
-                    octant |= YMAJOR;
-                }
-
-                e = -dmaj - ((bias >> octant) & 1);
-                len = dmaj;
-                dmin <<= 1;
-                dmaj <<= 1;
-            }
-            else {              /* Muffle compiler */
-                dmin = dmaj = e = octant = len = 0;
-            }
-
-            while (nbox--) {
-                oc1 = oc2 = 0;
-                OUTCODES(oc1, x1, y1, pbox);
-                OUTCODES(oc2, x2, y2, pbox);
-                if (!(oc1 | oc2)) {     /* unclipped */
-                    if (infoRec->SubsequentSolidTwoPointLine) {
-                        (*infoRec->SubsequentSolidTwoPointLine) (infoRec->pScrn,
-                                                                 x1, y1, x2, y2,
-#ifdef POLYSEGMENT
-                                                                 (pGC->
-                                                                  capStyle !=
-                                                                  CapNotLast) ?
-                                                                 0 :
-#endif
-                                                                 OMIT_LAST);
-                    }
-                    else {
-                        (*infoRec->SubsequentSolidBresenhamLine) (infoRec->
-                                                                  pScrn, x1, y1,
-                                                                  dmaj, dmin, e,
-#ifdef POLYSEGMENT
-                                                                  (pGC->
-                                                                   capStyle !=
-                                                                   CapNotLast)
-                                                                  ? (len + 1) :
-#endif
-                                                                  len, octant);
-                    }
-                    break;
-                }
-                else if (oc1 & oc2) {   /* completely clipped */
-                    pbox++;
-                }
-                else if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_LINE) {
-                    (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                                      pbox->x1, pbox->y1,
-                                                      pbox->x2 - 1,
-                                                      pbox->y2 - 1);
-
-                    if (infoRec->SubsequentSolidBresenhamLine) {
-                        (*infoRec->SubsequentSolidBresenhamLine) (infoRec->
-                                                                  pScrn, x1, y1,
-                                                                  dmaj, dmin, e,
-#ifdef POLYSEGMENT
-                                                                  (pGC->
-                                                                   capStyle !=
-                                                                   CapNotLast)
-                                                                  ? (len + 1) :
-#endif
-                                                                  len, octant);
-                    }
-                    else {
-                        (*infoRec->SubsequentSolidTwoPointLine) (infoRec->pScrn,
-                                                                 x1, y1, x2, y2,
-#ifdef POLYSEGMENT
-                                                                 (pGC->
-                                                                  capStyle !=
-                                                                  CapNotLast) ?
-                                                                 0 :
-#endif
-                                                                 OMIT_LAST);
-                    }
-                    (*infoRec->DisableClipping) (infoRec->pScrn);
-                    pbox++;
-                }
-                else {
-                    int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
-                    int clip1 = 0, clip2 = 0;
-                    int err, adx, ady;
-
-                    if (octant & YMAJOR) {
-                        ady = dmaj >> 1;
-                        adx = dmin >> 1;
-                    }
-                    else {
-                        ady = dmin >> 1;
-                        adx = dmaj >> 1;
-                    }
-
-                    if (miZeroClipLine(pbox->x1, pbox->y1,
-                                       pbox->x2 - 1, pbox->y2 - 1,
-                                       &new_x1, &new_y1, &new_x2, &new_y2,
-                                       adx, ady, &clip1, &clip2,
-                                       octant, bias, oc1, oc2) == -1) {
-                        pbox++;
-                        continue;
-                    }
-
-                    if (octant & YMAJOR)
-                        len = abs(new_y2 - new_y1);
-                    else
-                        len = abs(new_x2 - new_x1);
-#ifdef POLYSEGMENT
-                    if (clip2 != 0 || pGC->capStyle != CapNotLast)
-                        len++;
-#else
-                    len += (clip2 != 0);
-#endif
-                    if (len) {
-                        int abserr, clipdx, clipdy;
-
-                        /* unwind bresenham error term to first point */
-                        if (clip1) {
-                            clipdx = abs(new_x1 - x1);
-                            clipdy = abs(new_y1 - y1);
-
-                            if (octant & YMAJOR)
-                                err = e + clipdy * dmin - clipdx * dmaj;
-                            else
-                                err = e + clipdx * dmin - clipdy * dmaj;
-                        }
-                        else
-                            err = e;
-
-#define range infoRec->SolidBresenhamLineErrorTermBits
-                        abserr = abs(err);
-                        while ((abserr & range) ||
-                               (dmaj & range) || (dmin & range)) {
-                            dmin >>= 1;
-                            dmaj >>= 1;
-                            abserr >>= 1;
-                            err /= 2;
-                        }
-
-                        (*infoRec->SubsequentSolidBresenhamLine) (infoRec->
-                                                                  pScrn, new_x1,
-                                                                  new_y1, dmaj,
-                                                                  dmin, err,
-                                                                  len, octant);
-                    }
-                    pbox++;
-                }
-            }                   /* while (nbox--) */
-        }                       /* sloped line */
-    }                           /* while (nline--) */
-
-#ifndef POLYSEGMENT
-    /* paint the last point if the end style isn't CapNotLast.
-       (Assume that a projecting, butt, or round cap that is one
-       pixel wide is the same as the single pixel of the endpoint.)
-     */
-
-    if ((pGC->capStyle != CapNotLast) &&
-        ((ppt->x + xorg != pptInit->x + pDrawable->x) ||
-         (ppt->y + yorg != pptInit->y + pDrawable->y) ||
-         (ppt == pptInit + 1))) {
-        nbox = nboxInit;
-        pbox = pboxInit;
-        while (nbox--) {
-            if ((x2 >= pbox->x1) && (y2 >= pbox->y1) &&
-                (x2 < pbox->x2) && (y2 < pbox->y2)) {
-                (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn, x2, y2,
-                                                        1, DEGREES_0);
-                break;
-            }
-            else
-                pbox++;
-        }
-    }
-#endif
-
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaLineMisc.c b/xorg-server/hw/xfree86/xaa/xaaLineMisc.c
deleted file mode 100644
index 4379778f6..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaLineMisc.c
+++ /dev/null
@@ -1,149 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "miline.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-void
-XAASolidHorVertLineAsRects(ScrnInfoPtr pScrn, int x, int y, int len, int dir)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    if (dir == DEGREES_0)
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, len, 1);
-    else
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, 1, len);
-}
-
-void
-XAASolidHorVertLineAsTwoPoint(ScrnInfoPtr pScrn, int x, int y, int len, int dir)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    len--;
-
-    if (dir == DEGREES_0)
-        (*infoRec->SubsequentSolidTwoPointLine) (pScrn, x, y, x + len, y, 0);
-    else
-        (*infoRec->SubsequentSolidTwoPointLine) (pScrn, x, y, x, y + len, 0);
-}
-
-void
-XAASolidHorVertLineAsBresenham(ScrnInfoPtr pScrn,
-                               int x, int y, int len, int dir)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    if (dir == DEGREES_0)
-        (*infoRec->SubsequentSolidBresenhamLine) (pScrn, x, y, len << 1, 0,
-                                                  -len, len, 0);
-    else
-        (*infoRec->SubsequentSolidBresenhamLine) (pScrn, x, y, len << 1, 0,
-                                                  -len, len, YMAJOR);
-}
-
-void
-XAAComputeDash(GCPtr pGC)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAGCPtr pGCPriv = (XAAGCPtr) dixLookupPrivate(&pGC->devPrivates,
-                                                   XAAGetGCKey());
-    Bool EvenDash = (pGC->numInDashList & 0x01) ? FALSE : TRUE;
-    int PatternLength = 0;
-    unsigned char *DashPtr = (unsigned char *) pGC->dash;
-    CARD32 *ptr;
-    int count = pGC->numInDashList;
-    int shift, value, direction;
-    Bool set;
-
-    free(pGCPriv->DashPattern);
-
-    pGCPriv->DashPattern = NULL;
-    pGCPriv->DashLength = 0;
-
-    while (count--)
-        PatternLength += *(DashPtr++);
-
-    if (!EvenDash)
-        PatternLength <<= 1;
-
-    if (PatternLength > infoRec->DashPatternMaxLength)
-        return;
-
-    if ((infoRec->DashedLineFlags & LINE_PATTERN_POWER_OF_2_ONLY) &&
-        (PatternLength & (PatternLength - 1)))
-        return;
-
-    pGCPriv->DashPattern = calloc((PatternLength + 31) >> 5, 4);
-    if (!pGCPriv->DashPattern)
-        return;
-    pGCPriv->DashLength = PatternLength;
-
-    if (infoRec->DashedLineFlags & (LINE_PATTERN_LSBFIRST_MSBJUSTIFIED |
-                                    LINE_PATTERN_LSBFIRST_LSBJUSTIFIED)) {
-        direction = 1;
-        set = TRUE;
-        DashPtr = (unsigned char *) pGC->dash;
-    }
-    else {
-        direction = -1;
-        set = FALSE;
-        DashPtr = (unsigned char *) pGC->dash + pGC->numInDashList - 1;
-    }
-
-    if (infoRec->DashedLineFlags & (LINE_PATTERN_LSBFIRST_MSBJUSTIFIED |
-                                    LINE_PATTERN_MSBFIRST_MSBJUSTIFIED))
-        shift = 32 - (PatternLength & 31);
-    else
-        shift = 0;
-
-    ptr = (CARD32 *) (pGCPriv->DashPattern);
-
- CONCATENATE:
-
-    count = pGC->numInDashList;
-
-    while (count--) {
-        value = *DashPtr;
-        DashPtr += direction;
-        while (value) {
-            if (value < (32 - shift)) {
-                if (set)
-                    *ptr |= XAAShiftMasks[value] << shift;
-                shift += value;
-                break;
-            }
-            else {
-                if (set)
-                    *ptr |= ~0L << shift;
-                value -= (32 - shift);
-                shift = 0;
-                ptr++;
-            }
-        }
-        if (set)
-            set = FALSE;
-        else
-            set = TRUE;
-    }
-
-    if (!EvenDash) {
-        EvenDash = TRUE;
-        if (infoRec->DashedLineFlags & (LINE_PATTERN_LSBFIRST_MSBJUSTIFIED |
-                                        LINE_PATTERN_LSBFIRST_LSBJUSTIFIED))
-            DashPtr = (unsigned char *) pGC->dash;
-        else
-            DashPtr = (unsigned char *) pGC->dash + pGC->numInDashList;
-        goto CONCATENATE;
-    }
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaNonTEGlyph.c b/xorg-server/hw/xfree86/xaa/xaaNonTEGlyph.c
deleted file mode 100644
index bfe7f9a09..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaNonTEGlyph.c
+++ /dev/null
@@ -1,192 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaacexp.h"
-#include "xf86.h"
-
-/* Not used anymore because the algorithm isn't correct. It doesn't
-   handle overlapping characters properly */
-
-#ifdef TRIPLE_BITS
-#define NonTEGlyphFunc EXPNAME(XAANonTEGlyphScanlineFunc3)
-#else
-#define NonTEGlyphFunc EXPNAME(XAANonTEGlyphScanlineFunc)
-#endif
-
-/********************************************************************
-
-   Here we have NonTEGlyphRenders for a bunch of different color
-   expansion types.  The driver may provide its own renderer, but
-   this is the default one which renders using lower-level primitives
-   exported by the chipset driver.
-
-********************************************************************/
-
-/* Since the dimensions of the text string and the backing rectangle
-	do not always coincide, it is possible that wBack or wText
-	may be 0!  The NonTEGlyphRender must always check for this. */
-
-/* This gets built for MSBFIRST or LSBFIRST with FIXEDBASE or not,
-	with TRIPLE_BITS or not. A total of 8 versions */
-
-/* if the backing rectangle and text are of the same dimensions
-	then we can draw in one pass */
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAANonTEGlyphRenderer3) (
-#else
- EXPNAME(XAANonTEGlyphRenderer) (
-#endif
-                                    ScrnInfoPtr pScrn,
-                                    int xText, int wText,
-                                    int y, int h, int skipleft, int startline,
-                                    NonTEGlyphInfo * glyphp,
-                                    int fg, int rop, unsigned int planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base = (CARD32 *) infoRec->ColorExpandBase;
-
-#ifdef TRIPLE_BITS
-    int dwords = ((3 * wText + 31) >> 5) * h;
-#else
-    int dwords = ((wText + 31) >> 5) * h;
-#endif
-
-    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, -1, rop,
-                                                    planemask);
-    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, xText, y, wText, h,
-                                                      0);
-
-#ifndef FIXEDBASE
-#ifdef TRIPLE_BITS
-    if ((((3 * wText + 31) >> 5) * h) <= infoRec->ColorExpandRange)
-#else
-    if ((((wText + 31) >> 5) * h) <= infoRec->ColorExpandRange)
-#endif
-        while (h--)
-            base = NonTEGlyphFunc(base, glyphp, startline++, wText, skipleft);
-    else
-#endif
-        while (h--)
-            NonTEGlyphFunc(base, glyphp, startline++, wText, skipleft);
-
-    if ((infoRec->CPUToScreenColorExpandFillFlags & CPU_TRANSFER_PAD_QWORD) &&
-        (dwords & 1)) {
-        base = (CARD32 *) infoRec->ColorExpandBase;
-        base[0] = 0x00000000;
-    }
-
-    if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-#ifndef FIXEDBASE
-/*  Scanline version of above gets built for LSBFIRST and MSBFIRST */
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAANonTEGlyphRendererScanline3) (
-#else
- EXPNAME(XAANonTEGlyphRendererScanline) (
-#endif
-                                            ScrnInfoPtr pScrn,
-                                            int xText, int wText,
-                                            int y, int h, int skipleft,
-                                            int startline,
-                                            NonTEGlyphInfo * glyphp, int fg,
-                                            int rop, unsigned int planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int bufferNo = 0;
-    CARD32 *base;
-
-    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, -1, rop,
-                                                            planemask);
-    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, xText, y,
-                                                              wText, h, 0);
-
-    while (h--) {
-        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-        NonTEGlyphFunc(base, glyphp, startline++, wText, skipleft);
-        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-            bufferNo = 0;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-#endif
-
-/********************************************************************
-
-   Generic NonTE scanline rendering code.
-
-********************************************************************/
-
-CARD32 *
-NonTEGlyphFunc(CARD32 *base,
-               NonTEGlyphInfo * glyphp, int line, int TotalWidth, int skipleft)
-{
-    CARD32 bits = 0;
-    int shift = glyphp->width;
-
-    if (skipleft) {
-        if ((line >= glyphp->firstline) && (line <= glyphp->lastline))
-            bits = SHIFT_R(glyphp->bitsp[line], skipleft);
-        shift -= skipleft;
-    }
-    else if ((line >= glyphp->firstline) && (line <= glyphp->lastline))
-        bits = glyphp->bitsp[line];
-
-    while (TotalWidth > 32) {
-        while (shift < 32) {
-            glyphp++;
-            if ((line >= glyphp->firstline) && (line <= glyphp->lastline))
-                bits |= SHIFT_L(glyphp->bitsp[line], shift);
-            shift += glyphp->width;
-        }
-#ifdef TRIPLE_BITS
-        WRITE_BITS3(bits);
-#else
-        WRITE_BITS(bits);
-#endif
-        shift &= 31;
-        if (shift && (line >= glyphp->firstline) && (line <= glyphp->lastline))
-            bits = SHIFT_R(glyphp->bitsp[line], glyphp->width - shift);
-        else
-            bits = 0;
-        TotalWidth -= 32;
-    }
-
-    if (TotalWidth) {
-        TotalWidth -= shift;
-        while (TotalWidth > 0) {
-            glyphp++;
-            if ((line >= glyphp->firstline) && (line <= glyphp->lastline))
-                bits |= SHIFT_L(glyphp->bitsp[line], shift);
-            shift += glyphp->width;
-            TotalWidth -= glyphp->width;
-        }
-#ifdef TRIPLE_BITS
-        if (shift >= 22) {
-            WRITE_BITS3(bits);
-        }
-        else if (shift >= 11) {
-            WRITE_BITS2(bits);
-        }
-        else {
-            WRITE_BITS1(bits);
-        }
-#else
-        WRITE_BITS(bits);
-#endif
-    }
-
-    return base;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaNonTEText.c b/xorg-server/hw/xfree86/xaa/xaaNonTEText.c
deleted file mode 100644
index 35b43912b..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaNonTEText.c
+++ /dev/null
@@ -1,591 +0,0 @@
-
-/********************************************************************
-
-   In this file we have GC level replacements for PolyText8/16,
-   ImageText8/16, ImageGlyphBlt and PolyGlyphBlt for NonTE (proportional) 
-   fonts. The idea is that everything in this file is device independent.
-   The mentioned GCOps are merely wrappers for the 
-   PolyGlyphBltNonTEColorExpansion and ImageGlyphBltNonTEColorExpansion
-   functions which calculate the boxes containing arbitrarily clipped 
-   text and passes them to the NonTEGlyphRenderer which will usually 
-   be a lower level XAA function which renders these clipped glyphs using
-   the basic color expansion functions exported by the chipset driver.
-   The NonTEGlyphRenderer itself may optionally be driver supplied to
-   facilitate work-arounds/optimizations at a higher level than usual.
-
-   Written by Mark Vojkovich (mvojkovi@ucsd.edu)
-
-********************************************************************/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include <X11/fonts/font.h>
-#include "scrnintstr.h"
-#include "dixfontstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaacexp.h"
-#include "xaalocal.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-
-static void ImageGlyphBltNonTEColorExpansion(ScrnInfoPtr pScrn,
-                                             int xInit, int yInit, FontPtr font,
-                                             int fg, int bg, unsigned planemask,
-                                             RegionPtr cclip, int nglyph,
-                                             unsigned char *gBase,
-                                             CharInfoPtr * ppci);
-static int PolyGlyphBltNonTEColorExpansion(ScrnInfoPtr pScrn, int xInit,
-                                           int yInit, FontPtr font, int fg,
-                                           int rop, unsigned planemask,
-                                           RegionPtr cclip, int nglyph,
-                                           unsigned char *gBase,
-                                           CharInfoPtr * ppci);
-
-/********************************************************************
-
-   GC level replacements for PolyText8/16 and ImageText8/16
-   for NonTE fonts when using color expansion.
-
-********************************************************************/
-
-int
-XAAPolyText8NonTEColorExpansion(DrawablePtr pDraw,
-                                GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-    int width = 0;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars, Linear8Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n) {
-        width = PolyGlyphBltNonTEColorExpansion(infoRec->pScrn,
-                                                x + pDraw->x, y + pDraw->y,
-                                                pGC->font, pGC->fgPixel,
-                                                pGC->alu, pGC->planemask,
-                                                pGC->pCompositeClip, n,
-                                                FONTGLYPHS(pGC->font),
-                                                infoRec->CharInfo);
-    }
-
-    return x + width;
-}
-
-int
-XAAPolyText16NonTEColorExpansion(DrawablePtr pDraw,
-                                 GCPtr pGC,
-                                 int x, int y, int count, unsigned short *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-    int width = 0;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars,
-                              (FONTLASTROW(pGC->font) ==
-                               0) ? Linear16Bit : TwoD16Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n) {
-        width = PolyGlyphBltNonTEColorExpansion(infoRec->pScrn,
-                                                x + pDraw->x, y + pDraw->y,
-                                                pGC->font, pGC->fgPixel,
-                                                pGC->alu, pGC->planemask,
-                                                pGC->pCompositeClip, n,
-                                                FONTGLYPHS(pGC->font),
-                                                infoRec->CharInfo);
-    }
-
-    return x + width;
-}
-
-void
-XAAImageText8NonTEColorExpansion(DrawablePtr pDraw,
-                                 GCPtr pGC,
-                                 int x, int y, int count, char *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars, Linear8Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n)
-        ImageGlyphBltNonTEColorExpansion(infoRec->pScrn, x + pDraw->x,
-                                         y + pDraw->y, pGC->font, pGC->fgPixel,
-                                         pGC->bgPixel, pGC->planemask,
-                                         pGC->pCompositeClip, n,
-                                         FONTGLYPHS(pGC->font),
-                                         infoRec->CharInfo);
-}
-
-void
-XAAImageText16NonTEColorExpansion(DrawablePtr pDraw,
-                                  GCPtr pGC,
-                                  int x,
-                                  int y, int count, unsigned short *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars,
-                              (FONTLASTROW(pGC->font) ==
-                               0) ? Linear16Bit : TwoD16Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n)
-        ImageGlyphBltNonTEColorExpansion(infoRec->pScrn, x + pDraw->x,
-                                         y + pDraw->y, pGC->font, pGC->fgPixel,
-                                         pGC->bgPixel, pGC->planemask,
-                                         pGC->pCompositeClip, n,
-                                         FONTGLYPHS(pGC->font),
-                                         infoRec->CharInfo);
-}
-
-/********************************************************************
-
-   GC level replacements for ImageGlyphBlt and PolyGlyphBlt for
-   NonTE fonts when using color expansion.
-
-********************************************************************/
-
-void
-XAAImageGlyphBltNonTEColorExpansion(DrawablePtr pDraw, GCPtr pGC, int xInit, int yInit, unsigned int nglyph, CharInfoPtr * ppci,        /* array of character info */
-                                    pointer pglyphBase  /* start of array of glyphs */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    ImageGlyphBltNonTEColorExpansion(infoRec->pScrn, xInit + pDraw->x,
-                                     yInit + pDraw->y, pGC->font, pGC->fgPixel,
-                                     pGC->bgPixel, pGC->planemask,
-                                     pGC->pCompositeClip, nglyph,
-                                     (unsigned char *) pglyphBase, ppci);
-}
-
-void
-XAAPolyGlyphBltNonTEColorExpansion(DrawablePtr pDraw, GCPtr pGC, int xInit, int yInit, unsigned int nglyph, CharInfoPtr * ppci, /* array of character info */
-                                   pointer pglyphBase   /* start of array of glyphs */
-    )
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    PolyGlyphBltNonTEColorExpansion(infoRec->pScrn, xInit + pDraw->x,
-                                    yInit + pDraw->y, pGC->font, pGC->fgPixel,
-                                    pGC->alu, pGC->planemask,
-                                    pGC->pCompositeClip, nglyph,
-                                    (unsigned char *) pglyphBase, ppci);
-}
-
-/********************************************************************
-
-   ImageGlyphBltNonTEColorExpansion -
-   PolyGlyphBltNonTEColorExpansion -
-
-   These guys compute the clipped pieces of text and send it to
-   the lower-level function which will handle acceleration of 
-   arbitrarily clipped text.
-  
-********************************************************************/
-
-static int
-CollectCharacterInfo(NonTEGlyphPtr glyphs,
-                     unsigned int nglyph, CharInfoPtr * ppci, FontPtr pfont)
-{
-    int i, w = 0;
-
-    for (i = 0; i < nglyph; i++, ppci++, glyphs++) {
-        glyphs->bits = (unsigned char *) ((*ppci)->bits);
-        glyphs->start = w + (*ppci)->metrics.leftSideBearing;
-        glyphs->end = w + (*ppci)->metrics.rightSideBearing;
-        glyphs->yoff = (*ppci)->metrics.ascent;
-        glyphs->height = glyphs->yoff + (*ppci)->metrics.descent;
-        glyphs->srcwidth = PADGLYPHWIDTHBYTES(glyphs->end - glyphs->start);
-        w += (*ppci)->metrics.characterWidth;
-    }
-    return w;
-}
-
-static void
-PolyGlyphBltAsSingleBitmap(ScrnInfoPtr pScrn,
-                           int nglyph,
-                           FontPtr font,
-                           int xInit,
-                           int yInit,
-                           int nbox,
-                           BoxPtr pbox, int fg, int rop, unsigned planemask)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *block, *pntr, *bits;
-    int pitch, topLine, botLine, top, bot, height;
-    int Left, Right, Top, Bottom;
-    int LeftEdge, RightEdge;
-    int bitPitch, shift, size, i, skippix;
-    NonTEGlyphPtr glyphs = infoRec->GlyphInfo;
-    Bool extra;
-
-    Left = xInit + infoRec->GlyphInfo[0].start;
-    Right = xInit + infoRec->GlyphInfo[nglyph - 1].end;
-    Top = yInit - FONTMAXBOUNDS(font, ascent);
-    Bottom = yInit + FONTMAXBOUNDS(font, descent);
-
-    /* get into the first band that may contain part of our string */
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    if (!nbox)
-        return;
-
-    pitch = (Right - Left + 31) >> 5;
-    size = (pitch << 2) * (Bottom - Top);
-    block = calloc(1, size);
-
-    topLine = 10000;
-    botLine = -10000;
-
-    while (nglyph--) {
-        top = -glyphs->yoff;
-        bot = top + glyphs->height;
-        if (top < topLine)
-            topLine = top;
-        if (bot > botLine)
-            botLine = bot;
-        skippix = glyphs->start - infoRec->GlyphInfo[0].start;
-        bits = (CARD32 *) glyphs->bits;
-        bitPitch = glyphs->srcwidth >> 2;
-        pntr = block + ((FONTMAXBOUNDS(font, ascent) + top) * pitch) +
-            (skippix >> 5);
-        shift = skippix & 31;
-        extra = ((shift + glyphs->end - glyphs->start) > 32);
-
-        for (i = top; i < bot; i++) {
-            *pntr |= SHIFT_L(*bits, shift);
-            if (extra)
-                *(pntr + 1) |= SHIFT_R(*bits, 32 - shift);
-            pntr += pitch;
-            bits += bitPitch;
-        }
-
-        glyphs++;
-    }
-
-    pntr = block + ((FONTMAXBOUNDS(font, ascent) + topLine) * pitch);
-
-    Top = yInit + topLine;
-    Bottom = yInit + botLine;
-
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    while (nbox && (Bottom > pbox->y1)) {
-        LeftEdge = max(Left, pbox->x1);
-        RightEdge = min(Right, pbox->x2);
-
-        if (RightEdge > LeftEdge) {
-            skippix = LeftEdge - Left;
-            topLine = max(Top, pbox->y1);
-            botLine = min(Bottom, pbox->y2);
-            height = botLine - topLine;
-
-            if (height > 0)
-                (*infoRec->WriteBitmap) (pScrn, LeftEdge, topLine,
-                                         RightEdge - LeftEdge, height,
-                                         (unsigned char *) (pntr +
-                                                            ((topLine -
-                                                              Top) * pitch) +
-                                                            (skippix >> 5)),
-                                         pitch << 2, skippix & 31, fg, -1, rop,
-                                         planemask);
-        }
-
-        nbox--;
-        pbox++;
-    }
-
-    free(block);
-}
-
-static void
-ImageGlyphBltNonTEColorExpansion(ScrnInfoPtr pScrn,
-                                 int xInit, int yInit,
-                                 FontPtr font,
-                                 int fg, int bg,
-                                 unsigned planemask,
-                                 RegionPtr cclip,
-                                 int nglyph,
-                                 unsigned char *gBase, CharInfoPtr * ppci)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int skippix, skipglyph, width, n, i;
-    int Left, Right, Top, Bottom;
-    int LeftEdge, RightEdge, ytop, ybot;
-    int nbox = RegionNumRects(cclip);
-    BoxPtr pbox = RegionRects(cclip);
-    Bool AlreadySetup = FALSE;
-
-    width = CollectCharacterInfo(infoRec->GlyphInfo, nglyph, ppci, font);
-
-    /* find our backing rectangle dimensions */
-    Left = xInit;
-    Right = Left + width;
-    Top = yInit - FONTASCENT(font);
-    Bottom = yInit + FONTDESCENT(font);
-
-    /* get into the first band that may contain part of our box */
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    while (nbox && (Bottom >= pbox->y1)) {
-        /* handle backing rect first */
-        LeftEdge = max(Left, pbox->x1);
-        RightEdge = min(Right, pbox->x2);
-        if (RightEdge > LeftEdge) {
-            ytop = max(Top, pbox->y1);
-            ybot = min(Bottom, pbox->y2);
-
-            if (ybot > ytop) {
-                if (!AlreadySetup) {
-                    (*infoRec->SetupForSolidFill) (pScrn, bg, GXcopy,
-                                                   planemask);
-                    AlreadySetup = TRUE;
-                }
-                (*infoRec->SubsequentSolidFillRect) (pScrn,
-                                                     LeftEdge, ytop,
-                                                     RightEdge - LeftEdge,
-                                                     ybot - ytop);
-            }
-        }
-        nbox--;
-        pbox++;
-    }
-
-    nbox = RegionNumRects(cclip);
-    pbox = RegionRects(cclip);
-
-    if (infoRec->WriteBitmap && (nglyph > 1) &&
-        ((FONTMAXBOUNDS(font, rightSideBearing) -
-          FONTMINBOUNDS(font, leftSideBearing)) <= 32)) {
-        PolyGlyphBltAsSingleBitmap(pScrn, nglyph, font,
-                                   xInit, yInit, nbox, pbox,
-                                   fg, GXcopy, planemask);
-
-        return;
-    }
-
-    /* compute an approximate but covering bounding box */
-    Left = xInit + infoRec->GlyphInfo[0].start;
-    Right = xInit + infoRec->GlyphInfo[nglyph - 1].end;
-    Top = yInit - FONTMAXBOUNDS(font, ascent);
-    Bottom = yInit + FONTMAXBOUNDS(font, descent);
-
-    /* get into the first band that may contain part of our box */
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    /* stop when the lower edge of the box is beyond our string */
-    while (nbox && (Bottom >= pbox->y1)) {
-        LeftEdge = max(Left, pbox->x1);
-        RightEdge = min(Right, pbox->x2);
-
-        if (RightEdge > LeftEdge) {     /* we're possibly drawing something */
-            ytop = max(Top, pbox->y1);
-            ybot = min(Bottom, pbox->y2);
-            if (ybot > ytop) {
-                skippix = LeftEdge - xInit;
-                skipglyph = 0;
-                while (skippix >= infoRec->GlyphInfo[skipglyph].end)
-                    skipglyph++;
-
-                skippix = RightEdge - xInit;
-                n = 0;
-                i = skipglyph;
-                while ((i < nglyph) && (skippix > infoRec->GlyphInfo[i].start)) {
-                    i++;
-                    n++;
-                }
-
-                if (n)
-                    (*infoRec->NonTEGlyphRenderer) (pScrn,
-                                                    xInit, yInit, n,
-                                                    infoRec->GlyphInfo +
-                                                    skipglyph, pbox, fg, GXcopy,
-                                                    planemask);
-            }
-        }
-
-        nbox--;
-        pbox++;
-    }
-}
-
-static int
-PolyGlyphBltNonTEColorExpansion(ScrnInfoPtr pScrn,
-                                int xInit, int yInit,
-                                FontPtr font,
-                                int fg, int rop,
-                                unsigned planemask,
-                                RegionPtr cclip,
-                                int nglyph,
-                                unsigned char *gBase, CharInfoPtr * ppci)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int skippix, skipglyph, width, n, i;
-    int Left, Right, Top, Bottom;
-    int LeftEdge, RightEdge;
-    int nbox = RegionNumRects(cclip);
-    BoxPtr pbox = RegionRects(cclip);
-
-    width = CollectCharacterInfo(infoRec->GlyphInfo, nglyph, ppci, font);
-
-    if (!nbox)
-        return width;
-
-    if ((infoRec->WriteBitmap) && (rop == GXcopy) && (nglyph > 1) &&
-        ((FONTMAXBOUNDS(font, rightSideBearing) -
-          FONTMINBOUNDS(font, leftSideBearing)) <= 32)) {
-
-        PolyGlyphBltAsSingleBitmap(pScrn, nglyph, font,
-                                   xInit, yInit, nbox, pbox,
-                                   fg, rop, planemask);
-
-        return width;
-    }
-
-    /* compute an approximate but covering bounding box */
-    Left = xInit + infoRec->GlyphInfo[0].start;
-    Right = xInit + infoRec->GlyphInfo[nglyph - 1].end;
-    Top = yInit - FONTMAXBOUNDS(font, ascent);
-    Bottom = yInit + FONTMAXBOUNDS(font, descent);
-
-    /* get into the first band that may contain part of our string */
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    /* stop when the lower edge of the box is beyond our string */
-    while (nbox && (Bottom >= pbox->y1)) {
-        LeftEdge = max(Left, pbox->x1);
-        RightEdge = min(Right, pbox->x2);
-
-        if (RightEdge > LeftEdge) {     /* we're possibly drawing something */
-
-            skippix = LeftEdge - xInit;
-            skipglyph = 0;
-            while (skippix >= infoRec->GlyphInfo[skipglyph].end)
-                skipglyph++;
-
-            skippix = RightEdge - xInit;
-            n = 0;
-            i = skipglyph;
-            while ((i < nglyph) && (skippix > infoRec->GlyphInfo[i].start)) {
-                i++;
-                n++;
-            }
-
-            if (n)
-                (*infoRec->NonTEGlyphRenderer) (pScrn,
-                                                xInit, yInit, n,
-                                                infoRec->GlyphInfo + skipglyph,
-                                                pbox, fg, rop, planemask);
-        }
-
-        nbox--;
-        pbox++;
-    }
-    return width;
-}
-
-/* It is possible that the none of the glyphs passed to the 
-   NonTEGlyphRenderer will be drawn.  This function being called
-   indicates that part of the text string's bounding box is visible
-   but not necessarily that any of the characters are visible */
-
-void
-XAANonTEGlyphRenderer(ScrnInfoPtr pScrn,
-                      int x, int y, int n,
-                      NonTEGlyphPtr glyphs,
-                      BoxPtr pbox, int fg, int rop, unsigned int planemask)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x1, x2, y1, y2, i, w, h, skipleft, skiptop;
-    unsigned char *src;
-
-    for (i = 0; i < n; i++, glyphs++) {
-        x1 = x + glyphs->start;
-        x2 = x + glyphs->end;
-        y1 = y - glyphs->yoff;
-        y2 = y1 + glyphs->height;
-
-        if (y1 < pbox->y1) {
-            skiptop = pbox->y1 - y1;
-            y1 = pbox->y1;
-        }
-        else
-            skiptop = 0;
-        if (y2 > pbox->y2)
-            y2 = pbox->y2;
-        h = y2 - y1;
-        if (h <= 0)
-            continue;
-
-        if (x1 < pbox->x1) {
-            skipleft = pbox->x1 - x1;
-            x1 = pbox->x1;
-        }
-        else
-            skipleft = 0;
-        if (x2 > pbox->x2)
-            x2 = pbox->x2;
-
-        w = x2 - x1;
-
-        if (w > 0) {
-            src = glyphs->bits + (skiptop * glyphs->srcwidth);
-
-            if (skipleft) {
-                src += (skipleft >> 5) << 2;
-                skipleft &= 31;
-            }
-
-            (*infoRec->WriteBitmap) (pScrn, x1, y1, w, h, src,
-                                     glyphs->srcwidth, skipleft, fg, -1, rop,
-                                     planemask);
-        }
-    }
-
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaOffscreen.c b/xorg-server/hw/xfree86/xaa/xaaOffscreen.c
deleted file mode 100644
index 7d89fc17a..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaOffscreen.c
+++ /dev/null
@@ -1,163 +0,0 @@
-
-/*
-   Copyright (c) 1999 -  The XFree86 Project Inc.
-
-   Written by Mark Vojkovich
-
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "miline.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "xf86fbman.h"
-#include "servermd.h"
-
-void
-XAAMoveOutOffscreenPixmaps(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    PixmapLinkPtr pLink = infoRec->OffscreenPixmaps;
-    XAAPixmapPtr pPriv;
-
-    while (pLink) {
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pLink->pPix);
-        pLink->area = pPriv->offscreenArea;
-        XAAMoveOutOffscreenPixmap(pLink->pPix);
-        pLink = pLink->next;
-    }
-}
-
-void
-XAAMoveInOffscreenPixmaps(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    PixmapLinkPtr pLink = infoRec->OffscreenPixmaps;
-    PixmapPtr pPix, pScreenPix, tmpPix;
-    pointer data;
-    XAAPixmapPtr pPriv;
-    GCPtr pGC;
-    FBAreaPtr area;
-
-    pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
-
-    while (pLink) {
-        pPix = pLink->pPix;
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-        area = pLink->area;
-
-        data = pPix->devPrivate.ptr;
-        tmpPix = GetScratchPixmapHeader(pScreen,
-                                        pPix->drawable.width,
-                                        pPix->drawable.height,
-                                        pPix->drawable.depth,
-                                        pPix->drawable.bitsPerPixel,
-                                        pPix->devKind, data);
-
-        pPriv->freeData = FALSE;
-
-        pPix->drawable.x = area->box.x1;
-        pPix->drawable.y = area->box.y1;
-        pPix->devKind = pScreenPix->devKind;
-        pPix->devPrivate.ptr = pScreenPix->devPrivate.ptr;
-        pPix->drawable.bitsPerPixel = infoRec->pScrn->bitsPerPixel;
-        pPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-
-        if (!tmpPix) {
-            pPriv->offscreenArea = area;
-            free(data);
-            pLink = pLink->next;
-            continue;
-        }
-
-        pGC = GetScratchGC(pPix->drawable.depth, pScreen);
-        ValidateGC((DrawablePtr) pPix, pGC);
-
-        (*pGC->ops->CopyArea) ((DrawablePtr) tmpPix, (DrawablePtr) pPix, pGC,
-                               0, 0, pPix->drawable.width,
-                               pPix->drawable.height, 0, 0);
-
-        free(data);
-        tmpPix->devPrivate.ptr = NULL;
-
-        FreeScratchGC(pGC);
-        FreeScratchPixmapHeader(tmpPix);
-
-        pPriv->offscreenArea = area;
-        pLink->area = NULL;
-        pLink = pLink->next;
-    }
-}
-
-void
-XAARemoveAreaCallback(FBAreaPtr area)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(area->pScreen);
-    PixmapPtr pPix = (PixmapPtr) area->devPrivate.ptr;
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-
-    XAAMoveOutOffscreenPixmap(pPix);
-
-    pPriv->flags &= ~OFFSCREEN;
-
-    DELIST_OFFSCREEN_PIXMAP(pPix);
-}
-
-void
-XAAMoveOutOffscreenPixmap(PixmapPtr pPix)
-{
-    ScreenPtr pScreen = pPix->drawable.pScreen;
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-    int width, height, devKind, bitsPerPixel;
-    PixmapPtr tmpPix;
-    unsigned char *data;
-    GCPtr pGC;
-
-    width = pPix->drawable.width;
-    height = pPix->drawable.height;
-    bitsPerPixel = pPix->drawable.bitsPerPixel;
-
-    devKind = BitmapBytePad(width * bitsPerPixel);
-    if (!(data = malloc(devKind * height)))
-        FatalError("Out of memory\n");
-
-    tmpPix = GetScratchPixmapHeader(pScreen, width, height,
-                                    pPix->drawable.depth, bitsPerPixel, devKind,
-                                    data);
-    if (!tmpPix) {
-        free(data);
-        FatalError("Out of memory\n");
-    }
-
-    pGC = GetScratchGC(pPix->drawable.depth, pScreen);
-    ValidateGC((DrawablePtr) tmpPix, pGC);
-
-    (*pGC->ops->CopyArea) ((DrawablePtr) pPix, (DrawablePtr) tmpPix,
-                           pGC, 0, 0, width, height, 0, 0);
-
-    FreeScratchGC(pGC);
-    FreeScratchPixmapHeader(tmpPix);
-
-    pPix->drawable.x = 0;
-    pPix->drawable.y = 0;
-    pPix->devKind = devKind;
-    pPix->devPrivate.ptr = data;
-    pPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-
-    pPriv->offscreenArea = NULL;
-    pPriv->freeData = TRUE;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaOverlay.c b/xorg-server/hw/xfree86/xaa/xaaOverlay.c
deleted file mode 100644
index 25d18da96..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaOverlay.c
+++ /dev/null
@@ -1,122 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-#include "mioverlay.h"
-
-#ifdef PANORAMIX
-#include "panoramiX.h"
-#include "panoramiXsrv.h"
-#endif
-
-static void
-XAACopyWindow8_32(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
-    DDXPointPtr pptSrc, ppt;
-    RegionRec rgnDst;
-    BoxPtr pbox;
-    int dx, dy, nbox;
-    WindowPtr pwinRoot;
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
-    Bool doUnderlay = miOverlayCopyUnderlay(pScreen);
-    RegionPtr borderClip = &pWin->borderClip;
-    Bool freeReg = FALSE;
-
-    if (!infoRec->pScrn->vtSema || !infoRec->ScreenToScreenBitBlt ||
-        (infoRec->ScreenToScreenBitBltFlags & NO_PLANEMASK)) {
-        XAA_SCREEN_PROLOGUE(pScreen, CopyWindow);
-        if (infoRec->pScrn->vtSema && infoRec->NeedToSync) {
-            (*infoRec->Sync) (infoRec->pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-        (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
-        XAA_SCREEN_EPILOGUE(pScreen, CopyWindow, XAACopyWindow8_32);
-        return;
-    }
-
-    pwinRoot = pScreen->root;
-
-    if (doUnderlay)
-        freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);
-
-    RegionNull(&rgnDst);
-
-    dx = ptOldOrg.x - pWin->drawable.x;
-    dy = ptOldOrg.y - pWin->drawable.y;
-    RegionTranslate(prgnSrc, -dx, -dy);
-    RegionIntersect(&rgnDst, borderClip, prgnSrc);
-
-    pbox = RegionRects(&rgnDst);
-    nbox = RegionNumRects(&rgnDst);
-    if (!nbox || !(pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec)))) {
-        RegionUninit(&rgnDst);
-        return;
-    }
-    ppt = pptSrc;
-
-    while (nbox--) {
-        ppt->x = pbox->x1 + dx;
-        ppt->y = pbox->y1 + dy;
-        ppt++;
-        pbox++;
-    }
-
-    infoRec->ScratchGC.planemask = doUnderlay ? 0x00ffffff : 0xff000000;
-    infoRec->ScratchGC.alu = GXcopy;
-
-    XAADoBitBlt((DrawablePtr) pwinRoot, (DrawablePtr) pwinRoot,
-                &(infoRec->ScratchGC), &rgnDst, pptSrc);
-
-    free(pptSrc);
-    RegionUninit(&rgnDst);
-    if (freeReg)
-        RegionDestroy(borderClip);
-}
-
-static void
-XAASetColorKey8_32(ScreenPtr pScreen, int nbox, BoxPtr pbox)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = infoRec->pScrn;
-
-    /* I'm counting on writes being clipped away while switched away.
-       If this isn't going to be true then I need to be wrapping instead. */
-    if (!infoRec->pScrn->vtSema)
-        return;
-
-    (*infoRec->FillSolidRects) (pScrn, pScrn->colorKey << 24, GXcopy,
-                                0xff000000, nbox, pbox);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAASetupOverlay8_32Planar(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    int i;
-
-    pScreen->CopyWindow = XAACopyWindow8_32;
-
-    if (!(infoRec->FillSolidRectsFlags & NO_PLANEMASK))
-        miOverlaySetTransFunction(pScreen, XAASetColorKey8_32);
-
-    infoRec->FullPlanemask = ~0;
-    for (i = 0; i < 32; i++)    /* haven't thought about this much */
-        infoRec->FullPlanemasks[i] = ~0;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c b/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c
deleted file mode 100644
index 470694cbd..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaOverlayDF.c
+++ /dev/null
@@ -1,906 +0,0 @@
-/*
-   Copyright (c) 1999 - The XFree86 Project Inc.
-
-   Written by Mark Vojkovich
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "miline.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "servermd.h"
-
-/* Screen funcs */
-
-static void XAAOverCopyWindow(WindowPtr, DDXPointRec, RegionPtr);
-static void XAAOverWindowExposures(WindowPtr, RegionPtr, RegionPtr);
-
-static int XAAOverStippledFillChooser(GCPtr);
-static int XAAOverOpaqueStippledFillChooser(GCPtr);
-static int XAAOverTiledFillChooser(GCPtr);
-
-/* GC funcs */
-
-static RegionPtr XAAOverCopyArea(DrawablePtr, DrawablePtr, GC *,
-                                 int, int, int, int, int, int);
-static RegionPtr XAAOverCopyPlane(DrawablePtr, DrawablePtr, GCPtr,
-                                  int, int, int, int, int, int, unsigned long);
-static void XAAOverPushPixelsSolid(GCPtr, PixmapPtr, DrawablePtr, int,
-                                   int, int, int);
-static void XAAOverPolyFillRectSolid(DrawablePtr, GCPtr, int, xRectangle *);
-static void XAAOverPolyFillRectStippled(DrawablePtr, GCPtr, int, xRectangle *);
-static void XAAOverPolyFillRectOpaqueStippled(DrawablePtr, GCPtr,
-                                              int, xRectangle *);
-static void XAAOverPolyFillRectTiled(DrawablePtr, GCPtr, int, xRectangle *);
-static void XAAOverFillSpansSolid(DrawablePtr, GCPtr, int, DDXPointPtr,
-                                  int *, int);
-static void XAAOverFillSpansStippled(DrawablePtr, GCPtr, int, DDXPointPtr,
-                                     int *, int);
-static void XAAOverFillSpansOpaqueStippled(DrawablePtr, GCPtr, int,
-                                           DDXPointPtr, int *, int);
-static void XAAOverFillSpansTiled(DrawablePtr, GCPtr, int, DDXPointPtr,
-                                  int *, int);
-static int XAAOverPolyText8TE(DrawablePtr, GCPtr, int, int, int, char *);
-static int XAAOverPolyText16TE(DrawablePtr, GCPtr, int, int, int,
-                               unsigned short *);
-static void XAAOverImageText8TE(DrawablePtr, GCPtr, int, int, int, char *);
-static void XAAOverImageText16TE(DrawablePtr, GCPtr, int, int, int,
-                                 unsigned short *);
-static void XAAOverImageGlyphBltTE(DrawablePtr, GCPtr, int, int,
-                                   unsigned int, CharInfoPtr *, pointer);
-static void XAAOverPolyGlyphBltTE(DrawablePtr, GCPtr, int, int,
-                                  unsigned int, CharInfoPtr *, pointer);
-static int XAAOverPolyText8NonTE(DrawablePtr, GCPtr, int, int, int, char *);
-static int XAAOverPolyText16NonTE(DrawablePtr, GCPtr, int, int, int,
-                                  unsigned short *);
-static void XAAOverImageText8NonTE(DrawablePtr, GCPtr, int, int, int, char *);
-static void XAAOverImageText16NonTE(DrawablePtr, GCPtr, int, int, int,
-                                    unsigned short *);
-static void XAAOverImageGlyphBltNonTE(DrawablePtr, GCPtr, int, int,
-                                      unsigned int, CharInfoPtr *, pointer);
-static void XAAOverPolyGlyphBltNonTE(DrawablePtr, GCPtr, int, int,
-                                     unsigned int, CharInfoPtr *, pointer);
-static void XAAOverPolyRectangleThinSolid(DrawablePtr, GCPtr, int,
-                                          xRectangle *);
-static void XAAOverPolylinesWideSolid(DrawablePtr, GCPtr, int, int,
-                                      DDXPointPtr);
-static void XAAOverPolylinesThinSolid(DrawablePtr, GCPtr, int, int,
-                                      DDXPointPtr);
-static void XAAOverPolySegmentThinSolid(DrawablePtr, GCPtr, int, xSegment *);
-static void XAAOverPolylinesThinDashed(DrawablePtr, GCPtr, int, int,
-                                       DDXPointPtr);
-static void XAAOverPolySegmentThinDashed(DrawablePtr, GCPtr, int, xSegment *);
-static void XAAOverFillPolygonSolid(DrawablePtr, GCPtr, int, int, int,
-                                    DDXPointPtr);
-static void XAAOverFillPolygonStippled(DrawablePtr, GCPtr, int, int, int,
-                                       DDXPointPtr);
-static void XAAOverFillPolygonOpaqueStippled(DrawablePtr, GCPtr, int, int, int,
-                                             DDXPointPtr);
-static void XAAOverFillPolygonTiled(DrawablePtr, GCPtr, int, int, int,
-                                    DDXPointPtr);
-static void XAAOverPolyFillArcSolid(DrawablePtr, GCPtr, int, xArc *);
-static void XAAOverPutImage(DrawablePtr, GCPtr, int, int, int, int, int,
-                            int, int, char *);
-
-typedef struct {
-    ScrnInfoPtr pScrn;
-    DepthChangeFuncPtr callback;
-    int currentDepth;
-/* GC funcs */
-    RegionPtr (*CopyArea) (DrawablePtr, DrawablePtr, GC *,
-                           int, int, int, int, int, int);
-    RegionPtr (*CopyPlane) (DrawablePtr, DrawablePtr, GCPtr,
-                            int, int, int, int, int, int, unsigned long);
-    void (*PushPixelsSolid) (GCPtr, PixmapPtr, DrawablePtr, int, int, int, int);
-    void (*PolyFillRectSolid) (DrawablePtr, GCPtr, int, xRectangle *);
-    void (*PolyFillRectStippled) (DrawablePtr, GCPtr, int, xRectangle *);
-    void (*PolyFillRectOpaqueStippled) (DrawablePtr, GCPtr, int, xRectangle *);
-    void (*PolyFillRectTiled) (DrawablePtr, GCPtr, int, xRectangle *);
-    void (*FillSpansSolid) (DrawablePtr, GCPtr, int, DDXPointPtr, int *, int);
-    void (*FillSpansStippled) (DrawablePtr, GCPtr, int, DDXPointPtr, int *,
-                               int);
-    void (*FillSpansOpaqueStippled) (DrawablePtr, GCPtr, int, DDXPointPtr,
-                                     int *, int);
-    void (*FillSpansTiled) (DrawablePtr, GCPtr, int, DDXPointPtr, int *, int);
-    int (*PolyText8TE) (DrawablePtr, GCPtr, int, int, int, char *);
-    int (*PolyText16TE) (DrawablePtr, GCPtr, int, int, int, unsigned short *);
-    void (*ImageText8TE) (DrawablePtr, GCPtr, int, int, int, char *);
-    void (*ImageText16TE) (DrawablePtr, GCPtr, int, int, int, unsigned short *);
-    void (*ImageGlyphBltTE) (DrawablePtr, GCPtr, int, int, unsigned int,
-                             CharInfoPtr *, pointer);
-    void (*PolyGlyphBltTE) (DrawablePtr, GCPtr, int, int, unsigned int,
-                            CharInfoPtr *, pointer);
-    int (*PolyText8NonTE) (DrawablePtr, GCPtr, int, int, int, char *);
-    int (*PolyText16NonTE) (DrawablePtr, GCPtr, int, int, int,
-                            unsigned short *);
-    void (*ImageText8NonTE) (DrawablePtr, GCPtr, int, int, int, char *);
-    void (*ImageText16NonTE) (DrawablePtr, GCPtr, int, int, int,
-                              unsigned short *);
-    void (*ImageGlyphBltNonTE) (DrawablePtr, GCPtr, int, int, unsigned int,
-                                CharInfoPtr *, pointer);
-    void (*PolyGlyphBltNonTE) (DrawablePtr, GCPtr, int, int, unsigned int,
-                               CharInfoPtr *, pointer);
-    void (*PolyRectangleThinSolid) (DrawablePtr, GCPtr, int, xRectangle *);
-    void (*PolylinesWideSolid) (DrawablePtr, GCPtr, int, int, DDXPointPtr);
-
-    void (*PolylinesThinSolid) (DrawablePtr, GCPtr, int, int, DDXPointPtr);
-    void (*PolySegmentThinSolid) (DrawablePtr, GCPtr, int, xSegment *);
-    void (*PolylinesThinDashed) (DrawablePtr, GCPtr, int, int, DDXPointPtr);
-    void (*PolySegmentThinDashed) (DrawablePtr, GCPtr, int, xSegment *);
-    void (*FillPolygonSolid) (DrawablePtr, GCPtr, int, int, int, DDXPointPtr);
-    void (*FillPolygonStippled) (DrawablePtr, GCPtr, int, int, int,
-                                 DDXPointPtr);
-    void (*FillPolygonOpaqueStippled) (DrawablePtr, GCPtr, int, int, int,
-                                       DDXPointPtr);
-    void (*FillPolygonTiled) (DrawablePtr, GCPtr, int, int, int, DDXPointPtr);
-    void (*PolyFillArcSolid) (DrawablePtr, GCPtr, int, xArc *);
-    void (*PutImage) (DrawablePtr, GCPtr, int, int, int, int, int, int,
-                      int, char *);
-    int (*StippledFillChooser) (GCPtr);
-    int (*OpaqueStippledFillChooser) (GCPtr);
-    int (*TiledFillChooser) (GCPtr);
-} XAAOverlayRec, *XAAOverlayPtr;
-
-static DevPrivateKeyRec XAAOverlayKeyRec;
-
-#define XAAOverlayKey (&XAAOverlayKeyRec)
-
-#define GET_OVERLAY_PRIV(pScreen) \
-    (XAAOverlayPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAOverlayKey)
-
-#define SWITCH_DEPTH(d) \
-   if(pOverPriv->currentDepth != d) { \
-	(*pOverPriv->callback)(pOverPriv->pScrn, d); \
-	pOverPriv->currentDepth = d; \
-   }
-
-Bool
-XAAInitDualFramebufferOverlay(ScreenPtr pScreen, DepthChangeFuncPtr callback)
-{
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAOverlayPtr pOverPriv;
-
-    if (!dixRegisterPrivateKey(&XAAOverlayKeyRec, PRIVATE_SCREEN, 0))
-        return FALSE;
-
-    if (!(pOverPriv = malloc(sizeof(XAAOverlayRec))))
-        return FALSE;
-
-    dixSetPrivate(&pScreen->devPrivates, XAAOverlayKey, pOverPriv);
-
-    pOverPriv->pScrn = pScrn;
-    pOverPriv->callback = callback;
-    pOverPriv->currentDepth = -1;
-
-    /* Overwrite key screen functions.  The XAA core will clean up */
-
-    pScreen->CopyWindow = XAAOverCopyWindow;
-    pScreen->WindowExposures = XAAOverWindowExposures;
-
-    pOverPriv->StippledFillChooser = infoRec->StippledFillChooser;
-    pOverPriv->OpaqueStippledFillChooser = infoRec->OpaqueStippledFillChooser;
-    pOverPriv->TiledFillChooser = infoRec->TiledFillChooser;
-
-    infoRec->StippledFillChooser = XAAOverStippledFillChooser;
-    infoRec->OpaqueStippledFillChooser = XAAOverOpaqueStippledFillChooser;
-    infoRec->TiledFillChooser = XAAOverTiledFillChooser;
-
-    /* wrap all XAA GC rendering */
-
-    pOverPriv->CopyArea = infoRec->CopyArea;
-    pOverPriv->CopyPlane = infoRec->CopyPlane;
-    pOverPriv->PushPixelsSolid = infoRec->PushPixelsSolid;
-    pOverPriv->PolyFillRectSolid = infoRec->PolyFillRectSolid;
-    pOverPriv->PolyFillRectStippled = infoRec->PolyFillRectStippled;
-    pOverPriv->PolyFillRectOpaqueStippled = infoRec->PolyFillRectOpaqueStippled;
-    pOverPriv->PolyFillRectTiled = infoRec->PolyFillRectTiled;
-    pOverPriv->FillSpansSolid = infoRec->FillSpansSolid;
-    pOverPriv->FillSpansStippled = infoRec->FillSpansStippled;
-    pOverPriv->FillSpansOpaqueStippled = infoRec->FillSpansOpaqueStippled;
-    pOverPriv->FillSpansTiled = infoRec->FillSpansTiled;
-    pOverPriv->PolyText8TE = infoRec->PolyText8TE;
-    pOverPriv->PolyText16TE = infoRec->PolyText16TE;
-    pOverPriv->ImageText8TE = infoRec->ImageText8TE;
-    pOverPriv->ImageText16TE = infoRec->ImageText16TE;
-    pOverPriv->ImageGlyphBltTE = infoRec->ImageGlyphBltTE;
-    pOverPriv->PolyGlyphBltTE = infoRec->PolyGlyphBltTE;
-    pOverPriv->PolyText8NonTE = infoRec->PolyText8NonTE;
-    pOverPriv->PolyText16NonTE = infoRec->PolyText16NonTE;
-    pOverPriv->ImageText8NonTE = infoRec->ImageText8NonTE;
-    pOverPriv->ImageText16NonTE = infoRec->ImageText16NonTE;
-    pOverPriv->ImageGlyphBltNonTE = infoRec->ImageGlyphBltNonTE;
-    pOverPriv->PolyGlyphBltNonTE = infoRec->PolyGlyphBltNonTE;
-    pOverPriv->PolyRectangleThinSolid = infoRec->PolyRectangleThinSolid;
-    pOverPriv->PolylinesWideSolid = infoRec->PolylinesWideSolid;
-    pOverPriv->PolylinesThinSolid = infoRec->PolylinesThinSolid;
-    pOverPriv->PolySegmentThinSolid = infoRec->PolySegmentThinSolid;
-    pOverPriv->PolylinesThinDashed = infoRec->PolylinesThinDashed;
-    pOverPriv->PolySegmentThinDashed = infoRec->PolySegmentThinDashed;
-    pOverPriv->FillPolygonSolid = infoRec->FillPolygonSolid;
-    pOverPriv->FillPolygonStippled = infoRec->FillPolygonStippled;
-    pOverPriv->FillPolygonOpaqueStippled = infoRec->FillPolygonOpaqueStippled;
-    pOverPriv->FillPolygonTiled = infoRec->FillPolygonTiled;
-    pOverPriv->PolyFillArcSolid = infoRec->PolyFillArcSolid;
-    pOverPriv->PutImage = infoRec->PutImage;
-
-    if (infoRec->CopyArea)
-        infoRec->CopyArea = XAAOverCopyArea;
-    if (infoRec->CopyPlane)
-        infoRec->CopyPlane = XAAOverCopyPlane;
-    if (infoRec->PushPixelsSolid)
-        infoRec->PushPixelsSolid = XAAOverPushPixelsSolid;
-    if (infoRec->PolyFillRectSolid)
-        infoRec->PolyFillRectSolid = XAAOverPolyFillRectSolid;
-    if (infoRec->PolyFillRectStippled)
-        infoRec->PolyFillRectStippled = XAAOverPolyFillRectStippled;
-    if (infoRec->PolyFillRectOpaqueStippled)
-        infoRec->PolyFillRectOpaqueStippled = XAAOverPolyFillRectOpaqueStippled;
-    if (infoRec->PolyFillRectTiled)
-        infoRec->PolyFillRectTiled = XAAOverPolyFillRectTiled;
-    if (infoRec->FillSpansSolid)
-        infoRec->FillSpansSolid = XAAOverFillSpansSolid;
-    if (infoRec->FillSpansStippled)
-        infoRec->FillSpansStippled = XAAOverFillSpansStippled;
-    if (infoRec->FillSpansOpaqueStippled)
-        infoRec->FillSpansOpaqueStippled = XAAOverFillSpansOpaqueStippled;
-    if (infoRec->FillSpansTiled)
-        infoRec->FillSpansTiled = XAAOverFillSpansTiled;
-    if (infoRec->PolyText8TE)
-        infoRec->PolyText8TE = XAAOverPolyText8TE;
-    if (infoRec->PolyText16TE)
-        infoRec->PolyText16TE = XAAOverPolyText16TE;
-    if (infoRec->ImageText8TE)
-        infoRec->ImageText8TE = XAAOverImageText8TE;
-    if (infoRec->ImageText16TE)
-        infoRec->ImageText16TE = XAAOverImageText16TE;
-    if (infoRec->ImageGlyphBltTE)
-        infoRec->ImageGlyphBltTE = XAAOverImageGlyphBltTE;
-    if (infoRec->PolyGlyphBltTE)
-        infoRec->PolyGlyphBltTE = XAAOverPolyGlyphBltTE;
-    if (infoRec->PolyText8NonTE)
-        infoRec->PolyText8NonTE = XAAOverPolyText8NonTE;
-    if (infoRec->PolyText16NonTE)
-        infoRec->PolyText16NonTE = XAAOverPolyText16NonTE;
-    if (infoRec->ImageText8NonTE)
-        infoRec->ImageText8NonTE = XAAOverImageText8NonTE;
-    if (infoRec->ImageText16NonTE)
-        infoRec->ImageText16NonTE = XAAOverImageText16NonTE;
-    if (infoRec->ImageGlyphBltNonTE)
-        infoRec->ImageGlyphBltNonTE = XAAOverImageGlyphBltNonTE;
-    if (infoRec->PolyGlyphBltNonTE)
-        infoRec->PolyGlyphBltNonTE = XAAOverPolyGlyphBltNonTE;
-    if (infoRec->PolyRectangleThinSolid)
-        infoRec->PolyRectangleThinSolid = XAAOverPolyRectangleThinSolid;
-    if (infoRec->PolylinesWideSolid)
-        infoRec->PolylinesWideSolid = XAAOverPolylinesWideSolid;
-    if (infoRec->PolylinesThinSolid)
-        infoRec->PolylinesThinSolid = XAAOverPolylinesThinSolid;
-    if (infoRec->PolySegmentThinSolid)
-        infoRec->PolySegmentThinSolid = XAAOverPolySegmentThinSolid;
-    if (infoRec->PolylinesThinDashed)
-        infoRec->PolylinesThinDashed = XAAOverPolylinesThinDashed;
-    if (infoRec->PolySegmentThinDashed)
-        infoRec->PolySegmentThinDashed = XAAOverPolySegmentThinDashed;
-    if (infoRec->FillPolygonSolid)
-        infoRec->FillPolygonSolid = XAAOverFillPolygonSolid;
-    if (infoRec->FillPolygonStippled)
-        infoRec->FillPolygonStippled = XAAOverFillPolygonStippled;
-    if (infoRec->FillPolygonOpaqueStippled)
-        infoRec->FillPolygonOpaqueStippled = XAAOverFillPolygonOpaqueStippled;
-    if (infoRec->FillPolygonTiled)
-        infoRec->FillPolygonTiled = XAAOverFillPolygonTiled;
-    if (infoRec->PolyFillArcSolid)
-        infoRec->PolyFillArcSolid = XAAOverPolyFillArcSolid;
-    if (infoRec->PutImage)
-        infoRec->PutImage = XAAOverPutImage;
-
-    return TRUE;
-}
-
-/***********************  Screen functions ************************/
-
-void
-XAAOverCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pScreen);
-    ScrnInfoPtr pScrn = infoRec->pScrn;
-    DDXPointPtr ppt, pptSrc;
-    RegionRec rgnDst;
-    BoxPtr pbox;
-    int i, nbox, dx, dy;
-    WindowPtr pRoot = pScreen->root;
-
-    if (!pScrn->vtSema || !infoRec->ScreenToScreenBitBlt) {
-        XAA_SCREEN_PROLOGUE(pScreen, CopyWindow);
-        if (pScrn->vtSema && infoRec->NeedToSync) {
-            (*infoRec->Sync) (pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-        (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
-        XAA_SCREEN_EPILOGUE(pScreen, CopyWindow, XAAOverCopyWindow);
-        return;
-    }
-
-    infoRec->ScratchGC.alu = GXcopy;
-    infoRec->ScratchGC.planemask = ~0;
-
-    RegionNull(&rgnDst);
-
-    dx = ptOldOrg.x - pWin->drawable.x;
-    dy = ptOldOrg.y - pWin->drawable.y;
-    RegionTranslate(prgnSrc, -dx, -dy);
-    RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
-
-    nbox = RegionNumRects(&rgnDst);
-    if (nbox && (pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec)))) {
-
-        pbox = RegionRects(&rgnDst);
-        for (i = nbox, ppt = pptSrc; i--; ppt++, pbox++) {
-            ppt->x = pbox->x1 + dx;
-            ppt->y = pbox->y1 + dy;
-        }
-
-        SWITCH_DEPTH(8);
-        XAADoBitBlt((DrawablePtr) pRoot, (DrawablePtr) pRoot,
-                    &(infoRec->ScratchGC), &rgnDst, pptSrc);
-
-        if (pWin->drawable.bitsPerPixel != 8) {
-            SWITCH_DEPTH(pScrn->depth);
-            XAADoBitBlt((DrawablePtr) pRoot, (DrawablePtr) pRoot,
-                        &(infoRec->ScratchGC), &rgnDst, pptSrc);
-        }
-
-        free(pptSrc);
-    }
-
-    RegionUninit(&rgnDst);
-
-    if (pWin->drawable.depth == 8) {
-        RegionNull(&rgnDst);
-        miSegregateChildren(pWin, &rgnDst, pScrn->depth);
-        if (RegionNotEmpty(&rgnDst)) {
-            RegionIntersect(&rgnDst, &rgnDst, prgnSrc);
-            nbox = RegionNumRects(&rgnDst);
-            if (nbox &&
-                (pptSrc = (DDXPointPtr) malloc(nbox * sizeof(DDXPointRec)))) {
-
-                pbox = RegionRects(&rgnDst);
-                for (i = nbox, ppt = pptSrc; i--; ppt++, pbox++) {
-                    ppt->x = pbox->x1 + dx;
-                    ppt->y = pbox->y1 + dy;
-                }
-
-                SWITCH_DEPTH(pScrn->depth);
-                XAADoBitBlt((DrawablePtr) pRoot, (DrawablePtr) pRoot,
-                            &(infoRec->ScratchGC), &rgnDst, pptSrc);
-                free(pptSrc);
-            }
-        }
-        RegionUninit(&rgnDst);
-    }
-}
-
-void
-XAAOverWindowExposures(WindowPtr pWin, RegionPtr pReg, RegionPtr pOtherReg)
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-
-    if ((pWin->drawable.bitsPerPixel != 8) && infoRec->pScrn->vtSema) {
-        if (RegionNumRects(pReg) && infoRec->FillSolidRects) {
-            XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pScreen);
-
-            SWITCH_DEPTH(8);
-            (*infoRec->FillSolidRects) (infoRec->pScrn,
-                                        infoRec->pScrn->colorKey, GXcopy, ~0,
-                                        RegionNumRects(pReg),
-                                        RegionRects(pReg));
-            miWindowExposures(pWin, pReg, pOtherReg);
-            return;
-        }
-        else if (infoRec->NeedToSync) {
-            (*infoRec->Sync) (infoRec->pScrn);
-            infoRec->NeedToSync = FALSE;
-        }
-    }
-
-    XAA_SCREEN_PROLOGUE(pScreen, WindowExposures);
-    (*pScreen->WindowExposures) (pWin, pReg, pOtherReg);
-    XAA_SCREEN_EPILOGUE(pScreen, WindowExposures, XAAOverWindowExposures);
-}
-
-/*********************  Choosers *************************/
-
-static int
-XAAOverStippledFillChooser(GCPtr pGC)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-    int ret;
-
-    ret = (*pOverPriv->StippledFillChooser) (pGC);
-
-    if ((pGC->depth == 8) && ((ret == DO_COLOR_8x8) || (ret == DO_CACHE_BLT))) {
-        ret = 0;
-    }
-
-    return ret;
-}
-
-static int
-XAAOverOpaqueStippledFillChooser(GCPtr pGC)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-    int ret;
-
-    ret = (*pOverPriv->OpaqueStippledFillChooser) (pGC);
-
-    if ((pGC->depth == 8) && ((ret == DO_COLOR_8x8) || (ret == DO_CACHE_BLT))) {
-        ret = 0;
-    }
-
-    return ret;
-}
-
-static int
-XAAOverTiledFillChooser(GCPtr pGC)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-    int ret;
-
-    ret = (*pOverPriv->TiledFillChooser) (pGC);
-
-    if ((pGC->depth == 8) && ((ret == DO_COLOR_8x8) || (ret == DO_CACHE_BLT))) {
-        ret = 0;
-    }
-
-    return ret;
-}
-
-/**************************** GC Functions **************************/
-
-static RegionPtr
-XAAOverCopyArea(DrawablePtr pSrc,
-                DrawablePtr pDst,
-                GC * pGC,
-                int srcx, int srcy, int width, int height, int dstx, int dsty)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->CopyArea) (pSrc, pDst,
-                                   pGC, srcx, srcy, width, height, dstx, dsty);
-}
-
-static RegionPtr
-XAAOverCopyPlane(DrawablePtr pSrc,
-                 DrawablePtr pDst,
-                 GCPtr pGC,
-                 int srcx, int srcy,
-                 int width, int height,
-                 int dstx, int dsty, unsigned long bitPlane)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->CopyPlane) (pSrc, pDst,
-                                    pGC, srcx, srcy, width, height, dstx, dsty,
-                                    bitPlane);
-
-}
-
-static void
-XAAOverPushPixelsSolid(GCPtr pGC,
-                       PixmapPtr pBitMap,
-                       DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PushPixelsSolid) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
-}
-
-static void
-XAAOverPolyFillRectSolid(DrawablePtr pDraw,
-                         GCPtr pGC, int nrectFill, xRectangle *prectInit)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyFillRectSolid) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAOverPolyFillRectStippled(DrawablePtr pDraw,
-                            GCPtr pGC, int nrectFill, xRectangle *prectInit)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyFillRectStippled) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAOverPolyFillRectOpaqueStippled(DrawablePtr pDraw,
-                                  GCPtr pGC,
-                                  int nrectFill, xRectangle *prectInit)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyFillRectOpaqueStippled) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAOverPolyFillRectTiled(DrawablePtr pDraw,
-                         GCPtr pGC, int nrectFill, xRectangle *prectInit)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyFillRectTiled) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAOverFillSpansSolid(DrawablePtr pDraw,
-                      GCPtr pGC,
-                      int nInit, DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillSpansSolid) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static void
-XAAOverFillSpansStippled(DrawablePtr pDraw,
-                         GCPtr pGC,
-                         int nInit, DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillSpansStippled) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static void
-XAAOverFillSpansOpaqueStippled(DrawablePtr pDraw,
-                               GCPtr pGC,
-                               int nInit,
-                               DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillSpansOpaqueStippled) (pDraw, pGC, nInit, ppt, pwidth,
-                                           fSorted);
-}
-
-static void
-XAAOverFillSpansTiled(DrawablePtr pDraw,
-                      GCPtr pGC,
-                      int nInit, DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillSpansTiled) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static int
-XAAOverPolyText8TE(DrawablePtr pDraw,
-                   GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->PolyText8TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static int
-XAAOverPolyText16TE(DrawablePtr pDraw,
-                    GCPtr pGC, int x, int y, int count, unsigned short *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->PolyText16TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageText8TE(DrawablePtr pDraw,
-                    GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageText8TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageText16TE(DrawablePtr pDraw,
-                     GCPtr pGC, int x, int y, int count, unsigned short *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageText16TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageGlyphBltTE(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int xInit, int yInit,
-                       unsigned int nglyph,
-                       CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageGlyphBltTE) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                                   pglyphBase);
-}
-
-static void
-XAAOverPolyGlyphBltTE(DrawablePtr pDraw,
-                      GCPtr pGC,
-                      int xInit, int yInit,
-                      unsigned int nglyph,
-                      CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyGlyphBltTE) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                                  pglyphBase);
-}
-
-static int
-XAAOverPolyText8NonTE(DrawablePtr pDraw,
-                      GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->PolyText8NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static int
-XAAOverPolyText16NonTE(DrawablePtr pDraw,
-                       GCPtr pGC,
-                       int x, int y, int count, unsigned short *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    return (*pOverPriv->PolyText16NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageText8NonTE(DrawablePtr pDraw,
-                       GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageText8NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageText16NonTE(DrawablePtr pDraw,
-                        GCPtr pGC,
-                        int x, int y, int count, unsigned short *chars)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageText16NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAOverImageGlyphBltNonTE(DrawablePtr pDraw,
-                          GCPtr pGC,
-                          int xInit, int yInit,
-                          unsigned int nglyph,
-                          CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->ImageGlyphBltNonTE) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                                      pglyphBase);
-}
-
-static void
-XAAOverPolyGlyphBltNonTE(DrawablePtr pDraw,
-                         GCPtr pGC,
-                         int xInit, int yInit,
-                         unsigned int nglyph,
-                         CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyGlyphBltNonTE) (pDraw, pGC, xInit, yInit, nglyph, ppci,
-                                     pglyphBase);
-}
-
-static void
-XAAOverPolyRectangleThinSolid(DrawablePtr pDraw,
-                              GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyRectangleThinSolid) (pDraw, pGC, nRectsInit, pRectsInit);
-}
-
-static void
-XAAOverPolylinesWideSolid(DrawablePtr pDraw,
-                          GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolylinesWideSolid) (pDraw, pGC, mode, npt, pPts);
-}
-
-static void
-XAAOverPolylinesThinSolid(DrawablePtr pDraw,
-                          GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolylinesThinSolid) (pDraw, pGC, mode, npt, pPts);
-}
-
-static void
-XAAOverPolySegmentThinSolid(DrawablePtr pDraw,
-                            GCPtr pGC, int nseg, xSegment * pSeg)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolySegmentThinSolid) (pDraw, pGC, nseg, pSeg);
-}
-
-static void
-XAAOverPolylinesThinDashed(DrawablePtr pDraw,
-                           GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolylinesThinDashed) (pDraw, pGC, mode, npt, pPts);
-}
-
-static void
-XAAOverPolySegmentThinDashed(DrawablePtr pDraw,
-                             GCPtr pGC, int nseg, xSegment * pSeg)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolySegmentThinDashed) (pDraw, pGC, nseg, pSeg);
-}
-
-static void
-XAAOverFillPolygonSolid(DrawablePtr pDraw,
-                        GCPtr pGC,
-                        int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillPolygonSolid) (pDraw, pGC, shape, mode, count, ptsIn);
-}
-
-static void
-XAAOverFillPolygonStippled(DrawablePtr pDraw,
-                           GCPtr pGC,
-                           int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillPolygonStippled) (pDraw, pGC, shape, mode, count, ptsIn);
-}
-
-static void
-XAAOverFillPolygonOpaqueStippled(DrawablePtr pDraw,
-                                 GCPtr pGC,
-                                 int shape,
-                                 int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillPolygonOpaqueStippled) (pDraw, pGC, shape, mode, count,
-                                             ptsIn);
-}
-
-static void
-XAAOverFillPolygonTiled(DrawablePtr pDraw,
-                        GCPtr pGC,
-                        int shape, int mode, int count, DDXPointPtr ptsIn)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->FillPolygonTiled) (pDraw, pGC, shape, mode, count, ptsIn);
-}
-
-static void
-XAAOverPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PolyFillArcSolid) (pDraw, pGC, narcs, parcs);
-}
-
-static void
-XAAOverPutImage(DrawablePtr pDraw,
-                GCPtr pGC,
-                int depth,
-                int x,
-                int y, int w, int h, int leftPad, int format, char *pImage)
-{
-    XAAOverlayPtr pOverPriv = GET_OVERLAY_PRIV(pGC->pScreen);
-
-    SWITCH_DEPTH(pGC->depth);
-
-    (*pOverPriv->PutImage) (pDraw, pGC, depth, x, y, w, h,
-                            leftPad, format, pImage);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaPCache.c b/xorg-server/hw/xfree86/xaa/xaaPCache.c
deleted file mode 100644
index 53460b31e..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaPCache.c
+++ /dev/null
@@ -1,2527 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "gc.h"
-#include "mi.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "regionstr.h"
-#include "servermd.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaacexp.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-
-#define MAX_COLOR	32
-#define MAX_MONO	32
-#define MAX_8		32
-#define MAX_128		32
-#define MAX_256		32
-#define MAX_512		16
-
-static int CacheInitIndex = -1;
-
-#define CACHEINIT(p) ((p)->privates[CacheInitIndex].val)
-
-typedef struct _CacheLink {
-    int x;
-    int y;
-    int w;
-    int h;
-    struct _CacheLink *next;
-} CacheLink, *CacheLinkPtr;
-
-static void
-TransferList(CacheLinkPtr list, XAACacheInfoPtr array, int num)
-{
-    while (num--) {
-        array->x = list->x;
-        array->y = list->y;
-        array->w = list->w;
-        array->h = list->h;
-        array->serialNumber = 0;
-        array->fg = array->bg = -1;
-        list = list->next;
-        array++;
-    }
-}
-
-static CacheLinkPtr
-Enlist(CacheLinkPtr link, int x, int y, int w, int h)
-{
-    CacheLinkPtr newLink;
-
-    newLink = malloc(sizeof(CacheLink));
-    newLink->next = link;
-    newLink->x = x;
-    newLink->y = y;
-    newLink->w = w;
-    newLink->h = h;
-    return newLink;
-}
-
-static CacheLinkPtr
-Delist(CacheLinkPtr link)
-{
-    CacheLinkPtr ret = NULL;
-
-    if (link) {
-        ret = link->next;
-        free(link);
-    }
-    return ret;
-}
-
-static void
-FreeList(CacheLinkPtr link)
-{
-    CacheLinkPtr tmp;
-
-    while (link) {
-        tmp = link;
-        link = link->next;
-        free(tmp);
-    }
-}
-
-static CacheLinkPtr
-QuadLinks(CacheLinkPtr big, CacheLinkPtr little)
-{
-    /* CAUTION: This doesn't free big */
-    int w1, w2, h1, h2;
-
-    while (big) {
-        w1 = big->w >> 1;
-        w2 = big->w - w1;
-        h1 = big->h >> 1;
-        h2 = big->h - h1;
-
-        little = Enlist(little, big->x, big->y, w1, h1);
-        little = Enlist(little, big->x + w1, big->y, w2, h1);
-        little = Enlist(little, big->x, big->y + h1, w1, h2);
-        little = Enlist(little, big->x + w1, big->y + h1, w2, h2);
-
-        big = big->next;
-    }
-    return little;
-}
-
-static void
-SubdivideList(CacheLinkPtr * large, CacheLinkPtr * small)
-{
-    CacheLinkPtr big = *large;
-    CacheLinkPtr little = *small;
-    int size = big->w >> 1;
-
-    little = Enlist(little, big->x, big->y, size, size);
-    little = Enlist(little, big->x + size, big->y, size, size);
-    little = Enlist(little, big->x, big->y + size, size, size);
-    little = Enlist(little, big->x + size, big->y + size, size, size);
-    *small = little;
-    big = Delist(big);
-    *large = big;
-}
-
-static void
-FreePixmapCachePrivate(XAAPixmapCachePrivatePtr pPriv)
-{
-    if (!pPriv)
-        return;
-
-    free(pPriv->Info512);
-    free(pPriv->Info256);
-    free(pPriv->Info128);
-    free(pPriv->InfoColor);
-    free(pPriv->InfoMono);
-    free(pPriv->InfoPartial);
-
-    free(pPriv);
-}
-
-void
-XAAClosePixmapCache(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-
-    if (infoRec->PixmapCachePrivate)
-        FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec->
-                               PixmapCachePrivate);
-
-    infoRec->PixmapCachePrivate = NULL;
-}
-
-static CacheLinkPtr
-ThinOutPartials(CacheLinkPtr ListPartial, int *num, int *maxw, int *maxh)
-{
-/* This guy's job is to get at least 4 big slots out of a list of fragments */
-
-    CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;
-    int Num64, Num32, Num16, Num8, NumKeepers;
-    int w, h;
-
-    List64 = List32 = List16 = List8 = ListKeepers = NULL;
-    Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;
-    w = h = 0;
-
-    /* We sort partials by how large a square tile they can cache.
-       If a partial can't store a 64x64, 32x32, 16x16 or 8x8 tile,
-       we free it.  */
-
-    pCur = ListPartial;
-    while (pCur) {
-        next = pCur->next;
-        if ((pCur->w >= 64) && (pCur->h >= 64)) {
-            pCur->next = List64;
-            List64 = pCur;
-            Num64++;
-        }
-        else if ((pCur->w >= 32) && (pCur->h >= 32)) {
-            pCur->next = List32;
-            List32 = pCur;
-            Num32++;
-        }
-        else if ((pCur->w >= 16) && (pCur->h >= 16)) {
-            pCur->next = List16;
-            List16 = pCur;
-            Num16++;
-        }
-        else if ((pCur->w >= 8) && (pCur->h >= 8)) {
-            pCur->next = List8;
-            List8 = pCur;
-            Num8++;
-        }
-        else {
-            free(pCur);
-        }
-
-        pCur = next;
-    }
-
-    /* We save all the tiles from the largest bin that we can get
-       at least 4 of.  If there are too few of a bigger slot, we
-       cut it in fourths to make smaller slots. */
-
-    if (Num64 >= 4) {
-        ListKeepers = List64;
-        List64 = NULL;
-        NumKeepers = Num64;
-        goto GOT_EM;
-    }
-    else if (Num64) {
-        List32 = QuadLinks(List64, List32);
-        Num32 += Num64 * 4;
-        Num64 = 0;
-    }
-
-    if (Num32 >= 4) {
-        ListKeepers = List32;
-        List32 = NULL;
-        NumKeepers = Num32;
-        goto GOT_EM;
-    }
-    else if (Num32) {
-        List16 = QuadLinks(List32, List16);
-        Num16 += Num32 * 4;
-        Num32 = 0;
-    }
-
-    if (Num16 >= 4) {
-        ListKeepers = List16;
-        List16 = NULL;
-        NumKeepers = Num16;
-        goto GOT_EM;
-    }
-    else if (Num16) {
-        List8 = QuadLinks(List16, List8);
-        Num8 += Num16 * 4;
-        Num16 = 0;
-    }
-
-    if (Num8 >= 4) {
-        ListKeepers = List8;
-        List8 = NULL;
-        NumKeepers = Num8;
-        goto GOT_EM;
-    }
-
- GOT_EM:
-
-    /* Free the ones we aren't using */
-
-    if (List64)
-        FreeList(List64);
-    if (List32)
-        FreeList(List32);
-    if (List16)
-        FreeList(List16);
-    if (List8)
-        FreeList(List8);
-
-    /* Enlarge the slots if we can */
-
-    if (ListKeepers) {
-        CacheLinkPtr pLink = ListKeepers;
-
-        w = h = 128;
-
-        while (pLink) {
-            if (pLink->w < w)
-                w = pLink->w;
-            if (pLink->h < h)
-                h = pLink->h;
-            pLink = pLink->next;
-        }
-    }
-
-    *maxw = w;
-    *maxh = h;
-    *num = NumKeepers;
-    return ListKeepers;
-}
-
-static void
-ConvertColorToMono(CacheLinkPtr * ColorList,
-                   int ColorW, int ColorH,
-                   CacheLinkPtr * MonoList, int MonoW, int MonoH)
-{
-    int x, y, w;
-
-    x = (*ColorList)->x;
-    y = (*ColorList)->y;
-    *ColorList = Delist(*ColorList);
-
-    while (ColorH) {
-        ColorH -= MonoH;
-        for (w = 0; w <= (ColorW - MonoW); w += MonoW)
-            *MonoList = Enlist(*MonoList, x + w, y + ColorH, MonoW, MonoH);
-    }
-}
-
-static void
-ConvertAllPartialsTo8x8(int *NumMono, int *NumColor,
-                        CacheLinkPtr ListPartial,
-                        CacheLinkPtr * ListMono,
-                        CacheLinkPtr * ListColor, XAAInfoRecPtr infoRec)
-{
-/* This guy extracts as many 8x8 slots as it can out of fragments */
-
-    int ColorH = infoRec->CacheHeightColor8x8Pattern;
-    int ColorW = infoRec->CacheWidthColor8x8Pattern;
-    int MonoH = infoRec->CacheHeightMono8x8Pattern;
-    int MonoW = infoRec->CacheWidthMono8x8Pattern;
-    int x, y, w, Height, Width;
-    Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
-    Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
-    CacheLinkPtr pLink = ListPartial;
-    CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;
-
-    if (DoColor && DoMono) {
-        /* we assume color patterns take more space than color ones */
-        if (MonoH > ColorH)
-            ColorH = MonoH;
-        if (MonoW > ColorW)
-            ColorW = MonoW;
-    }
-
-    /* Break up the area into as many Color and Mono slots as we can */
-
-    while (pLink) {
-        Height = pLink->h;
-        Width = pLink->w;
-        x = pLink->x;
-        y = pLink->y;
-
-        if (DoColor) {
-            while (Height >= ColorH) {
-                Height -= ColorH;
-                for (w = 0; w <= (Width - ColorW); w += ColorW) {
-                    ColorList =
-                        Enlist(ColorList, x + w, y + Height, ColorW, ColorH);
-                    (*NumColor)++;
-                }
-            }
-        }
-
-        if (DoMono && (Height >= MonoH)) {
-            while (Height >= MonoH) {
-                Height -= MonoH;
-                for (w = 0; w <= (Width - MonoW); w += MonoW) {
-                    MonoList =
-                        Enlist(MonoList, x + w, y + Height, MonoW, MonoH);
-                    (*NumMono)++;
-                }
-            }
-        }
-
-        pLink = pLink->next;
-    }
-
-    *ListMono = MonoList;
-    *ListColor = ColorList;
-    FreeList(ListPartial);
-}
-
-static CacheLinkPtr
-ExtractOneThatFits(CacheLinkPtr * initList, int w, int h)
-{
-    CacheLinkPtr list = *initList;
-    CacheLinkPtr prev = NULL;
-
-    while (list) {
-        if ((list->w >= w) && (list->h >= h))
-            break;
-        prev = list;
-        list = list->next;
-    }
-
-    if (list) {
-        if (prev)
-            prev->next = list->next;
-        else
-            *initList = list->next;
-
-        list->next = NULL;
-    }
-
-    return list;
-}
-
-static CacheLinkPtr
-ConvertSomePartialsTo8x8(int *NumMono, int *NumColor, int *NumPartial,
-                         CacheLinkPtr ListPartial,
-                         CacheLinkPtr * ListMono,
-                         CacheLinkPtr * ListColor,
-                         int *maxw, int *maxh, XAAInfoRecPtr infoRec)
-{
-/* This guy tries to get 4 of each type of 8x8 slot requested out of
-   a list of fragments all while trying to retain some big fragments
-   for the cache blits */
-
-    int ColorH = infoRec->CacheHeightColor8x8Pattern;
-    int ColorW = infoRec->CacheWidthColor8x8Pattern;
-    int MonoH = infoRec->CacheHeightMono8x8Pattern;
-    int MonoW = infoRec->CacheWidthMono8x8Pattern;
-    Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
-    Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
-    CacheLinkPtr List64, List32, List16, List8, pCur, next, ListKeepers;
-    CacheLinkPtr MonoList = *ListMono, ColorList = *ListColor;
-    int Num64, Num32, Num16, Num8, NumKeepers;
-    int w, h, Width, Height;
-    int MonosPerColor = 1;
-
-    if (DoColor && DoMono) {
-        /* we assume color patterns take more space than color ones */
-        if (MonoH > ColorH)
-            ColorH = MonoH;
-        if (MonoW > ColorW)
-            ColorW = MonoW;
-        MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW);
-    }
-
-    List64 = List32 = List16 = List8 = ListKeepers = MonoList = ColorList =
-        NULL;
-    Num64 = Num32 = Num16 = Num8 = NumKeepers = 0;
-    Width = Height = 0;
-
-    /* We sort partials by how large a square tile they can cache.
-       We make 8x8 patterns from the leftovers if we can. */
-
-    pCur = ListPartial;
-    while (pCur) {
-        next = pCur->next;
-        if ((pCur->w >= 64) && (pCur->h >= 64)) {
-            pCur->next = List64;
-            List64 = pCur;
-            Num64++;
-        }
-        else if ((pCur->w >= 32) && (pCur->h >= 32)) {
-            pCur->next = List32;
-            List32 = pCur;
-            Num32++;
-        }
-        else if ((pCur->w >= 16) && (pCur->h >= 16)) {
-            pCur->next = List16;
-            List16 = pCur;
-            Num16++;
-        }
-        else if ((pCur->w >= 8) && (pCur->h >= 8)) {
-            pCur->next = List8;
-            List8 = pCur;
-            Num8++;
-        }
-        else {
-            h = pCur->h;
-            if (DoColor && (pCur->w >= ColorW) && (h >= ColorH)) {
-                while (h >= ColorH) {
-                    h -= ColorH;
-                    for (w = 0; w <= (pCur->w - ColorW); w += ColorW) {
-                        ColorList = Enlist(ColorList,
-                                           pCur->x + w, pCur->y + h, ColorW,
-                                           ColorH);
-                        (*NumColor)++;
-                    }
-                }
-            }
-            if (DoMono && (pCur->w >= MonoW) && (h >= MonoH)) {
-                while (h >= MonoH) {
-                    h -= MonoH;
-                    for (w = 0; w <= (pCur->w - MonoW); w += MonoW) {
-                        MonoList = Enlist(MonoList,
-                                          pCur->x + w, pCur->y + h, MonoW,
-                                          MonoH);
-                        (*NumMono)++;
-                    }
-                }
-            }
-            free(pCur);
-        }
-
-        pCur = next;
-    }
-
-    /* Try to extract at least 4 of each type of 8x8 slot that we need */
-
-    if (DoColor) {
-        CacheLinkPtr theOne;
-
-        while (*NumColor < 4) {
-            theOne = NULL;
-            if (Num8) {
-                if ((theOne = ExtractOneThatFits(&List8, ColorW, ColorH)))
-                    Num8--;
-            }
-            if (Num16 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List16, ColorW, ColorH)))
-                    Num16--;
-            }
-            if (Num32 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List32, ColorW, ColorH)))
-                    Num32--;
-            }
-            if (Num64 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List64, ColorW, ColorH)))
-                    Num64--;
-            }
-
-            if (!theOne)
-                break;
-
-            ConvertAllPartialsTo8x8(NumMono, NumColor, theOne,
-                                    &MonoList, &ColorList, infoRec);
-
-            if (DoMono) {
-                while (*NumColor && (*NumMono < 4)) {
-                    ConvertColorToMono(&ColorList, ColorW, ColorH,
-                                       &MonoList, MonoW, MonoH);
-                    (*NumColor)--;
-                    *NumMono += MonosPerColor;
-                }
-            }
-        }
-    }
-
-    if (DoMono) {
-        CacheLinkPtr theOne;
-
-        while (*NumMono < 4) {
-            theOne = NULL;
-            if (Num8) {
-                if ((theOne = ExtractOneThatFits(&List8, MonoW, MonoH)))
-                    Num8--;
-            }
-            if (Num16 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List16, MonoW, MonoH)))
-                    Num16--;
-            }
-            if (Num32 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List32, MonoW, MonoH)))
-                    Num32--;
-            }
-            if (Num64 && !theOne) {
-                if ((theOne = ExtractOneThatFits(&List64, MonoW, MonoH)))
-                    Num64--;
-            }
-
-            if (!theOne)
-                break;
-
-            ConvertAllPartialsTo8x8(NumMono, NumColor, theOne,
-                                    &MonoList, &ColorList, infoRec);
-        }
-    }
-
-    /* We save all the tiles from the largest bin that we can get
-       at least 4 of.  If there are too few of a bigger slot, we
-       cut it in fourths to make smaller slots. */
-
-    if (Num64 >= 4) {
-        ListKeepers = List64;
-        List64 = NULL;
-        NumKeepers = Num64;
-        goto GOT_EM;
-    }
-    else if (Num64) {
-        List32 = QuadLinks(List64, List32);
-        Num32 += Num64 * 4;
-        Num64 = 0;
-    }
-
-    if (Num32 >= 4) {
-        ListKeepers = List32;
-        List32 = NULL;
-        NumKeepers = Num32;
-        goto GOT_EM;
-    }
-    else if (Num32) {
-        List16 = QuadLinks(List32, List16);
-        Num16 += Num32 * 4;
-        Num32 = 0;
-    }
-
-    if (Num16 >= 4) {
-        ListKeepers = List16;
-        List16 = NULL;
-        NumKeepers = Num16;
-        goto GOT_EM;
-    }
-    else if (Num16) {
-        List8 = QuadLinks(List16, List8);
-        Num8 += Num16 * 4;
-        Num16 = 0;
-    }
-
-    if (Num8 >= 4) {
-        ListKeepers = List8;
-        List8 = NULL;
-        NumKeepers = Num8;
-        goto GOT_EM;
-    }
-
- GOT_EM:
-
-    /* Free the ones we aren't using */
-
-    if (List64)
-        ConvertAllPartialsTo8x8(NumMono, NumColor, List64,
-                                &MonoList, &ColorList, infoRec);
-    if (List32)
-        ConvertAllPartialsTo8x8(NumMono, NumColor, List32,
-                                &MonoList, &ColorList, infoRec);
-    if (List16)
-        ConvertAllPartialsTo8x8(NumMono, NumColor, List16,
-                                &MonoList, &ColorList, infoRec);
-    if (List8)
-        ConvertAllPartialsTo8x8(NumMono, NumColor, List8,
-                                &MonoList, &ColorList, infoRec);
-
-    /* Enlarge the slots if we can */
-
-    if (ListKeepers) {
-        CacheLinkPtr pLink = ListKeepers;
-
-        Width = Height = 128;
-
-        while (pLink) {
-            if (pLink->w < Width)
-                Width = pLink->w;
-            if (pLink->h < Height)
-                Height = pLink->h;
-            pLink = pLink->next;
-        }
-    }
-
-    *ListMono = MonoList;
-    *ListColor = ColorList;
-    *maxw = Width;
-    *maxh = Height;
-    *NumPartial = NumKeepers;
-    return ListKeepers;
-}
-
-void
-XAAInitPixmapCache(ScreenPtr pScreen, RegionPtr areas, pointer data)
-{
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAInfoRecPtr infoRec = (XAAInfoRecPtr) data;
-    XAAPixmapCachePrivatePtr pCachePriv;
-    BoxPtr pBox = RegionRects(areas);
-    int nBox = RegionNumRects(areas);
-    int Num512, Num256, Num128, NumPartial, NumColor, NumMono;
-    int Target512, Target256;
-    CacheLinkPtr List512, List256, List128, ListPartial, ListColor, ListMono;
-    int x, y, w, h, ntotal, granularity, width, height, i;
-    int MaxPartialWidth, MaxPartialHeight;
-
-    infoRec->MaxCacheableTileWidth = 0;
-    infoRec->MaxCacheableTileHeight = 0;
-    infoRec->MaxCacheableStippleHeight = 0;
-    infoRec->MaxCacheableStippleWidth = 0;
-    infoRec->UsingPixmapCache = FALSE;
-
-    if (!nBox || !pBox || !(infoRec->Flags & PIXMAP_CACHE))
-        return;
-
-    /* Allocate a persistent per-screen init flag to control messages */
-    if (CacheInitIndex < 0)
-        CacheInitIndex = xf86AllocateScrnInfoPrivateIndex();
-
-    /* free the old private data if it exists */
-    if (infoRec->PixmapCachePrivate) {
-        FreePixmapCachePrivate((XAAPixmapCachePrivatePtr) infoRec->
-                               PixmapCachePrivate);
-        infoRec->PixmapCachePrivate = NULL;
-    }
-
-    Num512 = Num256 = Num128 = NumPartial = NumMono = NumColor = 0;
-    List512 = List256 = List128 = ListPartial = ListMono = ListColor = NULL;
-    granularity = infoRec->CachePixelGranularity;
-    if (granularity <= 1)
-        granularity = 0;
-
-    /* go through the boxes and break it into as many pieces as we can fit */
-
-    while (nBox--) {
-        x = pBox->x1;
-        if (granularity) {
-            int tmp = x % granularity;
-
-            if (tmp)
-                x += (granularity - tmp);
-        }
-        width = pBox->x2 - x;
-        if (width <= 0) {
-            pBox++;
-            continue;
-        }
-
-        y = pBox->y1;
-        height = pBox->y2 - y;
-
-        for (h = 0; h <= (height - 512); h += 512) {
-            for (w = 0; w <= (width - 512); w += 512) {
-                List512 = Enlist(List512, x + w, y + h, 512, 512);
-                Num512++;
-            }
-            for (; w <= (width - 256); w += 256) {
-                List256 = Enlist(List256, x + w, y + h, 256, 256);
-                List256 = Enlist(List256, x + w, y + h + 256, 256, 256);
-                Num256 += 2;
-            }
-            for (; w <= (width - 128); w += 128) {
-                List128 = Enlist(List128, x + w, y + h, 128, 128);
-                List128 = Enlist(List128, x + w, y + h + 128, 128, 128);
-                List128 = Enlist(List128, x + w, y + h + 256, 128, 128);
-                List128 = Enlist(List128, x + w, y + h + 384, 128, 128);
-                Num128 += 4;
-            }
-            if (w < width) {
-                int d = width - w;
-
-                ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);
-                ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);
-                ListPartial = Enlist(ListPartial, x + w, y + h + 256, d, 128);
-                ListPartial = Enlist(ListPartial, x + w, y + h + 384, d, 128);
-                NumPartial += 4;
-            }
-        }
-        for (; h <= (height - 256); h += 256) {
-            for (w = 0; w <= (width - 256); w += 256) {
-                List256 = Enlist(List256, x + w, y + h, 256, 256);
-                Num256++;
-            }
-            for (; w <= (width - 128); w += 128) {
-                List128 = Enlist(List128, x + w, y + h, 128, 128);
-                List128 = Enlist(List128, x + w, y + h + 128, 128, 128);
-                Num128 += 2;
-            }
-            if (w < width) {
-                int d = width - w;
-
-                ListPartial = Enlist(ListPartial, x + w, y + h, d, 128);
-                ListPartial = Enlist(ListPartial, x + w, y + h + 128, d, 128);
-                NumPartial += 2;
-            }
-        }
-        for (; h <= (height - 128); h += 128) {
-            for (w = 0; w <= (width - 128); w += 128) {
-                List128 = Enlist(List128, x + w, y + h, 128, 128);
-                Num128++;
-            }
-            if (w < width) {
-                ListPartial = Enlist(ListPartial, x + w, y + h, width - w, 128);
-                NumPartial++;
-            }
-        }
-        if (h < height) {
-            int d = height - h;
-
-            for (w = 0; w <= (width - 128); w += 128) {
-                ListPartial = Enlist(ListPartial, x + w, y + h, 128, d);
-                NumPartial++;
-            }
-            if (w < width) {
-                ListPartial = Enlist(ListPartial, x + w, y + h, width - w, d);
-                NumPartial++;
-            }
-        }
-        pBox++;
-    }
-
-/* 
-   by this point we've carved the space into as many 512x512, 256x256
-	and 128x128 blocks as we could fit.  We will then break larger
-	blocks into smaller ones if we need to.  The rules are as follows:
-
-     512x512 -
-	1) Don't take up more than half the memory.
-	2) Don't bother if you can't get at least four.
-	3) Don't make more than MAX_512.
-	4) Don't have any of there are no 256x256s.
-
-     256x256 -
-	1) Don't take up more than a quarter of the memory enless there
-		aren't any 512x512s.  Then we can take up to half.
-	2) Don't bother if you can't get at least four.
-	3) Don't make more than MAX_256.
-
-     128x128 -
-	1) Don't make more than MAX_128.
-
-     We don't bother with the partial blocks unless we can use them
-     for 8x8 pattern fills or we are short on larger blocks.
-
-*/
-
-    ntotal = Num128 + (Num256 << 2) + (Num512 << 4);
-
-    Target512 = ntotal >> 5;
-    if (Target512 < 4)
-        Target512 = 0;
-    if (!Target512)
-        Target256 = ntotal >> 3;
-    else
-        Target256 = ntotal >> 4;
-    if (Target256 < 4)
-        Target256 = 0;
-
-    if (Num512 && Num256 < 4) {
-        while (Num512 && Num256 < Target256) {
-            SubdivideList(&List512, &List256);
-            Num256 += 4;
-            Num512--;
-        }
-    }
-
-    if (!Num512) {              /* no room */
-    }
-    else if ((Num512 < 4) || (!Target512)) {
-        while (Num512) {
-            SubdivideList(&List512, &List256);
-            Num256 += 4;
-            Num512--;
-        }
-    }
-    else if ((Num512 > MAX_512) || (Num512 > Target512)) {
-        while (Num512 > MAX_512) {
-            SubdivideList(&List512, &List256);
-            Num256 += 4;
-            Num512--;
-        }
-        while (Num512 > Target512) {
-            if (Num256 < MAX_256) {
-                SubdivideList(&List512, &List256);
-                Num256 += 4;
-                Num512--;
-            }
-            else
-                break;
-        }
-    }
-
-    if (!Num256) {              /* no room */
-    }
-    else if ((Num256 < 4) || (!Target256)) {
-        while (Num256) {
-            SubdivideList(&List256, &List128);
-            Num128 += 4;
-            Num256--;
-        }
-    }
-    else if ((Num256 > MAX_256) || (Num256 > Target256)) {
-        while (Num256 > MAX_256) {
-            SubdivideList(&List256, &List128);
-            Num128 += 4;
-            Num256--;
-        }
-        while (Num256 > Target256) {
-            if (Num128 < MAX_128) {
-                SubdivideList(&List256, &List128);
-                Num128 += 4;
-                Num256--;
-            }
-            else
-                break;
-        }
-    }
-
-    if (Num128 && ((Num128 < 4) || (Num128 > MAX_128))) {
-        CacheLinkPtr next;
-        int max = (Num128 > MAX_128) ? MAX_128 : 0;
-
-        /*
-         * Note: next is set in this way to work around a code generation
-         * bug in gcc 2.7.2.3.
-         */
-        next = List128->next;
-        while (Num128 > max) {
-            List128->next = ListPartial;
-            ListPartial = List128;
-            if ((List128 = next))
-                next = List128->next;
-            NumPartial++;
-            Num128--;
-        }
-    }
-
-    MaxPartialHeight = MaxPartialWidth = 0;
-
-    /* at this point we have as many 512x512 and 256x256 slots as we
-       want but may have an excess of 128x128 slots.  We still need
-       to find out if we need 8x8 slots.  We take these from the
-       partials if we have them.  Otherwise, we break some 128x128's */
-
-    if (!(infoRec->PixmapCacheFlags & (CACHE_MONO_8x8 | CACHE_COLOR_8x8))) {
-        if (NumPartial) {
-            if (Num128) {       /* don't bother with partials */
-                FreeList(ListPartial);
-                NumPartial = 0;
-                ListPartial = NULL;
-            }
-            else {
-                /* We have no big slots.  Weed out the unusable partials */
-                ListPartial = ThinOutPartials(ListPartial, &NumPartial,
-                                              &MaxPartialWidth,
-                                              &MaxPartialHeight);
-            }
-        }
-    }
-    else {
-        int MonosPerColor = 1;
-        int ColorH = infoRec->CacheHeightColor8x8Pattern;
-        int ColorW = infoRec->CacheWidthColor8x8Pattern;
-        int MonoH = infoRec->CacheHeightMono8x8Pattern;
-        int MonoW = infoRec->CacheWidthMono8x8Pattern;
-        Bool DoColor = (infoRec->PixmapCacheFlags & CACHE_COLOR_8x8);
-        Bool DoMono = (infoRec->PixmapCacheFlags & CACHE_MONO_8x8);
-
-        if (DoColor)
-            infoRec->CanDoColor8x8 = FALSE;
-        if (DoMono)
-            infoRec->CanDoMono8x8 = FALSE;
-
-        if (DoColor && DoMono) {
-            /* we assume color patterns take more space than color ones */
-            if (MonoH > ColorH)
-                ColorH = MonoH;
-            if (MonoW > ColorW)
-                ColorW = MonoW;
-            MonosPerColor = (ColorH / MonoH) * (ColorW / MonoW);
-        }
-
-        if (Num128) {
-            if (NumPartial) {   /* use all for 8x8 slots */
-                ConvertAllPartialsTo8x8(&NumMono, &NumColor,
-                                        ListPartial, &ListMono, &ListColor,
-                                        infoRec);
-                NumPartial = 0;
-                ListPartial = NULL;
-            }
-
-            /* Get some 8x8 slots from the 128 slots */
-            while ((Num128 > 4) &&
-                   ((NumMono < MAX_MONO) && (NumColor < MAX_COLOR))) {
-                CacheLinkPtr tmp = NULL;
-
-                tmp = Enlist(tmp, List128->x, List128->y,
-                             List128->w, List128->h);
-                List128 = Delist(List128);
-                Num128--;
-
-                ConvertAllPartialsTo8x8(&NumMono, &NumColor,
-                                        tmp, &ListMono, &ListColor, infoRec);
-            }
-        }
-        else if (NumPartial) {
-            /* We have share partials between 8x8 slots and tiles. */
-            ListPartial = ConvertSomePartialsTo8x8(&NumMono, &NumColor,
-                                                   &NumPartial, ListPartial,
-                                                   &ListMono, &ListColor,
-                                                   &MaxPartialWidth,
-                                                   &MaxPartialHeight, infoRec);
-        }
-
-        if (DoMono && DoColor) {
-            if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {
-                int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;
-
-                while (NumColor > max) {
-                    ConvertColorToMono(&ListColor, ColorW, ColorH,
-                                       &ListMono, MonoW, MonoH);
-                    NumColor--;
-                    NumMono += MonosPerColor;
-                }
-            }
-
-            /* favor Mono slots over Color ones */
-            while ((NumColor > 4) && (NumMono < MAX_MONO)) {
-                ConvertColorToMono(&ListColor, ColorW, ColorH,
-                                   &ListMono, MonoW, MonoH);
-                NumColor--;
-                NumMono += MonosPerColor;
-            }
-        }
-
-        if (NumMono && ((NumMono > MAX_MONO) || (NumMono < 4))) {
-            int max = (NumMono > MAX_MONO) ? MAX_MONO : 0;
-
-            while (NumMono > max) {
-                ListMono = Delist(ListMono);
-                NumMono--;
-            }
-        }
-        if (NumColor && ((NumColor > MAX_COLOR) || (NumColor < 4))) {
-            int max = (NumColor > MAX_COLOR) ? MAX_COLOR : 0;
-
-            while (NumColor > max) {
-                ListColor = Delist(ListColor);
-                NumColor--;
-            }
-        }
-    }
-
-    pCachePriv = calloc(1, sizeof(XAAPixmapCachePrivate));
-    if (!pCachePriv) {
-        if (Num512)
-            FreeList(List512);
-        if (Num256)
-            FreeList(List256);
-        if (Num128)
-            FreeList(List128);
-        if (NumPartial)
-            FreeList(ListPartial);
-        if (NumColor)
-            FreeList(ListColor);
-        if (NumMono)
-            FreeList(ListMono);
-        return;
-    }
-
-    infoRec->PixmapCachePrivate = (char *) pCachePriv;
-
-    if (Num512) {
-        pCachePriv->Info512 = calloc(Num512, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->Info512)
-            Num512 = 0;
-        if (Num512)
-            TransferList(List512, pCachePriv->Info512, Num512);
-        FreeList(List512);
-        pCachePriv->Num512x512 = Num512;
-    }
-    if (Num256) {
-        pCachePriv->Info256 = calloc(Num256, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->Info256)
-            Num256 = 0;
-        if (Num256)
-            TransferList(List256, pCachePriv->Info256, Num256);
-        FreeList(List256);
-        pCachePriv->Num256x256 = Num256;
-    }
-    if (Num128) {
-        pCachePriv->Info128 = calloc(Num128, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->Info128)
-            Num128 = 0;
-        if (Num128)
-            TransferList(List128, pCachePriv->Info128, Num128);
-        FreeList(List128);
-        pCachePriv->Num128x128 = Num128;
-    }
-
-    if (NumPartial) {
-        pCachePriv->InfoPartial = calloc(NumPartial, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->InfoPartial)
-            NumPartial = 0;
-        if (NumPartial)
-            TransferList(ListPartial, pCachePriv->InfoPartial, NumPartial);
-        FreeList(ListPartial);
-        pCachePriv->NumPartial = NumPartial;
-    }
-
-    if (NumColor) {
-        pCachePriv->InfoColor = calloc(NumColor, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->InfoColor)
-            NumColor = 0;
-        if (NumColor)
-            TransferList(ListColor, pCachePriv->InfoColor, NumColor);
-        FreeList(ListColor);
-        pCachePriv->NumColor = NumColor;
-    }
-
-    if (NumMono) {
-        pCachePriv->InfoMono = calloc(NumMono, sizeof(XAACacheInfoRec));
-        if (!pCachePriv->InfoMono)
-            NumMono = 0;
-        if (NumMono)
-            TransferList(ListMono, pCachePriv->InfoMono, NumMono);
-        FreeList(ListMono);
-        pCachePriv->NumMono = NumMono;
-    }
-
-    if (NumPartial) {
-        infoRec->MaxCacheableTileWidth = MaxPartialWidth;
-        infoRec->MaxCacheableTileHeight = MaxPartialHeight;
-    }
-    if (Num128)
-        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 128;
-    if (Num256)
-        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 256;
-    if (Num512)
-        infoRec->MaxCacheableTileWidth = infoRec->MaxCacheableTileHeight = 512;
-
-    infoRec->MaxCacheableStippleHeight = infoRec->MaxCacheableTileHeight;
-    infoRec->MaxCacheableStippleWidth =
-        infoRec->MaxCacheableTileWidth * pScrn->bitsPerPixel;
-    if (infoRec->ScreenToScreenColorExpandFillFlags & TRIPLE_BITS_24BPP)
-        infoRec->MaxCacheableStippleWidth /= 3;
-
-    if (NumMono) {
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              (HARDWARE_PATTERN_PROGRAMMED_ORIGIN |
-               HARDWARE_PATTERN_PROGRAMMED_BITS))) {
-            int numPerLine =
-                infoRec->CacheWidthMono8x8Pattern / infoRec->MonoPatternPitch;
-
-            for (i = 0; i < 64; i++) {
-                pCachePriv->MonoOffsets[i].y = i / numPerLine;
-                pCachePriv->MonoOffsets[i].x = (i % numPerLine) *
-                    infoRec->MonoPatternPitch;
-            }
-        }
-        infoRec->CanDoMono8x8 = TRUE;
-    }
-    if (NumColor) {
-        if (!(infoRec->Color8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-
-            for (i = 0; i < 64; i++) {
-                pCachePriv->ColorOffsets[i].y = i & 0x07;
-                pCachePriv->ColorOffsets[i].x = i & ~0x07;
-            }
-        }
-        infoRec->CanDoColor8x8 = TRUE;
-    }
-
-    if (!CACHEINIT(pScrn)) {
-        xf86ErrorF("\tSetting up tile and stipple cache:\n");
-        if (NumPartial)
-            xf86ErrorF("\t\t%i %ix%i slots\n",
-                       NumPartial, MaxPartialWidth, MaxPartialHeight);
-        if (Num128)
-            xf86ErrorF("\t\t%i 128x128 slots\n", Num128);
-        if (Num256)
-            xf86ErrorF("\t\t%i 256x256 slots\n", Num256);
-        if (Num512)
-            xf86ErrorF("\t\t%i 512x512 slots\n", Num512);
-        if (NumColor)
-            xf86ErrorF("\t\t%i 8x8 color pattern slots\n", NumColor);
-        if (NumMono)
-            xf86ErrorF("\t\t%i 8x8 color expansion slots\n", NumMono);
-    }
-
-    if (!(NumPartial | Num128 | Num256 | Num512 | NumColor | NumMono)) {
-        if (!CACHEINIT(pScrn))
-            xf86ErrorF("\t\tNot enough video memory for pixmap cache\n");
-    }
-    else
-        infoRec->UsingPixmapCache = TRUE;
-
-    CACHEINIT(pScrn) = 1;
-}
-
-#if X_BYTE_ORDER == X_BIG_ENDIAN
-static CARD32 StippleMasks[4] = {
-    0x80808080,
-    0xC0C0C0C0,
-    0x00000000,
-    0xF0F0F0F0
-};
-#else
-static CARD32 StippleMasks[4] = {
-    0x01010101,
-    0x03030303,
-    0x00000000,
-    0x0F0F0F0F
-};
-#endif
-
-Bool
-XAACheckStippleReducibility(PixmapPtr pPixmap)
-{
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);
-    CARD32 *IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
-    int w = pPixmap->drawable.width;
-    int h = pPixmap->drawable.height;
-    int i;
-    CARD32 bits[8];
-    CARD32 mask = SHIFT_R(0xFFFFFFFF, 24);
-
-    pPriv->flags |= REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR;
-    pPriv->flags &= ~REDUCIBLE_TO_8x8;
-
-    if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1)))
-        return FALSE;
-
-    i = (h > 8) ? 8 : h;
-
-    switch (w) {
-    case 32:
-        while (i--) {
-            bits[i] = IntPtr[i] & mask;
-            if ((bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 8)), 8)) ||
-                (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 16)), 16)) ||
-                (bits[i] != SHIFT_R((IntPtr[i] & SHIFT_L(mask, 24)), 24)))
-                return FALSE;
-        }
-        break;
-    case 16:
-        while (i--) {
-            bits[i] = IntPtr[i] & mask;
-            if (bits[i] != ((IntPtr[i] & SHIFT_R(SHIFT_L(mask, 8), 8))))
-                return FALSE;
-        }
-        break;
-    default:
-        while (i--)
-            bits[i] = IntPtr[i] & mask;
-        break;
-    }
-
-    switch (h) {
-    case 32:
-        if ((IntPtr[8] != IntPtr[16]) || (IntPtr[9] != IntPtr[17]) ||
-            (IntPtr[10] != IntPtr[18]) || (IntPtr[11] != IntPtr[19]) ||
-            (IntPtr[12] != IntPtr[20]) || (IntPtr[13] != IntPtr[21]) ||
-            (IntPtr[14] != IntPtr[22]) || (IntPtr[15] != IntPtr[23]) ||
-            (IntPtr[16] != IntPtr[24]) || (IntPtr[17] != IntPtr[25]) ||
-            (IntPtr[18] != IntPtr[26]) || (IntPtr[19] != IntPtr[27]) ||
-            (IntPtr[20] != IntPtr[28]) || (IntPtr[21] != IntPtr[29]) ||
-            (IntPtr[22] != IntPtr[30]) || (IntPtr[23] != IntPtr[31]))
-            return FALSE;
-        /* fall through */
-    case 16:
-        if ((IntPtr[0] != IntPtr[8]) || (IntPtr[1] != IntPtr[9]) ||
-            (IntPtr[2] != IntPtr[10]) || (IntPtr[3] != IntPtr[11]) ||
-            (IntPtr[4] != IntPtr[12]) || (IntPtr[5] != IntPtr[13]) ||
-            (IntPtr[6] != IntPtr[14]) || (IntPtr[7] != IntPtr[15]))
-            return FALSE;
-    case 8:
-        break;
-    case 1:
-        bits[1] = bits[0];
-    case 2:
-        bits[2] = bits[0];
-        bits[3] = bits[1];
-    case 4:
-        bits[4] = bits[0];
-        bits[5] = bits[1];
-        bits[6] = bits[2];
-        bits[7] = bits[3];
-        break;
-    }
-
-    pPriv->flags |= REDUCIBLE_TO_8x8;
-
-    pPriv->pattern0 =
-        bits[0] | SHIFT_L(bits[1], 8) | SHIFT_L(bits[2], 16) | SHIFT_L(bits[3],
-                                                                       24);
-    pPriv->pattern1 =
-        bits[4] | SHIFT_L(bits[5], 8) | SHIFT_L(bits[6], 16) | SHIFT_L(bits[7],
-                                                                       24);
-
-    if (w < 8) {
-        pPriv->pattern0 &= StippleMasks[w - 1];
-        pPriv->pattern1 &= StippleMasks[w - 1];
-
-        switch (w) {
-        case 1:
-            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 1);
-            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 1);
-        case 2:
-            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 2);
-            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 2);
-        case 4:
-            pPriv->pattern0 |= SHIFT_L(pPriv->pattern0, 4);
-            pPriv->pattern1 |= SHIFT_L(pPriv->pattern1, 4);
-        }
-    }
-
-    if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
-        pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);
-        pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);
-    }
-
-    return TRUE;
-}
-
-Bool
-XAACheckTileReducibility(PixmapPtr pPixmap, Bool checkMono)
-{
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
-    CARD32 *IntPtr;
-    int w = pPixmap->drawable.width;
-    int h = pPixmap->drawable.height;
-    int pitch = pPixmap->devKind >> 2;
-    int dwords, i, j;
-
-    pPriv->flags |= REDUCIBILITY_CHECKED;
-    pPriv->flags &= ~(REDUCIBILITY_CHECKED | REDUCIBLE_TO_2_COLOR);
-
-    if ((w > 32) || (h > 32) || (w & (w - 1)) || (h & (h - 1)))
-        return FALSE;
-
-    dwords = ((w * pPixmap->drawable.bitsPerPixel) + 31) >> 5;
-    i = (h > 8) ? 8 : h;
-
-    if (w > 8) {
-        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
-        switch (pPixmap->drawable.bitsPerPixel) {
-        case 8:
-            while (i--) {
-                for (j = 2; j < dwords; j++)
-                    if (IntPtr[j] != IntPtr[j & 0x01])
-                        return FALSE;
-                IntPtr += pitch;
-            }
-            break;
-        case 16:
-            while (i--) {
-                for (j = 4; j < dwords; j++)
-                    if (IntPtr[j] != IntPtr[j & 0x03])
-                        return FALSE;
-                IntPtr += pitch;
-            }
-            break;
-        case 24:
-            while (i--) {
-                for (j = 6; j < dwords; j++)
-                    if (IntPtr[j] != IntPtr[j % 6])
-                        return FALSE;
-                IntPtr += pitch;
-            }
-            break;
-        case 32:
-            while (i--) {
-                for (j = 8; j < dwords; j++)
-                    if (IntPtr[j] != IntPtr[j & 0x07])
-                        return FALSE;
-                IntPtr += pitch;
-            }
-            break;
-        default:
-            return FALSE;
-        }
-
-    }
-
-    if (h == 32) {
-        CARD32 *IntPtr2, *IntPtr3, *IntPtr4;
-
-        i = 8;
-        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
-        IntPtr2 = IntPtr + (pitch << 3);
-        IntPtr3 = IntPtr2 + (pitch << 3);
-        IntPtr4 = IntPtr3 + (pitch << 3);
-        while (i--) {
-            for (j = 0; j < dwords; j++)
-                if ((IntPtr[j] != IntPtr2[j]) || (IntPtr[j] != IntPtr3[j]) ||
-                    (IntPtr[j] != IntPtr4[j]))
-                    return FALSE;
-            IntPtr += pitch;
-            IntPtr2 += pitch;
-            IntPtr3 += pitch;
-            IntPtr4 += pitch;
-        }
-    }
-    else if (h == 16) {
-        CARD32 *IntPtr2;
-
-        i = 8;
-        IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
-        IntPtr2 = IntPtr + (pitch << 3);
-        while (i--) {
-            for (j = 0; j < dwords; j++)
-                if (IntPtr[j] != IntPtr2[j])
-                    return FALSE;
-            IntPtr += pitch;
-            IntPtr2 += pitch;
-        }
-    }
-
-    pPriv->flags |= REDUCIBLE_TO_8x8;
-
-    if (checkMono) {
-        XAAInfoRecPtr infoRec =
-            GET_XAAINFORECPTR_FROM_DRAWABLE(&pPixmap->drawable);
-        unsigned char bits[8];
-        int fg, bg = -1, x, y;
-
-        i = (h > 8) ? 8 : h;
-        j = (w > 8) ? 8 : w;
-
-        if (pPixmap->drawable.bitsPerPixel == 8) {
-            unsigned char *srcp = pPixmap->devPrivate.ptr;
-
-            fg = srcp[0];
-            pitch = pPixmap->devKind;
-            for (y = 0; y < i; y++) {
-                bits[y] = 0;
-                for (x = 0; x < j; x++) {
-                    if (srcp[x] != fg) {
-                        if (bg == -1)
-                            bg = srcp[x];
-                        else if (bg != srcp[x])
-                            return TRUE;
-                    }
-                    else
-                        bits[y] |= 1 << x;
-                }
-                srcp += pitch;
-            }
-        }
-        else if (pPixmap->drawable.bitsPerPixel == 16) {
-            unsigned short *srcp = (unsigned short *) pPixmap->devPrivate.ptr;
-
-            fg = srcp[0];
-            pitch = pPixmap->devKind >> 1;
-            for (y = 0; y < i; y++) {
-                bits[y] = 0;
-                for (x = 0; x < j; x++) {
-                    if (srcp[x] != fg) {
-                        if (bg == -1)
-                            bg = srcp[x];
-                        else if (bg != srcp[x])
-                            return TRUE;
-                    }
-                    else
-                        bits[y] |= 1 << x;
-                }
-                srcp += pitch;
-            }
-        }
-        else if (pPixmap->drawable.bitsPerPixel == 24) {
-            CARD32 val;
-            unsigned char *srcp = pPixmap->devPrivate.ptr;
-
-            fg = *((CARD32 *) srcp) & 0x00FFFFFF;
-            pitch = pPixmap->devKind;
-            j *= 3;
-            for (y = 0; y < i; y++) {
-                bits[y] = 0;
-                for (x = 0; x < j; x += 3) {
-                    val = *((CARD32 *) (srcp + x)) & 0x00FFFFFF;
-                    if (val != fg) {
-                        if (bg == -1)
-                            bg = val;
-                        else if (bg != val)
-                            return TRUE;
-                    }
-                    else
-                        bits[y] |= 1 << (x / 3);
-                }
-                srcp += pitch;
-            }
-        }
-        else if (pPixmap->drawable.bitsPerPixel == 32) {
-            IntPtr = (CARD32 *) pPixmap->devPrivate.ptr;
-            fg = IntPtr[0];
-            for (y = 0; y < i; y++) {
-                bits[y] = 0;
-                for (x = 0; x < j; x++) {
-                    if (IntPtr[x] != fg) {
-                        if (bg == -1)
-                            bg = IntPtr[x];
-                        else if (bg != IntPtr[x])
-                            return TRUE;
-                    }
-                    else
-                        bits[y] |= 1 << x;
-                }
-                IntPtr += pitch;
-            }
-        }
-        else
-            return TRUE;
-
-        pPriv->fg = fg;
-        if (bg == -1)
-            pPriv->bg = fg;
-        else
-            pPriv->bg = bg;
-
-        if (h < 8) {
-            switch (h) {
-            case 1:
-                bits[1] = bits[0];
-            case 2:
-                bits[2] = bits[0];
-                bits[3] = bits[1];
-            case 4:
-                bits[4] = bits[0];
-                bits[5] = bits[1];
-                bits[6] = bits[2];
-                bits[7] = bits[3];
-                break;
-            }
-        }
-
-        pPriv->pattern0 =
-            bits[0] | (bits[1] << 8) | (bits[2] << 16) | (bits[3] << 24);
-        pPriv->pattern1 =
-            bits[4] | (bits[5] << 8) | (bits[6] << 16) | (bits[7] << 24);
-
-        if (w < 8) {
-            switch (w) {
-            case 1:
-                pPriv->pattern0 |= (pPriv->pattern0 << 1);
-                pPriv->pattern1 |= (pPriv->pattern1 << 1);
-            case 2:
-                pPriv->pattern0 |= (pPriv->pattern0 << 2);
-                pPriv->pattern1 |= (pPriv->pattern1 << 2);
-            case 4:
-                pPriv->pattern0 |= (pPriv->pattern0 << 4);
-                pPriv->pattern1 |= (pPriv->pattern1 << 4);
-            }
-        }
-        pPriv->flags |= REDUCIBLE_TO_2_COLOR;
-
-        if (infoRec->Mono8x8PatternFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST) {
-            pPriv->pattern0 = SWAP_BITS_IN_BYTES(pPriv->pattern0);
-            pPriv->pattern1 = SWAP_BITS_IN_BYTES(pPriv->pattern1);
-        }
-
-    }
-
-    return TRUE;
-}
-
-void
-XAATileCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache, int w, int h)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, GXcopy, ~0, -1);
-
-    while ((w << 1) <= pCache->w) {
-        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
-                                                  pCache->x + w, pCache->y, w,
-                                                  h);
-        w <<= 1;
-    }
-    if (w != pCache->w) {
-        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
-                                                  pCache->x + w, pCache->y,
-                                                  pCache->w - w, h);
-        w = pCache->w;
-    }
-
-    while ((h << 1) <= pCache->h) {
-        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
-                                                  pCache->x, pCache->y + h, w,
-                                                  h);
-        h <<= 1;
-    }
-    if (h != pCache->h) {
-        (*infoRec->SubsequentScreenToScreenCopy) (pScrn, pCache->x, pCache->y,
-                                                  pCache->x, pCache->y + h, w,
-                                                  pCache->h - h);
-    }
-    SET_SYNC_FLAG(infoRec);
-}
-
-XAACacheInfoPtr
-XAACacheTile(ScrnInfoPtr pScrn, PixmapPtr pPix)
-{
-    int w = pPix->drawable.width;
-    int h = pPix->drawable.height;
-    int size = max(w, h);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache, cacheRoot = NULL;
-    int i, max = 0;
-    int *current;
-
-    if (size <= 128) {
-        if (pCachePriv->Info128) {
-            cacheRoot = pCachePriv->Info128;
-            max = pCachePriv->Num128x128;
-            current = &pCachePriv->Current128;
-        }
-        else {
-            cacheRoot = pCachePriv->InfoPartial;
-            max = pCachePriv->NumPartial;
-            current = &pCachePriv->CurrentPartial;
-        }
-    }
-    else if (size <= 256) {
-        cacheRoot = pCachePriv->Info256;
-        max = pCachePriv->Num256x256;
-        current = &pCachePriv->Current256;
-    }
-    else if (size <= 512) {
-        cacheRoot = pCachePriv->Info512;
-        max = pCachePriv->Num512x512;
-        current = &pCachePriv->Current512;
-    }
-    else {                      /* something's wrong */
-        ErrorF("Something's wrong in XAACacheTile()\n");
-        return pCachePriv->Info128;
-    }
-
-    pCache = cacheRoot;
-
-    /* lets look for it */
-    for (i = 0; i < max; i++, pCache++) {
-        if (pCache->serialNumber == pPix->drawable.serialNumber) {
-            pCache->trans_color = -1;
-            return pCache;
-        }
-    }
-
-    pCache = &cacheRoot[(*current)++];
-    if (*current >= max)
-        *current = 0;
-
-    pCache->serialNumber = pPix->drawable.serialNumber;
-    pCache->trans_color = pCache->bg = pCache->fg = -1;
-    pCache->orig_w = w;
-    pCache->orig_h = h;
-    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, w, h,
-                                    pPix->devPrivate.ptr, pPix->devKind,
-                                    pPix->drawable.bitsPerPixel,
-                                    pPix->drawable.depth);
-    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) &&
-        ((w != pCache->w) || (h != pCache->h)))
-        XAATileCache(pScrn, pCache, w, h);
-
-    return pCache;
-}
-
-XAACacheInfoPtr
-XAACacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
-{
-    int w = pPix->drawable.width;
-    int h = pPix->drawable.height;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache, cacheRoot = NULL;
-    int i, max = 0, funcNo, pad, dwords, bpp = pScrn->bitsPerPixel;
-    int *current;
-    StippleScanlineProcPtr StippleFunc;
-    unsigned char *data, *srcPtr, *dstPtr;
-
-    if ((h <= 128) && (w <= 128 * bpp)) {
-        if (pCachePriv->Info128) {
-            cacheRoot = pCachePriv->Info128;
-            max = pCachePriv->Num128x128;
-            current = &pCachePriv->Current128;
-        }
-        else {
-            cacheRoot = pCachePriv->InfoPartial;
-            max = pCachePriv->NumPartial;
-            current = &pCachePriv->CurrentPartial;
-        }
-    }
-    else if ((h <= 256) && (w <= 256 * bpp)) {
-        cacheRoot = pCachePriv->Info256;
-        max = pCachePriv->Num256x256;
-        current = &pCachePriv->Current256;
-    }
-    else if ((h <= 512) && (w <= 526 * bpp)) {
-        cacheRoot = pCachePriv->Info512;
-        max = pCachePriv->Num512x512;
-        current = &pCachePriv->Current512;
-    }
-    else {                      /* something's wrong */
-        ErrorF("Something's wrong in XAACacheMonoStipple()\n");
-        return pCachePriv->Info128;
-    }
-
-    pCache = cacheRoot;
-
-    /* lets look for it */
-    for (i = 0; i < max; i++, pCache++) {
-        if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
-            (pCache->fg == -1) && (pCache->bg == -1)) {
-            pCache->trans_color = -1;
-            return pCache;
-        }
-    }
-
-    pCache = &cacheRoot[(*current)++];
-    if (*current >= max)
-        *current = 0;
-
-    pCache->serialNumber = pPix->drawable.serialNumber;
-    pCache->trans_color = pCache->bg = pCache->fg = -1;
-    pCache->orig_w = w;
-    pCache->orig_h = h;
-
-    if (w <= 32) {
-        if (w & (w - 1))
-            funcNo = 1;
-        else
-            funcNo = 0;
-    }
-    else
-        funcNo = 2;
-
-    pad = BitmapBytePad(pCache->w * bpp);
-    dwords = bytes_to_int32(pad);
-    dstPtr = data = (unsigned char *) malloc(pad * pCache->h);
-    srcPtr = (unsigned char *) pPix->devPrivate.ptr;
-
-    if (infoRec->
-        ScreenToScreenColorExpandFillFlags & BIT_ORDER_IN_BYTE_MSBFIRST)
-        StippleFunc = XAAStippleScanlineFuncMSBFirst[funcNo];
-    else
-        StippleFunc = XAAStippleScanlineFuncLSBFirst[funcNo];
-
-    /* don't bother generating more than we'll ever use */
-    max = ((pScrn->displayWidth + w - 1) + 31) >> 5;
-    if (dwords > max)
-        dwords = max;
-
-    for (i = 0; i < h; i++) {
-        (*StippleFunc) ((CARD32 *) dstPtr, (CARD32 *) srcPtr, 0, w, dwords);
-        srcPtr += pPix->devKind;
-        dstPtr += pad;
-    }
-
-    while ((h << 1) <= pCache->h) {
-        memcpy(data + (pad * h), data, pad * h);
-        h <<= 1;
-    }
-
-    if (h < pCache->h)
-        memcpy(data + (pad * h), data, pad * (pCache->h - h));
-
-    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y, pCache->w,
-                                    pCache->h, data, pad, bpp, pScrn->depth);
-
-    free(data);
-
-    return pCache;
-}
-
-XAACacheInfoPtr
-XAACachePlanarMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
-{
-    int w = pPix->drawable.width;
-    int h = pPix->drawable.height;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache, cacheRoot = NULL;
-    int i, max = 0;
-    int *current;
-
-    if ((h <= 128) && (w <= 128)) {
-        if (pCachePriv->Info128) {
-            cacheRoot = pCachePriv->Info128;
-            max = pCachePriv->Num128x128;
-            current = &pCachePriv->Current128;
-        }
-        else {
-            cacheRoot = pCachePriv->InfoPartial;
-            max = pCachePriv->NumPartial;
-            current = &pCachePriv->CurrentPartial;
-        }
-    }
-    else if ((h <= 256) && (w <= 256)) {
-        cacheRoot = pCachePriv->Info256;
-        max = pCachePriv->Num256x256;
-        current = &pCachePriv->Current256;
-    }
-    else if ((h <= 512) && (w <= 526)) {
-        cacheRoot = pCachePriv->Info512;
-        max = pCachePriv->Num512x512;
-        current = &pCachePriv->Current512;
-    }
-    else {                      /* something's wrong */
-        ErrorF("Something's wrong in XAACachePlanarMonoStipple()\n");
-        return pCachePriv->Info128;
-    }
-
-    pCache = cacheRoot;
-
-    /* lets look for it */
-    for (i = 0; i < max; i++, pCache++) {
-        if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
-            (pCache->fg == -1) && (pCache->bg == -1)) {
-            pCache->trans_color = -1;
-            return pCache;
-        }
-    }
-
-    pCache = &cacheRoot[(*current)++];
-    if (*current >= max)
-        *current = 0;
-
-    pCache->serialNumber = pPix->drawable.serialNumber;
-    pCache->trans_color = pCache->bg = pCache->fg = -1;
-    pCache->orig_w = w;
-    pCache->orig_h = h;
-
-    /* Plane 0 holds the stipple. Plane 1 holds the inverted stipple */
-    (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
-                                    pPix->drawable.width, pPix->drawable.height,
-                                    pPix->devPrivate.ptr, pPix->devKind, 1, 2);
-    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_MONO_DATA) &&
-        ((w != pCache->w) || (h != pCache->h)))
-        XAATileCache(pScrn, pCache, w, h);
-
-    return pCache;
-}
-
-XAACachePlanarMonoStippleProc
-XAAGetCachePlanarMonoStipple(void)
-{
-    return XAACachePlanarMonoStipple;
-}
-
-XAACacheInfoPtr
-XAACacheStipple(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)
-{
-    int w = pPix->drawable.width;
-    int h = pPix->drawable.height;
-    int size = max(w, h);
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache, cacheRoot = NULL;
-    int i, max = 0;
-    int *current;
-
-    if (size <= 128) {
-        if (pCachePriv->Info128) {
-            cacheRoot = pCachePriv->Info128;
-            max = pCachePriv->Num128x128;
-            current = &pCachePriv->Current128;
-        }
-        else {
-            cacheRoot = pCachePriv->InfoPartial;
-            max = pCachePriv->NumPartial;
-            current = &pCachePriv->CurrentPartial;
-        }
-    }
-    else if (size <= 256) {
-        cacheRoot = pCachePriv->Info256;
-        max = pCachePriv->Num256x256;
-        current = &pCachePriv->Current256;
-    }
-    else if (size <= 512) {
-        cacheRoot = pCachePriv->Info512;
-        max = pCachePriv->Num512x512;
-        current = &pCachePriv->Current512;
-    }
-    else {                      /* something's wrong */
-        ErrorF("Something's wrong in XAACacheStipple()\n");
-        return pCachePriv->Info128;
-    }
-
-    pCache = cacheRoot;
-    /* lets look for it */
-    if (bg == -1)
-        for (i = 0; i < max; i++, pCache++) {
-            if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
-                (fg == pCache->fg) && (pCache->fg != pCache->bg)) {
-                pCache->trans_color = pCache->bg;
-                return pCache;
-            }
-        }
-    else
-        for (i = 0; i < max; i++, pCache++) {
-            if ((pCache->serialNumber == pPix->drawable.serialNumber) &&
-                (fg == pCache->fg) && (bg == pCache->bg)) {
-                pCache->trans_color = -1;
-                return pCache;
-            }
-        }
-
-    pCache = &cacheRoot[(*current)++];
-    if (*current >= max)
-        *current = 0;
-
-    pCache->serialNumber = pPix->drawable.serialNumber;
-    pCache->fg = fg;
-    if (bg == -1)
-        pCache->trans_color = bg = fg ^ 1;
-    else
-        pCache->trans_color = -1;
-    pCache->bg = bg;
-
-    pCache->orig_w = w;
-    pCache->orig_h = h;
-    (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
-                                    pPix->drawable.width, pPix->drawable.height,
-                                    pPix->devPrivate.ptr, pPix->devKind, fg,
-                                    bg);
-    if (!(infoRec->PixmapCacheFlags & DO_NOT_TILE_COLOR_DATA) &&
-        ((w != pCache->w) || (h != pCache->h)))
-        XAATileCache(pScrn, pCache, w, h);
-
-    return pCache;
-}
-
-XAACacheInfoPtr
-XAACacheMono8x8Pattern(ScrnInfoPtr pScrn, int pat0, int pat1)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache = pCachePriv->InfoMono;
-    int i;
-
-    for (i = 0; i < pCachePriv->NumMono; i++, pCache++) {
-        if (pCache->serialNumber &&
-            (pCache->pat0 == pat0) && (pCache->pat1 == pat1))
-            return pCache;
-    }
-
-    /* OK, let's cache it */
-    pCache = &pCachePriv->InfoMono[pCachePriv->CurrentMono++];
-    if (pCachePriv->CurrentMono >= pCachePriv->NumMono)
-        pCachePriv->CurrentMono = 0;
-
-    pCache->serialNumber = 1;   /* we don't care since we do lookups by pattern */
-    pCache->pat0 = pat0;
-    pCache->pat1 = pat1;
-
-    (*infoRec->WriteMono8x8PatternToCache) (pScrn, pCache);
-
-    return pCache;
-}
-
-XAACacheInfoPtr
-XAACacheColor8x8Pattern(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    XAACacheInfoPtr pCache = pCachePriv->InfoColor;
-    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-    int i;
-
-    if (!(pixPriv->flags & REDUCIBLE_TO_2_COLOR)) {
-        for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
-            if (pCache->serialNumber == pPix->drawable.serialNumber) {
-                pCache->trans_color = -1;
-                return pCache;
-            }
-        }
-        pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++];
-        if (pCachePriv->CurrentColor >= pCachePriv->NumColor)
-            pCachePriv->CurrentColor = 0;
-
-        pCache->serialNumber = pPix->drawable.serialNumber;
-        pCache->trans_color = pCache->fg = pCache->bg = -1;
-    }
-    else {
-        int pat0 = pixPriv->pattern0;
-        int pat1 = pixPriv->pattern1;
-
-        if (fg == -1) {         /* it's a tile */
-            fg = pixPriv->fg;
-            bg = pixPriv->bg;
-        }
-
-        if (bg == -1) {         /* stipple */
-            for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
-                if (pCache->serialNumber &&
-                    (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&
-                    (pCache->fg == fg) && (pCache->bg != fg)) {
-                    pCache->trans_color = pCache->bg;
-                    return pCache;
-                }
-            }
-        }
-        else {                  /* opaque stipple */
-            for (i = 0; i < pCachePriv->NumColor; i++, pCache++) {
-                if (pCache->serialNumber &&
-                    (pCache->pat0 == pat0) && (pCache->pat1 == pat1) &&
-                    (pCache->fg == fg) && (pCache->bg == bg)) {
-                    pCache->trans_color = -1;
-                    return pCache;
-                }
-            }
-        }
-        pCache = &pCachePriv->InfoColor[pCachePriv->CurrentColor++];
-        if (pCachePriv->CurrentColor >= pCachePriv->NumColor)
-            pCachePriv->CurrentColor = 0;
-
-        if (bg == -1)
-            pCache->trans_color = bg = fg ^ 1;
-        else
-            pCache->trans_color = -1;
-
-        pCache->pat0 = pat0;
-        pCache->pat1 = pat1;
-        pCache->fg = fg;
-        pCache->bg = bg;
-        pCache->serialNumber = 1;
-    }
-
-    (*infoRec->WriteColor8x8PatternToCache) (pScrn, pPix, pCache);
-
-    return pCache;
-}
-
-void
-XAAWriteBitmapToCache(ScrnInfoPtr pScrn,
-                      int x, int y, int w, int h,
-                      unsigned char *src, int srcwidth, int fg, int bg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->WriteBitmap) (pScrn, x, y, w, h, src, srcwidth,
-                             0, fg, bg, GXcopy, ~0);
-}
-
-void
-XAAWriteBitmapToCacheLinear(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h,
-                            unsigned char *src, int srcwidth, int fg, int bg)
-{
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    PixmapPtr pScreenPix, pDstPix;
-    ChangeGCVal gcvals[2];
-    GCPtr pGC;
-
-    pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
-
-    pDstPix = GetScratchPixmapHeader(pScreen, pScreenPix->drawable.width,
-                                     y + h, pScreenPix->drawable.depth,
-                                     pScreenPix->drawable.bitsPerPixel,
-                                     pScreenPix->devKind,
-                                     pScreenPix->devPrivate.ptr);
-
-    pGC = GetScratchGC(pScreenPix->drawable.depth, pScreen);
-    gcvals[0].val = fg;
-    gcvals[1].val = bg;
-    ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcvals);
-    ValidateGC((DrawablePtr) pDstPix, pGC);
-
-    /* We've unwrapped already so these ops miss a sync */
-    SYNC_CHECK(pScrn);
-
-    (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, 1, x, y, w, h, 0,
-                           XYBitmap, (pointer) src);
-
-    FreeScratchGC(pGC);
-    FreeScratchPixmapHeader(pDstPix);
-}
-
-void
-XAAWritePixmapToCache(ScrnInfoPtr pScrn,
-                      int x, int y, int w, int h,
-                      unsigned char *src, int srcwidth, int bpp, int depth)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->WritePixmap) (pScrn, x, y, w, h, src, srcwidth,
-                             GXcopy, ~0, -1, bpp, depth);
-}
-
-void
-XAAWritePixmapToCacheLinear(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h,
-                            unsigned char *src,
-                            int srcwidth, int bpp, int depth)
-{
-    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
-    PixmapPtr pScreenPix, pDstPix;
-    GCPtr pGC;
-
-    pScreenPix = (*pScreen->GetScreenPixmap) (pScreen);
-
-    pDstPix = GetScratchPixmapHeader(pScreen, x + w, y + h,
-                                     depth, bpp, pScreenPix->devKind,
-                                     pScreenPix->devPrivate.ptr);
-
-    pGC = GetScratchGC(depth, pScreen);
-    ValidateGC((DrawablePtr) pDstPix, pGC);
-
-    /* We've unwrapped already so these ops miss a sync */
-    SYNC_CHECK(pScrn);
-
-    if (bpp == BitsPerPixel(depth))
-        (*pGC->ops->PutImage) ((DrawablePtr) pDstPix, pGC, depth, x, y, w,
-                               h, 0, ZPixmap, (pointer) src);
-    else {
-        PixmapPtr pSrcPix;
-
-        pSrcPix = GetScratchPixmapHeader(pScreen, w, h, depth, bpp,
-                                         srcwidth, (pointer) src);
-
-        (*pGC->ops->CopyArea) ((DrawablePtr) pSrcPix, (DrawablePtr) pDstPix,
-                               pGC, 0, 0, w, h, x, y);
-
-        FreeScratchPixmapHeader(pSrcPix);
-    }
-
-    FreeScratchGC(pGC);
-    FreeScratchPixmapHeader(pDstPix);
-}
-
-void
-XAAWriteMono8x8PatternToCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    unsigned char *data;
-    int pad, Bpp = (pScrn->bitsPerPixel >> 3);
-
-    pCache->offsets = pCachePriv->MonoOffsets;
-
-    pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);
-
-    data = (unsigned char *) malloc(pad * pCache->h);
-    if (!data)
-        return;
-
-    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
-        CARD32 *ptr = (CARD32 *) data;
-
-        ptr[0] = pCache->pat0;
-        ptr[1] = pCache->pat1;
-    }
-    else {
-        CARD32 *ptr;
-        DDXPointPtr pPoint = pCache->offsets;
-        int patx, paty, i;
-
-        for (i = 0; i < 64; i++, pPoint++) {
-            patx = pCache->pat0;
-            paty = pCache->pat1;
-            XAARotateMonoPattern(&patx, &paty, i & 0x07, i >> 3,
-                                 (infoRec->Mono8x8PatternFillFlags &
-                                  BIT_ORDER_IN_BYTE_MSBFIRST));
-            ptr = (CARD32 *) (data + (pad * pPoint->y) + (Bpp * pPoint->x));
-            ptr[0] = patx;
-            ptr[1] = paty;
-        }
-    }
-
-    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y,
-                                    pCache->w, pCache->h, data, pad,
-                                    pScrn->bitsPerPixel, pScrn->depth);
-
-    free(data);
-}
-
-void
-XAAWriteColor8x8PatternToCache(ScrnInfoPtr pScrn,
-                               PixmapPtr pPix, XAACacheInfoPtr pCache)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    int pad, i, w, h, nw, nh, Bpp;
-    unsigned char *data, *srcPtr, *dstPtr;
-
-    pCache->offsets = pCachePriv->ColorOffsets;
-
-    if (pixPriv->flags & REDUCIBLE_TO_2_COLOR) {
-        CARD32 *ptr;
-
-        pad = BitmapBytePad(pCache->w);
-        data = (unsigned char *) malloc(pad * pCache->h);
-        if (!data)
-            return;
-
-        if (infoRec->Color8x8PatternFillFlags &
-            HARDWARE_PATTERN_PROGRAMMED_ORIGIN) {
-            ptr = (CARD32 *) data;
-            ptr[0] = pCache->pat0;
-            ptr[1] = pCache->pat1;
-        }
-        else {
-            int patx, paty;
-
-            ptr = (CARD32 *) data;
-            ptr[0] = ptr[2] = pCache->pat0;
-            ptr[1] = ptr[3] = pCache->pat1;
-            for (i = 1; i < 8; i++) {
-                patx = pCache->pat0;
-                paty = pCache->pat1;
-                XAARotateMonoPattern(&patx, &paty, i, 0,
-                                     (infoRec->Mono8x8PatternFillFlags &
-                                      BIT_ORDER_IN_BYTE_MSBFIRST));
-                ptr = (CARD32 *) (data + (pad * i));
-                ptr[0] = ptr[2] = patx;
-                ptr[1] = ptr[3] = paty;
-            }
-        }
-
-        (*infoRec->WriteBitmapToCache) (pScrn, pCache->x, pCache->y,
-                                        pCache->w, pCache->h, data, pad,
-                                        pCache->fg, pCache->bg);
-
-        free(data);
-        return;
-    }
-
-    Bpp = pScrn->bitsPerPixel >> 3;
-    h = min(8, pPix->drawable.height);
-    w = min(8, pPix->drawable.width);
-    pad = BitmapBytePad(pCache->w * pScrn->bitsPerPixel);
-
-    data = (unsigned char *) malloc(pad * pCache->h);
-    if (!data)
-        return;
-
-    /* Write and expand horizontally. */
-    for (i = h, dstPtr = data, srcPtr = pPix->devPrivate.ptr; i--;
-         srcPtr += pPix->devKind, dstPtr += pScrn->bitsPerPixel) {
-        nw = w;
-        memcpy(dstPtr, srcPtr, w * Bpp);
-        while (nw != 8) {
-            memcpy(dstPtr + (nw * Bpp), dstPtr, nw * Bpp);
-            nw <<= 1;
-        }
-    }
-    nh = h;
-    /* Expand vertically. */
-    while (nh != 8) {
-        memcpy(data + (nh * pScrn->bitsPerPixel), data,
-               nh * pScrn->bitsPerPixel);
-        nh <<= 1;
-    }
-
-    if (!(infoRec->Color8x8PatternFillFlags &
-          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-        int j;
-        unsigned char *ptr = data + (128 * Bpp);
-
-        memcpy(data + (64 * Bpp), data, 64 * Bpp);
-        for (i = 1; i < 8; i++, ptr += (128 * Bpp)) {
-            for (j = 0; j < 8; j++) {
-                memcpy(ptr + (j * 8) * Bpp, data + (j * 8 + i) * Bpp,
-                       (8 - i) * Bpp);
-                memcpy(ptr + (j * 8 + 8 - i) * Bpp, data + j * 8 * Bpp,
-                       i * Bpp);
-            }
-            memcpy(ptr + (64 * Bpp), ptr, 64 * Bpp);
-        }
-    }
-
-    (*infoRec->WritePixmapToCache) (pScrn, pCache->x, pCache->y,
-                                    pCache->w, pCache->h, data, pad,
-                                    pScrn->bitsPerPixel, pScrn->depth);
-
-    free(data);
-}
-
-int
-XAAStippledFillChooser(GCPtr pGC)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    PixmapPtr pPixmap = pGC->stipple;
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
-
-    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
-        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
-        XAACheckStippleReducibility(pPixmap);
-    }
-
-    if (pPriv->flags & REDUCIBLE_TO_8x8) {
-        if (infoRec->CanDoMono8x8 &&
-            !(infoRec->FillMono8x8PatternSpansFlags & NO_TRANSPARENCY) &&
-            ((pGC->alu == GXcopy) || !(infoRec->FillMono8x8PatternSpansFlags &
-                                       TRANSPARENCY_GXCOPY_ONLY)) &&
-            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_FG(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
-
-            return DO_MONO_8x8;
-        }
-
-        if (infoRec->CanDoColor8x8 &&
-            !(infoRec->FillColor8x8PatternSpansFlags & NO_TRANSPARENCY) &&
-            ((pGC->alu == GXcopy) || !(infoRec->FillColor8x8PatternSpansFlags &
-                                       TRANSPARENCY_GXCOPY_ONLY)) &&
-            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
-
-            return DO_COLOR_8x8;
-        }
-    }
-
-    if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans &&
-        (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&
-        (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /
-         infoRec->CacheColorExpandDensity) &&
-        !(infoRec->FillCacheExpandSpansFlags & NO_TRANSPARENCY) &&
-        ((pGC->alu == GXcopy) || !(infoRec->FillCacheExpandSpansFlags &
-                                   TRANSPARENCY_GXCOPY_ONLY)) &&
-        CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_FG(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) {
-
-        return DO_CACHE_EXPAND;
-    }
-
-    if (infoRec->UsingPixmapCache &&
-        !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) &&
-        infoRec->FillCacheBltSpans &&
-        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
-        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
-        !(infoRec->FillCacheBltSpansFlags & NO_TRANSPARENCY) &&
-        ((pGC->alu == GXcopy) || !(infoRec->FillCacheBltSpansFlags &
-                                   TRANSPARENCY_GXCOPY_ONLY)) &&
-        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
-
-        return DO_CACHE_BLT;
-    }
-
-    if (infoRec->FillColorExpandSpans &&
-        !(infoRec->FillColorExpandSpansFlags & NO_TRANSPARENCY) &&
-        ((pGC->alu == GXcopy) || !(infoRec->FillColorExpandSpansFlags &
-                                   TRANSPARENCY_GXCOPY_ONLY)) &&
-        CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_FG(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) {
-
-        return DO_COLOR_EXPAND;
-    }
-
-    return 0;
-}
-
-int
-XAAOpaqueStippledFillChooser(GCPtr pGC)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    PixmapPtr pPixmap = pGC->stipple;
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
-
-    if (XAA_DEPTH_BUG(pGC))
-        return 0;
-
-    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
-        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
-        XAACheckStippleReducibility(pPixmap);
-    }
-
-    if (pPriv->flags & REDUCIBLE_TO_8x8) {
-        if (infoRec->CanDoMono8x8 &&
-            !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) &&
-            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_COLORS(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
-
-            return DO_MONO_8x8;
-        }
-
-        if (infoRec->CanDoColor8x8 &&
-            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
-
-            return DO_COLOR_8x8;
-        }
-    }
-
-    if (infoRec->UsingPixmapCache && infoRec->FillCacheExpandSpans &&
-        (pPixmap->drawable.height <= infoRec->MaxCacheableStippleHeight) &&
-        (pPixmap->drawable.width <= infoRec->MaxCacheableStippleWidth /
-         infoRec->CacheColorExpandDensity) &&
-        !(infoRec->FillCacheExpandSpansFlags & TRANSPARENCY_ONLY) &&
-        CHECK_ROP(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_COLORS(pGC, infoRec->FillCacheExpandSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheExpandSpansFlags)) {
-
-        return DO_CACHE_EXPAND;
-    }
-
-    if (infoRec->UsingPixmapCache &&
-        !(infoRec->PixmapCacheFlags & DO_NOT_BLIT_STIPPLES) &&
-        infoRec->FillCacheBltSpans &&
-        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
-        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
-        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
-
-        return DO_CACHE_BLT;
-    }
-
-    if (infoRec->FillColorExpandSpans &&
-        !(infoRec->FillColorExpandSpansFlags & TRANSPARENCY_ONLY) &&
-        CHECK_ROP(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_COLORS(pGC, infoRec->FillColorExpandSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillColorExpandSpansFlags)) {
-
-        return DO_COLOR_EXPAND;
-    }
-
-    return 0;
-}
-
-int
-XAATiledFillChooser(GCPtr pGC)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    PixmapPtr pPixmap = pGC->tile.pixmap;
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPixmap);
-
-    if (IS_OFFSCREEN_PIXMAP(pPixmap) && infoRec->FillCacheBltSpans &&
-        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
-
-        return DO_PIXMAP_COPY;
-    }
-
-    if (!(pPriv->flags & REDUCIBILITY_CHECKED) &&
-        (infoRec->CanDoMono8x8 || infoRec->CanDoColor8x8)) {
-        XAACheckTileReducibility(pPixmap, infoRec->CanDoMono8x8);
-    }
-
-    if (pPriv->flags & REDUCIBLE_TO_8x8) {
-        if ((pPriv->flags & REDUCIBLE_TO_2_COLOR) && infoRec->CanDoMono8x8 &&
-            !(infoRec->FillMono8x8PatternSpansFlags & TRANSPARENCY_ONLY) &&
-            CHECK_ROP(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillMono8x8PatternSpansFlags) &&
-            (!(infoRec->FillMono8x8PatternSpansFlags & RGB_EQUAL) ||
-             (CHECK_RGB_EQUAL(pPriv->fg) && CHECK_RGB_EQUAL(pPriv->bg))) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillMono8x8PatternSpansFlags)) {
-
-            return DO_MONO_8x8;
-        }
-
-        if (infoRec->CanDoColor8x8 &&
-            CHECK_ROP(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillColor8x8PatternSpansFlags) &&
-            CHECK_PLANEMASK(pGC, infoRec->FillColor8x8PatternSpansFlags)) {
-
-            return DO_COLOR_8x8;
-        }
-    }
-
-    if (infoRec->UsingPixmapCache && infoRec->FillCacheBltSpans &&
-        (pPixmap->drawable.height <= infoRec->MaxCacheableTileHeight) &&
-        (pPixmap->drawable.width <= infoRec->MaxCacheableTileWidth) &&
-        CHECK_ROP(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillCacheBltSpansFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillCacheBltSpansFlags)) {
-
-        return DO_CACHE_BLT;
-    }
-
-    if (infoRec->FillImageWriteRects &&
-        CHECK_NO_GXCOPY(pGC, infoRec->FillImageWriteRectsFlags) &&
-        CHECK_ROP(pGC, infoRec->FillImageWriteRectsFlags) &&
-        CHECK_ROPSRC(pGC, infoRec->FillImageWriteRectsFlags) &&
-        CHECK_PLANEMASK(pGC, infoRec->FillImageWriteRectsFlags)) {
-
-        return DO_IMAGE_WRITE;
-    }
-
-    return 0;
-}
-
-static int RotateMasksX[8] = {
-    0xFFFFFFFF, 0x7F7F7F7F, 0x3F3F3F3F, 0x1F1F1F1F,
-    0x0F0F0F0F, 0x07070707, 0x03030303, 0x01010101
-};
-
-static int RotateMasksY[4] = {
-    0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF
-};
-
-void
-XAARotateMonoPattern(int *pat0, int *pat1, int xorg, int yorg, Bool msbfirst)
-{
-    int tmp, mask;
-
-    if (xorg) {
-        if (msbfirst)
-            xorg = 8 - xorg;
-        mask = RotateMasksX[xorg];
-        *pat0 = ((*pat0 >> xorg) & mask) | ((*pat0 << (8 - xorg)) & ~mask);
-        *pat1 = ((*pat1 >> xorg) & mask) | ((*pat1 << (8 - xorg)) & ~mask);
-    }
-    if (yorg >= 4) {
-        tmp = *pat0;
-        *pat0 = *pat1;
-        *pat1 = tmp;
-        yorg -= 4;
-    }
-    if (yorg) {
-        mask = RotateMasksY[yorg];
-        yorg <<= 3;
-        tmp = *pat0;
-        *pat0 = ((*pat0 >> yorg) & mask) | ((*pat1 << (32 - yorg)) & ~mask);
-        *pat1 = ((*pat1 >> yorg) & mask) | ((tmp << (32 - yorg)) & ~mask);
-    }
-}
-
-void
-XAAInvalidatePixmapCache(ScreenPtr pScreen)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAPixmapCachePrivatePtr pCachePriv =
-        (XAAPixmapCachePrivatePtr) infoRec->PixmapCachePrivate;
-    int i;
-
-    if (!pCachePriv)
-        return;
-
-    for (i = 0; i < pCachePriv->Num512x512; i++)
-        (pCachePriv->Info512)[i].serialNumber = 0;
-    for (i = 0; i < pCachePriv->Num256x256; i++)
-        (pCachePriv->Info256)[i].serialNumber = 0;
-    for (i = 0; i < pCachePriv->Num128x128; i++)
-        (pCachePriv->Info128)[i].serialNumber = 0;
-    for (i = 0; i < pCachePriv->NumPartial; i++)
-        (pCachePriv->InfoPartial)[i].serialNumber = 0;
-    for (i = 0; i < pCachePriv->NumMono; i++)
-        (pCachePriv->InfoMono)[i].serialNumber = 0;
-    for (i = 0; i < pCachePriv->NumColor; i++)
-        (pCachePriv->InfoColor)[i].serialNumber = 0;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaPict.c b/xorg-server/hw/xfree86/xaa/xaaPict.c
deleted file mode 100644
index 0721768ed..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaPict.c
+++ /dev/null
@@ -1,654 +0,0 @@
-/*
- *
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <string.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "picturestr.h"
-#include "glyphstr.h"
-#include "picture.h"
-#include "mipict.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "xaacexp.h"
-#include "xf86fbman.h"
-#include "servermd.h"
-
-Bool
-XAAGetPixelFromRGBA(CARD32 *pixel,
-                    CARD16 red,
-                    CARD16 green, CARD16 blue, CARD16 alpha, CARD32 format)
-{
-    int rbits, bbits, gbits, abits;
-    int rshift, bshift, gshift, ashift;
-
-    *pixel = 0;
-
-    if (!PICT_FORMAT_COLOR(format))
-        return FALSE;
-
-    rbits = PICT_FORMAT_R(format);
-    gbits = PICT_FORMAT_G(format);
-    bbits = PICT_FORMAT_B(format);
-    abits = PICT_FORMAT_A(format);
-
-    if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) {
-        bshift = 0;
-        gshift = bbits;
-        rshift = gshift + gbits;
-        ashift = rshift + rbits;
-    }
-    else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ABGR) {
-        rshift = 0;
-        gshift = rbits;
-        bshift = gshift + gbits;
-        ashift = bshift + bbits;
-    }
-    else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_BGRA) {
-        bshift = PICT_FORMAT_BPP(format) - bbits;
-        gshift = bshift - gbits;
-        rshift = gshift - rbits;
-        ashift = 0;
-    }
-    else
-        return FALSE;
-
-    *pixel |= (blue >> (16 - bbits)) << bshift;
-    *pixel |= (red >> (16 - rbits)) << rshift;
-    *pixel |= (green >> (16 - gbits)) << gshift;
-    *pixel |= (alpha >> (16 - abits)) << ashift;
-
-    return TRUE;
-}
-
-Bool
-XAAGetRGBAFromPixel(CARD32 pixel,
-                    CARD16 *red,
-                    CARD16 *green, CARD16 *blue, CARD16 *alpha, CARD32 format)
-{
-    int rbits, bbits, gbits, abits;
-    int rshift, bshift, gshift, ashift;
-
-    if (!PICT_FORMAT_COLOR(format))
-        return FALSE;
-
-    rbits = PICT_FORMAT_R(format);
-    gbits = PICT_FORMAT_G(format);
-    bbits = PICT_FORMAT_B(format);
-    abits = PICT_FORMAT_A(format);
-
-    if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) {
-        bshift = 0;
-        gshift = bbits;
-        rshift = gshift + gbits;
-        ashift = rshift + rbits;
-    }
-    else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ABGR) {
-        rshift = 0;
-        gshift = rbits;
-        bshift = gshift + gbits;
-        ashift = bshift + bbits;
-    }
-    else if (PICT_FORMAT_TYPE(format) == PICT_TYPE_BGRA) {
-        bshift = PICT_FORMAT_BPP(format) - bbits;
-        gshift = bshift - gbits;
-        rshift = gshift - rbits;
-        ashift = 0;
-    }
-    else
-        return FALSE;
-
-    *red = ((pixel >> rshift) & ((1 << rbits) - 1)) << (16 - rbits);
-    while (rbits < 16) {
-        *red |= *red >> rbits;
-        rbits <<= 1;
-    }
-
-    *green = ((pixel >> gshift) & ((1 << gbits) - 1)) << (16 - gbits);
-    while (gbits < 16) {
-        *green |= *green >> gbits;
-        gbits <<= 1;
-    }
-
-    *blue = ((pixel >> bshift) & ((1 << bbits) - 1)) << (16 - bbits);
-    while (bbits < 16) {
-        *blue |= *blue >> bbits;
-        bbits <<= 1;
-    }
-
-    if (abits) {
-        *alpha = ((pixel >> ashift) & ((1 << abits) - 1)) << (16 - abits);
-        while (abits < 16) {
-            *alpha |= *alpha >> abits;
-            abits <<= 1;
-        }
-    }
-    else
-        *alpha = 0xffff;
-
-    return TRUE;
-}
-
-/* 8:8:8 + PICT_a8 -> 8:8:8:8 texture */
-
-void
-XAA_888_plus_PICT_a8_to_8888(CARD32 color, CARD8 *alphaPtr,     /* in bytes */
-                             int alphaPitch, CARD32 *dstPtr, int dstPitch,      /* in dwords */
-                             int width, int height)
-{
-    int x;
-
-    color &= 0x00ffffff;
-
-    while (height--) {
-        for (x = 0; x < width; x++)
-            dstPtr[x] = color | (alphaPtr[x] << 24);
-        dstPtr += dstPitch;
-        alphaPtr += alphaPitch;
-    }
-}
-
-#define DRAWABLE_IS_ON_CARD(pDraw) \
-    (pDraw->type == DRAWABLE_WINDOW || \
-     (pDraw->type == DRAWABLE_PIXMAP && IS_OFFSCREEN_PIXMAP(pDraw)))
-
-Bool
-XAADoComposite(CARD8 op,
-               PicturePtr pSrc,
-               PicturePtr pMask,
-               PicturePtr pDst,
-               INT16 xSrc,
-               INT16 ySrc,
-               INT16 xMask,
-               INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    RegionRec region;
-    CARD32 *formats, *dstformats;
-    int flags = 0;
-    BoxPtr pbox;
-    int nbox, w, h;
-
-    if (!RegionNumRects(pDst->pCompositeClip))
-        return TRUE;
-
-    if (!infoRec->pScrn->vtSema || !DRAWABLE_IS_ON_CARD(pDst->pDrawable))
-        return FALSE;
-
-    if (DRAWABLE_IS_ON_CARD(pSrc->pDrawable))
-        return FALSE;
-
-    if (pSrc->transform || (pMask && pMask->transform))
-        return FALSE;
-
-    if (pDst->alphaMap || pSrc->alphaMap || (pMask && pMask->alphaMap))
-        return FALSE;
-
-    if ((pSrc->repeat && pSrc->repeatType != RepeatNormal) ||
-        (pMask && pMask->repeat && pMask->repeatType != RepeatNormal)) {
-        return FALSE;
-    }
-
-    xDst += pDst->pDrawable->x;
-    yDst += pDst->pDrawable->y;
-    xSrc += pSrc->pDrawable->x;
-    ySrc += pSrc->pDrawable->y;
-
-    if (pMask) {
-        if (pMask->componentAlpha)
-            return FALSE;
-
-        /* for now we only do it if there is a 1x1 (solid) source */
-
-        if ((pSrc->pDrawable->width == 1) && (pSrc->pDrawable->height == 1)) {
-            CARD16 red, green, blue, alpha;
-            CARD32 pixel =
-                *((CARD32 *) (((PixmapPtr) (pSrc->pDrawable))->devPrivate.ptr));
-
-            if (!XAAGetRGBAFromPixel
-                (pixel, &red, &green, &blue, &alpha, pSrc->format))
-                return FALSE;
-
-            xMask += pMask->pDrawable->x;
-            yMask += pMask->pDrawable->y;
-
-            /* pull out color expandable operations here */
-            if ((pMask->format == PICT_a1) && (alpha == 0xffff) &&
-                (op == PictOpOver) && infoRec->WriteBitmap && !pMask->repeat &&
-                !(infoRec->WriteBitmapFlags & NO_TRANSPARENCY) &&
-                (!(infoRec->WriteBitmapFlags & RGB_EQUAL) ||
-                 ((red == green) && (green == blue)))) {
-                PixmapPtr pPix = (PixmapPtr) (pMask->pDrawable);
-                int skipleft;
-
-                if (!miComputeCompositeRegion(&region, pSrc, pMask, pDst,
-                                              xSrc, ySrc, xMask, yMask, xDst,
-                                              yDst, width, height))
-                    return TRUE;
-
-                nbox = RegionNumRects(&region);
-                pbox = RegionRects(&region);
-
-                if (!nbox)
-                    return TRUE;
-
-                XAAGetPixelFromRGBA(&pixel, red, green, blue, 0, pDst->format);
-
-                xMask -= xDst;
-                yMask -= yDst;
-
-                while (nbox--) {
-                    skipleft = pbox->x1 + xMask;
-
-                    (*infoRec->WriteBitmap) (infoRec->pScrn,
-                                             pbox->x1, pbox->y1,
-                                             pbox->x2 - pbox->x1,
-                                             pbox->y2 - pbox->y1,
-                                             (unsigned char *) (pPix->
-                                                                devPrivate.
-                                                                ptr) +
-                                             (pPix->devKind *
-                                              (pbox->y1 + yMask)) +
-                                             ((skipleft >> 3) & ~3),
-                                             pPix->devKind, skipleft & 31,
-                                             pixel, -1, GXcopy, ~0);
-                    pbox++;
-                }
-
-                /* WriteBitmap sets the Sync flag */
-                RegionUninit(&region);
-                return TRUE;
-            }
-
-            formats = infoRec->CPUToScreenAlphaTextureFormats;
-            dstformats = infoRec->CPUToScreenAlphaTextureDstFormats;
-            if (!formats || !dstformats)
-                return FALSE;
-
-            w = pMask->pDrawable->width;
-            h = pMask->pDrawable->height;
-
-            if (pMask->repeat) {
-                if ((infoRec->CPUToScreenAlphaTextureFlags & XAA_RENDER_NO_TILE)
-                    ||
-                    ((infoRec->
-                      CPUToScreenAlphaTextureFlags &
-                      XAA_RENDER_POWER_OF_2_TILE_ONLY) && ((h & (h - 1)) ||
-                                                           (w & (w - 1))))) {
-                    return FALSE;
-                }
-                flags |= XAA_RENDER_REPEAT;
-            }
-
-            if ((alpha != 0xffff) &&
-                (infoRec->
-                 CPUToScreenAlphaTextureFlags & XAA_RENDER_NO_SRC_ALPHA))
-                return FALSE;
-
-            while (*formats != pMask->format) {
-                if (!(*formats))
-                    return FALSE;
-                formats++;
-            }
-            while (*dstformats != pDst->format) {
-                if (!(*dstformats))
-                    return FALSE;
-                dstformats++;
-            }
-
-            if (!miComputeCompositeRegion(&region, pSrc, pMask, pDst,
-                                          xSrc, ySrc, xMask, yMask, xDst, yDst,
-                                          width, height))
-                return TRUE;
-
-            nbox = RegionNumRects(&region);
-            pbox = RegionRects(&region);
-
-            if (!nbox) {
-                RegionUninit(&region);
-                return TRUE;
-            }
-
-            if (!(infoRec->SetupForCPUToScreenAlphaTexture2) (infoRec->pScrn,
-                                                              op, red, green,
-                                                              blue, alpha,
-                                                              pMask->format,
-                                                              pDst->format,
-                                                              ((PixmapPtr)
-                                                               (pMask->
-                                                                pDrawable))->
-                                                              devPrivate.ptr,
-                                                              ((PixmapPtr)
-                                                               (pMask->
-                                                                pDrawable))->
-                                                              devKind, w, h,
-                                                              flags)) {
-                RegionUninit(&region);
-                return FALSE;
-            }
-
-            xMask -= xDst;
-            yMask -= yDst;
-
-            while (nbox--) {
-                (*infoRec->SubsequentCPUToScreenAlphaTexture) (infoRec->pScrn,
-                                                               pbox->x1,
-                                                               pbox->y1,
-                                                               pbox->x1 + xMask,
-                                                               pbox->y1 + yMask,
-                                                               pbox->x2 -
-                                                               pbox->x1,
-                                                               pbox->y2 -
-                                                               pbox->y1);
-                pbox++;
-            }
-
-            SET_SYNC_FLAG(infoRec);
-            RegionUninit(&region);
-            return TRUE;
-        }
-    }
-    else {
-        formats = infoRec->CPUToScreenTextureFormats;
-        dstformats = infoRec->CPUToScreenTextureDstFormats;
-        if (!formats || !dstformats)
-            return FALSE;
-
-        w = pSrc->pDrawable->width;
-        h = pSrc->pDrawable->height;
-
-        if (pSrc->repeat) {
-            if ((infoRec->CPUToScreenTextureFlags & XAA_RENDER_NO_TILE) ||
-                ((infoRec->CPUToScreenTextureFlags &
-                  XAA_RENDER_POWER_OF_2_TILE_ONLY) &&
-                 ((h & (h - 1)) || (w & (w - 1))))) {
-                return FALSE;
-            }
-            flags |= XAA_RENDER_REPEAT;
-        }
-
-        while (*formats != pSrc->format) {
-            if (!(*formats))
-                return FALSE;
-            formats++;
-        }
-        while (*dstformats != pDst->format) {
-            if (!(*dstformats))
-                return FALSE;
-            dstformats++;
-        }
-
-        if (!miComputeCompositeRegion(&region, pSrc, pMask, pDst,
-                                      xSrc, ySrc, xMask, yMask, xDst, yDst,
-                                      width, height))
-            return TRUE;
-
-        nbox = RegionNumRects(&region);
-        pbox = RegionRects(&region);
-
-        if (!nbox) {
-            RegionUninit(&region);
-            return TRUE;
-        }
-
-        if (!(infoRec->SetupForCPUToScreenTexture2) (infoRec->pScrn,
-                                                     op, pSrc->format,
-                                                     pDst->format,
-                                                     ((PixmapPtr)
-                                                      (pSrc->pDrawable))->
-                                                     devPrivate.ptr,
-                                                     ((PixmapPtr)
-                                                      (pSrc->pDrawable))->
-                                                     devKind, w, h, flags)) {
-            RegionUninit(&region);
-            return FALSE;
-        }
-
-        xSrc -= xDst;
-        ySrc -= yDst;
-
-        while (nbox--) {
-            (*infoRec->SubsequentCPUToScreenTexture) (infoRec->pScrn,
-                                                      pbox->x1, pbox->y1,
-                                                      pbox->x1 + xSrc,
-                                                      pbox->y1 + ySrc,
-                                                      pbox->x2 - pbox->x1,
-                                                      pbox->y2 - pbox->y1);
-            pbox++;
-        }
-
-        SET_SYNC_FLAG(infoRec);
-        RegionUninit(&region);
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-static void
-XAACompositeSrcCopy(PicturePtr pSrc,
-                    PicturePtr pDst,
-                    INT16 xSrc,
-                    INT16 ySrc,
-                    INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    int i, nbox;
-    int xoff, yoff;
-    BoxPtr pbox;
-    DDXPointPtr pptSrc;
-    RegionRec region;
-
-    xDst += pDst->pDrawable->x;
-    yDst += pDst->pDrawable->y;
-    xSrc += pSrc->pDrawable->x;
-    ySrc += pSrc->pDrawable->y;
-
-    if (!miComputeCompositeRegion(&region, pSrc, NULL, pDst,
-                                  xSrc, ySrc, 0, 0, xDst, yDst, width, height))
-        return;
-
-    nbox = RegionNumRects(&region);
-    pbox = RegionRects(&region);
-
-    if (!nbox) {
-        RegionUninit(&region);
-        return;
-    }
-    pptSrc = malloc(sizeof(DDXPointRec) * nbox);
-    if (!pptSrc) {
-        RegionUninit(&region);
-        return;
-    }
-    xoff = xSrc - xDst;
-    yoff = ySrc - yDst;
-    for (i = 0; i < nbox; i++) {
-        pptSrc[i].x = pbox[i].x1 + xoff;
-        pptSrc[i].y = pbox[i].y1 + yoff;
-    }
-
-    infoRec->ScratchGC.planemask = ~0L;
-    infoRec->ScratchGC.alu = GXcopy;
-
-    XAADoBitBlt(pSrc->pDrawable, pDst->pDrawable, &infoRec->ScratchGC, &region,
-                pptSrc);
-
-    free(pptSrc);
-    RegionUninit(&region);
-    return;
-}
-
-void
-XAAComposite(CARD8 op,
-             PicturePtr pSrc,
-             PicturePtr pMask,
-             PicturePtr pDst,
-             INT16 xSrc,
-             INT16 ySrc,
-             INT16 xMask,
-             INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-
-    XAA_RENDER_PROLOGUE(pScreen, Composite);
-
-    if (!pMask && infoRec->pScrn->vtSema &&
-        infoRec->ScreenToScreenBitBlt &&
-        pSrc->pDrawable &&
-        DRAWABLE_IS_ON_CARD(pSrc->pDrawable) &&
-        DRAWABLE_IS_ON_CARD(pDst->pDrawable) &&
-        !pSrc->transform &&
-        (!pSrc->repeat || (xSrc >= 0 && ySrc >= 0 &&
-                           xSrc + width <= pSrc->pDrawable->width &&
-                           ySrc + height <= pSrc->pDrawable->height)) &&
-        ((op == PictOpSrc &&
-          ((pSrc->format == pDst->format) ||
-           (pSrc->format == PICT_a8r8g8b8 && pDst->format == PICT_x8r8g8b8) ||
-           (pSrc->format == PICT_a8b8g8r8 && pDst->format == PICT_x8b8g8r8))) ||
-         (op == PictOpOver && !pSrc->alphaMap && !pDst->alphaMap &&
-          pSrc->format == pDst->format &&
-          (pSrc->format == PICT_x8r8g8b8 || pSrc->format == PICT_x8b8g8r8)))) {
-        XAACompositeSrcCopy(pSrc, pDst, xSrc, ySrc, xDst, yDst, width, height);
-    }
-    else if (!pSrc->pDrawable || (pMask && !pMask->pDrawable) ||
-             !infoRec->Composite ||
-             !(*infoRec->Composite) (op, pSrc, pMask, pDst,
-                                     xSrc, ySrc, xMask, yMask, xDst, yDst,
-                                     width, height)) {
-        if (infoRec->pScrn->vtSema &&
-            ((pSrc->pDrawable &&
-              (pSrc->pDrawable->type == DRAWABLE_WINDOW ||
-               IS_OFFSCREEN_PIXMAP(pSrc->pDrawable))) ||
-             pDst->pDrawable->type == DRAWABLE_WINDOW ||
-             IS_OFFSCREEN_PIXMAP(pDst->pDrawable))) {
-            SYNC_CHECK(pDst->pDrawable);
-        }
-        (*GetPictureScreen(pScreen)->Composite) (op,
-                                                 pSrc,
-                                                 pMask,
-                                                 pDst,
-                                                 xSrc,
-                                                 ySrc,
-                                                 xMask,
-                                                 yMask,
-                                                 xDst, yDst, width, height);
-    }
-
-    if (pDst->pDrawable->type == DRAWABLE_PIXMAP)
-        (XAA_GET_PIXMAP_PRIVATE((PixmapPtr) (pDst->pDrawable)))->flags |= DIRTY;
-
-    XAA_RENDER_EPILOGUE(pScreen, Composite, XAAComposite);
-}
-
-Bool
-XAADoGlyphs(CARD8 op,
-            PicturePtr pSrc,
-            PicturePtr pDst,
-            PictFormatPtr maskFormat,
-            INT16 xSrc,
-            INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-
-    if (!RegionNumRects(pDst->pCompositeClip))
-        return TRUE;
-
-    if (!infoRec->pScrn->vtSema ||
-        ((pDst->pDrawable->type != DRAWABLE_WINDOW) &&
-         !IS_OFFSCREEN_PIXMAP(pDst->pDrawable)))
-        return FALSE;
-
-    if ((pSrc->pDrawable->type != DRAWABLE_PIXMAP) ||
-        IS_OFFSCREEN_PIXMAP(pSrc->pDrawable))
-        return FALSE;
-
-    /*
-     * If it looks like we have a chance of being able to draw these
-     * glyphs with an accelerated Composite, do that now to avoid
-     * unneeded and costly syncs.
-     */
-    if (maskFormat) {
-        if (!infoRec->CPUToScreenAlphaTextureFormats)
-            return FALSE;
-    }
-    else {
-        if (!infoRec->CPUToScreenTextureFormats)
-            return FALSE;
-    }
-
-    miGlyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
-
-    return TRUE;
-}
-
-void
-XAAGlyphs(CARD8 op,
-          PicturePtr pSrc,
-          PicturePtr pDst,
-          PictFormatPtr maskFormat,
-          INT16 xSrc,
-          INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-
-    XAA_RENDER_PROLOGUE(pScreen, Glyphs);
-
-    if (!pSrc->pDrawable || !infoRec->Glyphs ||
-        !(*infoRec->Glyphs) (op, pSrc, pDst, maskFormat,
-                             xSrc, ySrc, nlist, list, glyphs)) {
-        if (infoRec->pScrn->vtSema &&
-            ((pSrc->pDrawable &&
-              (pSrc->pDrawable->type == DRAWABLE_WINDOW ||
-               IS_OFFSCREEN_PIXMAP(pSrc->pDrawable))) ||
-             pDst->pDrawable->type == DRAWABLE_WINDOW ||
-             IS_OFFSCREEN_PIXMAP(pDst->pDrawable))) {
-            SYNC_CHECK(pDst->pDrawable);
-        }
-        (*GetPictureScreen(pScreen)->Glyphs) (op, pSrc, pDst, maskFormat,
-                                              xSrc, ySrc, nlist, list, glyphs);
-    }
-
-    if (pDst->pDrawable->type == DRAWABLE_PIXMAP)
-        (XAA_GET_PIXMAP_PRIVATE((PixmapPtr) (pDst->pDrawable)))->flags |= DIRTY;
-
-    XAA_RENDER_EPILOGUE(pScreen, Glyphs, XAAGlyphs);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaROP.c b/xorg-server/hw/xfree86/xaa/xaaROP.c
deleted file mode 100644
index 3b6ec9385..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaROP.c
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/X.h>
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include "scrnintstr.h"
-#include "xf86str.h"
-#include "xaarop.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-int XAACopyROP[16] = {
-    ROP_0,                      /* GXclear */
-    ROP_DSa,                    /* GXand */
-    ROP_SDna,                   /* GXandReverse */
-    ROP_S,                      /* GXcopy */
-    ROP_DSna,                   /* GXandInverted */
-    ROP_D,                      /* GXnoop */
-    ROP_DSx,                    /* GXxor */
-    ROP_DSo,                    /* GXor */
-    ROP_DSon,                   /* GXnor */
-    ROP_DSxn,                   /* GXequiv */
-    ROP_Dn,                     /* GXinvert */
-    ROP_SDno,                   /* GXorReverse */
-    ROP_Sn,                     /* GXcopyInverted */
-    ROP_DSno,                   /* GXorInverted */
-    ROP_DSan,                   /* GXnand */
-    ROP_1                       /* GXset */
-};
-
-int XAACopyROP_PM[16] = {
-    ROP_0,                      /* not used */
-    ROP_DSPnoa,
-    ROP_DPSnaon,
-    ROP_DPSDxax,
-    ROP_DPSana,
-    ROP_D,                      /* not used */
-    ROP_DPSax,
-    ROP_DPSao,
-    ROP_DPSaon,
-    ROP_DPSaxn,
-    ROP_Dn,                     /* not used */
-    ROP_DPSanan,
-    ROP_PSDPxox,                /* is that correct ? */
-    ROP_DPSnao,
-    ROP_DSPnoan,
-    ROP_1                       /* not used */
-};
-
-int XAAPatternROP[16] = {
-    ROP_0,
-    ROP_DPa,
-    ROP_PDna,
-    ROP_P,
-    ROP_DPna,
-    ROP_D,
-    ROP_DPx,
-    ROP_DPo,
-    ROP_DPon,
-    ROP_PDxn,
-    ROP_Dn,
-    ROP_PDno,
-    ROP_Pn,
-    ROP_DPno,
-    ROP_DPan,
-    ROP_1
-};
-
-int XAAPatternROP_PM[16] = {
-    ROP_DPna,
-    ROP_DPSnoa,
-    ROP_DSPnaon,
-    ROP_DSPDxax,
-    ROP_DPSana,
-    ROP_D,
-    ROP_DPSax,
-    ROP_DPSao,
-    ROP_DPSaon,
-    ROP_DPSaxn,
-    ROP_DPx,
-    ROP_DPSanan,
-    ROP_SPDSxox,                /* is that correct ? */
-    ROP_DSPnao,
-    ROP_DPSnoan,
-    ROP_DPo
-};
-
-int
-XAAGetCopyROP(int i)
-{
-    return XAACopyROP[i];
-}
-
-int
-XAAGetCopyROP_PM(int i)
-{
-    return XAACopyROP_PM[i];
-}
-
-int
-XAAGetPatternROP(int i)
-{
-    return XAAPatternROP[i];
-}
-
-int
-XAAGetPatternROP_PM(int i)
-{
-    return XAAPatternROP_PM[i];
-}
-
-int
-XAAHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int ret = 0;
-
-    pm &= infoRec->FullPlanemasks[pScrn->depth - 1];
-
-    if (pm == infoRec->FullPlanemasks[pScrn->depth - 1]) {
-        if (!NO_SRC_ROP(*rop))
-            ret |= ROP_PAT;
-        *rop = XAAPatternROP[*rop];
-    }
-    else {
-        switch (*rop) {
-        case GXnoop:
-            break;
-        case GXset:
-        case GXclear:
-        case GXinvert:
-            ret |= ROP_PAT;
-            *fg = pm;
-            if (*bg != -1)
-                *bg = pm;
-            break;
-        default:
-            ret |= ROP_PAT | ROP_SRC;
-            break;
-        }
-        *rop = XAAPatternROP_PM[*rop];
-    }
-
-    return ret;
-}
-
-int
-XAAHelpSolidROP(ScrnInfoPtr pScrn, int *fg, int pm, int *rop)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int ret = 0;
-
-    pm &= infoRec->FullPlanemasks[pScrn->depth - 1];
-
-    if (pm == infoRec->FullPlanemasks[pScrn->depth - 1]) {
-        if (!NO_SRC_ROP(*rop))
-            ret |= ROP_PAT;
-        *rop = XAAPatternROP[*rop];
-    }
-    else {
-        switch (*rop) {
-        case GXnoop:
-            break;
-        case GXset:
-        case GXclear:
-        case GXinvert:
-            ret |= ROP_PAT;
-            *fg = pm;
-            break;
-        default:
-            ret |= ROP_PAT | ROP_SRC;
-            break;
-        }
-        *rop = XAAPatternROP_PM[*rop];
-    }
-
-    return ret;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaRect.c b/xorg-server/hw/xfree86/xaa/xaaRect.c
deleted file mode 100644
index 002090085..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaRect.c
+++ /dev/null
@@ -1,121 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-/*
-   Much of this file based on code by 
-	Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
-*/
-
-void
-XAAPolyRectangleThinSolid(DrawablePtr pDrawable,
-                          GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int nClipRects;             /* number of clip rectangles */
-    BoxPtr pClipRects;          /* points to the list of clip rects */
-    int xOrigin;                /* Drawables x origin */
-    int yOrigin;                /* Drawables x origin */
-    xRectangle *pRect;          /* list of rects */
-    int nRects;                 /* running count of number of rects */
-    int origX1, origY1;         /* original rectangle's U/L corner */
-    int origX2, origY2;         /* original rectangle's L/R corner */
-    int clippedX1;              /* clipped rectangle's left x */
-    int clippedY1;              /* clipped rectangle's top y */
-    int clippedX2;              /* clipped rectangle's right x */
-    int clippedY2;              /* clipped rectangle's bottom y */
-    int clipXMin;               /* upper left corner of clip rect */
-    int clipYMin;               /* upper left corner of clip rect */
-    int clipXMax;               /* lower right corner of clip rect */
-    int clipYMax;               /* lower right corner of clip rect */
-    int width, height;          /* width and height of rect */
-
-    nClipRects = RegionNumRects(pGC->pCompositeClip);
-    pClipRects = RegionRects(pGC->pCompositeClip);
-
-    if (!nClipRects)
-        return;
-
-    xOrigin = pDrawable->x;
-    yOrigin = pDrawable->y;
-
-    (*infoRec->SetupForSolidLine) (infoRec->pScrn,
-                                   pGC->fgPixel, pGC->alu, pGC->planemask);
-
-    for (; nClipRects > 0; nClipRects--, pClipRects++) {
-        clipYMin = pClipRects->y1;
-        clipYMax = pClipRects->y2 - 1;
-        clipXMin = pClipRects->x1;
-        clipXMax = pClipRects->x2 - 1;
-
-        for (pRect = pRectsInit, nRects = nRectsInit;
-             nRects > 0; nRects--, pRect++) {
-            /* translate rectangle data over to the drawable */
-            origX1 = pRect->x + xOrigin;
-            origY1 = pRect->y + yOrigin;
-            origX2 = origX1 + pRect->width;
-            origY2 = origY1 + pRect->height;
-
-            /* reject entire rectangle if completely outside clip rect */
-            if ((origX1 > clipXMax) || (origX2 < clipXMin) ||
-                (origY1 > clipYMax) || (origY2 < clipYMin))
-                continue;
-
-            /* clip the rectangle */
-            clippedX1 = max(origX1, clipXMin);
-            clippedX2 = min(origX2, clipXMax);
-            clippedY1 = max(origY1, clipYMin);
-            clippedY2 = min(origY2, clipYMax);
-
-            width = clippedX2 - clippedX1 + 1;
-
-            if (origY1 >= clipYMin) {
-                (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                        clippedX1, clippedY1,
-                                                        width, DEGREES_0);
-
-                /* don't overwrite corner */
-                clippedY1++;
-            }
-
-            if ((origY2 <= clipYMax) && (origY1 != origY2)) {
-                (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                        clippedX1, clippedY2,
-                                                        width, DEGREES_0);
-
-                /* don't overwrite corner */
-                clippedY2--;
-            }
-
-            if (clippedY2 < clippedY1)
-                continue;
-
-            height = clippedY2 - clippedY1 + 1;
-
-            /* draw vertical edges using lines if not clipped out */
-            if (origX1 >= clipXMin)
-                (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                        clippedX1, clippedY1,
-                                                        height, DEGREES_270);
-
-            if ((origX2 <= clipXMax) && (origX2 != origX1))
-                (*infoRec->SubsequentSolidHorVertLine) (infoRec->pScrn,
-                                                        clippedX2, clippedY1,
-                                                        height, DEGREES_270);
-        }
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaSpans.c b/xorg-server/hw/xfree86/xaa/xaaSpans.c
deleted file mode 100644
index f03452a46..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaSpans.c
+++ /dev/null
@@ -1,876 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "mispans.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-static void XAARenderSolidSpans(GCPtr, int, DDXPointPtr, int *, int, int, int);
-static void XAARenderColor8x8Spans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                   int);
-static void XAARenderMono8x8Spans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                  int);
-static void XAARenderCacheBltSpans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                   int);
-static void XAARenderColorExpandSpans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                      int);
-static void XAARenderCacheExpandSpans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                      int);
-static void XAARenderPixmapCopySpans(GCPtr, int, DDXPointPtr, int *, int, int,
-                                     int);
-
-void
-XAAFillSpans(DrawablePtr pDraw, GC * pGC, int nInit,    /* number of spans to fill */
-             DDXPointPtr pptInit,       /* pointer to list of start points */
-             int *pwidthInit,   /* pointer to list of n widths */
-             int fSorted)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int type = 0;
-    ClipAndRenderSpansFunc function;
-    Bool fastClip = FALSE;
-
-    if ((nInit <= 0) || !pGC->planemask)
-        return;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    switch (pGC->fillStyle) {
-    case FillSolid:
-        type = DO_SOLID;
-        break;
-    case FillStippled:
-        type = (*infoRec->StippledFillChooser) (pGC);
-        break;
-    case FillOpaqueStippled:
-        if ((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&
-            CHECK_PLANEMASK(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_ROP(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_ROPSRC(pGC, infoRec->FillSpansSolidFlags) &&
-            CHECK_FG(pGC, infoRec->FillSpansSolidFlags))
-            type = DO_SOLID;
-        else
-            type = (*infoRec->OpaqueStippledFillChooser) (pGC);
-        break;
-    case FillTiled:
-        type = (*infoRec->TiledFillChooser) (pGC);
-        break;
-    }
-
-    switch (type) {
-    case DO_SOLID:
-        function = XAARenderSolidSpans;
-        if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL)
-            fastClip = TRUE;
-        break;
-    case DO_COLOR_8x8:
-        function = XAARenderColor8x8Spans;
-        if (infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL)
-            fastClip = TRUE;
-        break;
-    case DO_MONO_8x8:
-        function = XAARenderMono8x8Spans;
-        if (infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL)
-            fastClip = TRUE;
-        break;
-    case DO_CACHE_BLT:
-        function = XAARenderCacheBltSpans;
-        if (infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-            fastClip = TRUE;
-        break;
-    case DO_COLOR_EXPAND:
-        function = XAARenderColorExpandSpans;
-        break;
-    case DO_CACHE_EXPAND:
-        function = XAARenderCacheExpandSpans;
-        if (infoRec->ClippingFlags &
-            HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND)
-            fastClip = TRUE;
-        break;
-    case DO_PIXMAP_COPY:
-        function = XAARenderPixmapCopySpans;
-        if (infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-            fastClip = TRUE;
-        break;
-    case DO_IMAGE_WRITE:
-    default:
-        (*XAAFallbackOps.FillSpans) (pDraw, pGC, nInit, pptInit,
-                                     pwidthInit, fSorted);
-        return;
-    }
-
-    if ((nInit < 10) || (RegionNumRects(pGC->pCompositeClip) != 1))
-        fastClip = FALSE;
-
-    if (fastClip) {
-        infoRec->ClipBox = &pGC->pCompositeClip->extents;
-        (*function) (pGC, nInit, pptInit, pwidthInit, fSorted,
-                     pDraw->x, pDraw->y);
-        infoRec->ClipBox = NULL;
-    }
-    else
-        XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,
-                              function, pDraw->x, pDraw->y);
-}
-
-        /*********************\
-	|     Solid Spans     |
-	\*********************/
-
-static void
-XAARenderSolidSpans(GCPtr pGC,
-                    int n,
-                    DDXPointPtr ppt,
-                    int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    (*infoRec->FillSolidSpans) (infoRec->pScrn, pGC->fgPixel,
-                                pGC->alu, pGC->planemask, n, ppt, pwidth,
-                                fSorted);
-}
-
-        /************************\
-	|     Mono 8x8 Spans     |
-	\************************/
-
-static void
-XAARenderMono8x8Spans(GCPtr pGC,
-                      int n,
-                      DDXPointPtr ppt,
-                      int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAAPixmapPtr pPriv;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-        fg = pPriv->fg;
-        bg = pPriv->bg;
-        break;
-    default:                   /* Muffle compiler */
-        pPriv = NULL;           /* Kaboom */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillMono8x8PatternSpans) (infoRec->pScrn,
-                                         fg, bg, pGC->alu, pGC->planemask,
-                                         n, ppt, pwidth, fSorted,
-                                         pPriv->pattern0, pPriv->pattern1,
-                                         (xorg + pGC->patOrg.x),
-                                         (yorg + pGC->patOrg.y));
-}
-
-        /*************************\
-	|     Color 8x8 Spans     |
-	\*************************/
-
-static void
-XAARenderColor8x8Spans(GCPtr pGC,
-                       int n,
-                       DDXPointPtr ppt,
-                       int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-    PixmapPtr pPix;
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        pPix = pGC->stipple;
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    case FillTiled:
-        pPix = pGC->tile.pixmap;
-        fg = -1;
-        bg = -1;
-        break;
-    default:                   /* Muffle compiler */
-        pPix = NULL;
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    pCache = (*infoRec->CacheColor8x8Pattern) (infoRec->pScrn, pPix, fg, bg);
-
-    (*infoRec->FillColor8x8PatternSpans) (infoRec->pScrn,
-                                          pGC->alu, pGC->planemask, n, ppt,
-                                          pwidth, fSorted, pCache,
-                                          (yorg + pGC->patOrg.x),
-                                          (xorg + pGC->patOrg.y));
-}
-
-        /****************************\
-	|     Color Expand Spans     |
-	\****************************/
-
-static void
-XAARenderColorExpandSpans(GCPtr pGC,
-                          int n,
-                          DDXPointPtr ppt,
-                          int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillColorExpandSpans) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, n, ppt, pwidth,
-                                      fSorted, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-
-}
-
-        /*************************\
-	|     Cache Blt Spans     |
-	\*************************/
-
-static void
-XAARenderCacheBltSpans(GCPtr pGC,
-                       int n,
-                       DDXPointPtr ppt,
-                       int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, -1);
-        break;
-    case FillOpaqueStippled:
-        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
-                                           pGC->fgPixel, pGC->bgPixel);
-        break;
-    case FillTiled:
-        pCache = (*infoRec->CacheTile) (infoRec->pScrn, pGC->tile.pixmap);
-        break;
-    default:                   /* Muffle compiler */
-        pCache = NULL;
-        break;
-    }
-
-    (*infoRec->FillCacheBltSpans) (infoRec->pScrn,
-                                   pGC->alu, pGC->planemask, n, ppt, pwidth,
-                                   fSorted, pCache, (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y));
-
-}
-
-        /****************************\
-	|     Cache Expand Spans     |
-	\****************************/
-
-static void
-XAARenderCacheExpandSpans(GCPtr pGC,
-                          int n,
-                          DDXPointPtr ppt,
-                          int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int fg, bg;
-
-    switch (pGC->fillStyle) {
-    case FillStippled:
-        fg = pGC->fgPixel;
-        bg = -1;
-        break;
-    case FillOpaqueStippled:
-        fg = pGC->fgPixel;
-        bg = pGC->bgPixel;
-        break;
-    default:                   /* Muffle compiler */
-        fg = -1;
-        bg = -1;
-        break;
-    }
-
-    (*infoRec->FillCacheExpandSpans) (infoRec->pScrn, fg, bg,
-                                      pGC->alu, pGC->planemask, n, ppt, pwidth,
-                                      fSorted, (xorg + pGC->patOrg.x),
-                                      (yorg + pGC->patOrg.y), pGC->stipple);
-}
-
-        /***************************\
-	|     Pixmap Copy Spans     |
-	\***************************/
-
-static void
-XAARenderPixmapCopySpans(GCPtr pGC,
-                         int n,
-                         DDXPointPtr ppt,
-                         int *pwidth, int fSorted, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-    pCache->x = pPriv->offscreenArea->box.x1;
-    pCache->y = pPriv->offscreenArea->box.y1;
-    pCache->w = pCache->orig_w = pPriv->offscreenArea->box.x2 - pCache->x;
-    pCache->h = pCache->orig_h = pPriv->offscreenArea->box.y2 - pCache->y;
-    pCache->trans_color = -1;
-
-    (*infoRec->FillCacheBltSpans) (infoRec->pScrn,
-                                   pGC->alu, pGC->planemask, n, ppt, pwidth,
-                                   fSorted, pCache, (xorg + pGC->patOrg.x),
-                                   (yorg + pGC->patOrg.y));
-}
-
-        /****************\
-	|     Solid      |
-	\****************/
-
-void
-XAAFillSolidSpans(ScrnInfoPtr pScrn,
-                  int fg, int rop,
-                  unsigned int planemask,
-                  int n, DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-
-    (*infoRec->SetupForSolidFill) (pScrn, fg, rop, planemask);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        if (*pwidth > 0)
-            (*infoRec->SubsequentSolidFillRect) (pScrn, ppt->x, ppt->y,
-                                                 *pwidth, 1);
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /***************\
-	|   Mono 8x8    |
-	\***************/
-
-void
-XAAFillMono8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask,
-                                       int n,
-                                       DDXPointPtr ppt,
-                                       int *pwidth, int fSorted,
-                                       int pattern0, int pattern1,
-                                       int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                 (infoRec->Mono8x8PatternFillFlags &
-                                  BIT_ORDER_IN_BYTE_MSBFIRST));
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-    else {
-        XAACacheInfoPtr pCache =
-            (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            int slot = (yorg << 3) + xorg;
-
-            patx += pCache->offsets[slot].x;
-            paty += pCache->offsets[slot].y;
-            xorg = patx;
-            yorg = paty;
-        }
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, ppt->x,
-                                                      ppt->y, *pwidth, 1);
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillMono8x8PatternSpans(ScrnInfoPtr pScrn,
-                           int fg, int bg, int rop,
-                           unsigned int planemask,
-                           int n,
-                           DDXPointPtr ppt,
-                           int *pwidth, int fSorted,
-                           int pattern0, int pattern1, int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pattern0, paty = pattern1;
-    int xorg, yorg, slot;
-    XAACacheInfoPtr pCache = NULL;
-
-    if (!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)) {
-        pCache = (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
-        patx = pCache->x;
-        paty = pCache->y;
-    }
-
-    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
-                                            fg, bg, rop, planemask);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        xorg = (ppt->x - xorigin) & 0x07;
-        yorg = (ppt->y - yorigin) & 0x07;
-
-        if (!(infoRec->Mono8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            if (infoRec->Mono8x8PatternFillFlags &
-                HARDWARE_PATTERN_PROGRAMMED_BITS) {
-                patx = pattern0;
-                paty = pattern1;
-                XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-                                     (infoRec->Mono8x8PatternFillFlags &
-                                      BIT_ORDER_IN_BYTE_MSBFIRST));
-                xorg = patx;
-                yorg = paty;
-            }
-            else {
-                slot = (yorg << 3) + xorg;
-                xorg = patx + pCache->offsets[slot].x;
-                yorg = paty + pCache->offsets[slot].y;
-            }
-        }
-
-        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
-                                                      xorg, yorg, ppt->x,
-                                                      ppt->y, *pwidth, 1);
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /****************\
-	|   Color 8x8    |
-	\****************/
-
-void
-XAAFillColor8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int n,
-                                        DDXPointPtr ppt,
-                                        int *pwidth, int fSorted,
-                                        XAACacheInfoPtr pCache,
-                                        int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int patx = pCache->x, paty = pCache->y;
-    int xorg = (-xorigin) & 0x07;
-    int yorg = (-yorigin) & 0x07;
-
-    if (!(infoRec->Color8x8PatternFillFlags &
-          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-        int slot = (yorg << 3) + xorg;
-
-        paty += pCache->offsets[slot].y;
-        patx += pCache->offsets[slot].x;
-        xorg = patx;
-        yorg = paty;
-    }
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, patx, paty,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, ppt->x,
-                                                       ppt->y, *pwidth, 1);
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAFillColor8x8PatternSpans(ScrnInfoPtr pScrn,
-                            int rop,
-                            unsigned int planemask,
-                            int n,
-                            DDXPointPtr ppt,
-                            int *pwidth, int fSorted,
-                            XAACacheInfoPtr pCache, int xorigin, int yorigin)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int xorg, yorg, slot;
-
-    (*infoRec->SetupForColor8x8PatternFill) (pScrn, pCache->x, pCache->y,
-                                             rop, planemask,
-                                             pCache->trans_color);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        xorg = (ppt->x - xorigin) & 0x07;
-        yorg = (ppt->y - yorigin) & 0x07;
-
-        if (!(infoRec->Color8x8PatternFillFlags &
-              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
-            slot = (yorg << 3) + xorg;
-            yorg = pCache->y + pCache->offsets[slot].y;
-            xorg = pCache->x + pCache->offsets[slot].x;
-        }
-
-        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
-                                                       xorg, yorg, ppt->x,
-                                                       ppt->y, *pwidth, 1);
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /*****************\
-	|   Cache Blit    |
-	\*****************/
-
-void
-XAAFillCacheBltSpans(ScrnInfoPtr pScrn,
-                     int rop,
-                     unsigned int planemask,
-                     int n,
-                     DDXPointPtr ppt,
-                     int *pwidth,
-                     int fSorted, XAACacheInfoPtr pCache, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w;
-
-    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, rop, planemask,
-                                            pCache->trans_color);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        x = ppt->x;
-        w = *pwidth;
-        phaseX = (x - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        phaseY = (ppt->y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-
-        while (1) {
-            blit_w = pCache->w - phaseX;
-            if (blit_w > w)
-                blit_w = w;
-
-            (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
-                                                      pCache->x + phaseX,
-                                                      pCache->y + phaseY, x,
-                                                      ppt->y, blit_w, 1);
-
-            w -= blit_w;
-            if (!w)
-                break;
-            x += blit_w;
-            phaseX = (phaseX + blit_w) % pCache->orig_w;
-        }
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-        /****************\
-	|  Cache Expand  |
-	\****************/
-
-void
-XAAFillCacheExpandSpans(ScrnInfoPtr pScrn,
-                        int fg, int bg, int rop,
-                        unsigned int planemask,
-                        int n,
-                        DDXPointPtr ppt,
-                        int *pwidth,
-                        int fSorted, int xorg, int yorg, PixmapPtr pPix)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w, cacheWidth;
-    XAACacheInfoPtr pCache;
-
-    pCache = (*infoRec->CacheMonoStipple) (pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
-        infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                       planemask);
-
-    if (infoRec->ClipBox)
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-
-    while (n--) {
-        x = ppt->x;
-        w = *pwidth;
-        phaseX = (x - xorg) % pCache->orig_w;
-        if (phaseX < 0)
-            phaseX += pCache->orig_w;
-        phaseY = (ppt->y - yorg) % pCache->orig_h;
-        if (phaseY < 0)
-            phaseY += pCache->orig_h;
-
-        while (1) {
-            blit_w = cacheWidth - phaseX;
-            if (blit_w > w)
-                blit_w = w;
-
-            (*infoRec->SubsequentScreenToScreenColorExpandFill) (pScrn, x,
-                                                                 ppt->y, blit_w,
-                                                                 1, pCache->x,
-                                                                 pCache->y +
-                                                                 phaseY,
-                                                                 phaseX);
-
-            w -= blit_w;
-            if (!w)
-                break;
-            x += blit_w;
-            phaseX = (phaseX + blit_w) % pCache->orig_w;
-        }
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->ClipBox)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-XAAClipAndRenderSpans(GCPtr pGC,
-                      DDXPointPtr ppt,
-                      int *pwidth,
-                      int nspans,
-                      int fSorted,
-                      ClipAndRenderSpansFunc func, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    DDXPointPtr pptNew, pptBase;
-    int *pwidthBase, *pwidthNew;
-    int Right, numRects, MaxBoxes;
-
-    MaxBoxes = infoRec->PreAllocSize / (sizeof(DDXPointRec) + sizeof(int));
-    pptBase = (DDXPointRec *) infoRec->PreAllocMem;
-    pwidthBase = (int *) (&pptBase[MaxBoxes]);
-
-    pptNew = pptBase;
-    pwidthNew = pwidthBase;
-
-    numRects = RegionNumRects(pGC->pCompositeClip);
-
-    if (numRects == 1) {
-        BoxPtr pextent = RegionRects(pGC->pCompositeClip);
-
-        while (nspans--) {
-            if ((pextent->y1 <= ppt->y) && (ppt->y < pextent->y2)) {
-                pptNew->x = max(pextent->x1, ppt->x);
-                Right = ppt->x + *pwidth;
-                *pwidthNew = min(pextent->x2, Right) - pptNew->x;
-
-                if (*pwidthNew > 0) {
-                    pptNew->y = ppt->y;
-                    pptNew++;
-                    pwidthNew++;
-
-                    if (pptNew >= (pptBase + MaxBoxes)) {
-                        (*func) (pGC, MaxBoxes, pptBase, pwidthBase, fSorted,
-                                 xorg, yorg);
-                        pptNew = pptBase;
-                        pwidthNew = pwidthBase;
-                    }
-                }
-            }
-            ppt++;
-            pwidth++;
-        }
-    }
-    else if (numRects) {
-        BoxPtr pbox;
-        int nbox;
-
-        while (nspans--) {
-            nbox = numRects;
-            pbox = RegionRects(pGC->pCompositeClip);
-
-            /* find the first band */
-            while (nbox && (pbox->y2 <= ppt->y)) {
-                pbox++;
-                nbox--;
-            }
-
-            if (nbox && (pbox->y1 <= ppt->y)) {
-                int orig_y = pbox->y1;
-
-                Right = ppt->x + *pwidth;
-                while (nbox && (orig_y == pbox->y1)) {
-                    if (pbox->x2 <= ppt->x) {
-                        nbox--;
-                        pbox++;
-                        continue;
-                    }
-
-                    if (pbox->x1 >= Right) {
-                        nbox = 0;
-                        break;
-                    }
-
-                    pptNew->x = max(pbox->x1, ppt->x);
-                    *pwidthNew = min(pbox->x2, Right) - pptNew->x;
-                    if (*pwidthNew > 0) {
-                        pptNew->y = ppt->y;
-                        pptNew++;
-                        pwidthNew++;
-
-                        if (pptNew >= (pptBase + MaxBoxes)) {
-                            (*func) (pGC, MaxBoxes, pptBase, pwidthBase,
-                                     fSorted, xorg, yorg);
-                            pptNew = pptBase;
-                            pwidthNew = pwidthBase;
-                        }
-                    }
-                    pbox++;
-                    nbox--;
-                }
-            }
-            ppt++;
-            pwidth++;
-        }
-    }
-
-    if (pptNew != pptBase)
-        (*func) (pGC, pptNew - pptBase, pptBase, pwidthBase, fSorted,
-                 xorg, yorg);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaStateChange.c b/xorg-server/hw/xfree86/xaa/xaaStateChange.c
deleted file mode 100644
index cd2b601c4..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaStateChange.c
+++ /dev/null
@@ -1,1665 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "miline.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "servermd.h"
-
-#define XAA_STATE_WRAP(func) do {\
-if(infoRec->func) { \
-   pStatePriv->func = infoRec->func;\
-   infoRec->func = XAAStateWrap##func;\
-}} while(0)
-
-/* Wrap all XAA functions and allocate our private structure.
- */
-
-typedef struct _XAAStateWrapRec {
-    ScrnInfoPtr pScrn;
-    void (*RestoreAccelState) (ScrnInfoPtr pScrn);
-    void (*Sync) (ScrnInfoPtr pScrn);
-    void (*SetupForScreenToScreenCopy) (ScrnInfoPtr pScrn, int xdir, int ydir,
-                                        int rop, unsigned int planemask,
-                                        int trans_color);
-    void (*SetupForSolidFill) (ScrnInfoPtr pScrn, int color, int rop,
-                               unsigned int planemask);
-    void (*SetupForSolidLine) (ScrnInfoPtr pScrn, int color, int rop,
-                               unsigned int planemask);
-    void (*SetupForDashedLine) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                unsigned int planemask, int length,
-                                unsigned char *pattern);
-    void (*SetClippingRectangle) (ScrnInfoPtr pScrn, int left, int top,
-                                  int right, int bottom);
-    void (*DisableClipping) (ScrnInfoPtr pScrn);
-    void (*SetupForMono8x8PatternFill) (ScrnInfoPtr pScrn, int patx, int paty,
-                                        int fg, int bg, int rop,
-                                        unsigned int planemask);
-    void (*SetupForColor8x8PatternFill) (ScrnInfoPtr pScrn, int patx, int paty,
-                                         int rop, unsigned int planemask,
-                                         int transparency_color);
-    void (*SetupForCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn, int fg,
-                                                int bg, int rop,
-                                                unsigned int planemask);
-    void (*SetupForScanlineCPUToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                        int fg, int bg, int rop,
-                                                        unsigned int planemask);
-    void (*SetupForScreenToScreenColorExpandFill) (ScrnInfoPtr pScrn,
-                                                   int fg, int bg, int rop,
-                                                   unsigned int planemask);
-    void (*SetupForImageWrite) (ScrnInfoPtr pScrn, int rop,
-                                unsigned int planemask, int transparency_color,
-                                int bpp, int depth);
-    void (*SetupForScanlineImageWrite) (ScrnInfoPtr pScrn, int rop,
-                                        unsigned int planemask,
-                                        int transparency_color,
-                                        int bpp, int depth);
-    void (*SetupForImageRead) (ScrnInfoPtr pScrn, int bpp, int depth);
-    void (*ScreenToScreenBitBlt) (ScrnInfoPtr pScrn, int nbox,
-                                  DDXPointPtr pptSrc, BoxPtr pbox, int xdir,
-                                  int ydir, int alu, unsigned int planmask);
-    void (*WriteBitmap) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                         unsigned char *src, int srcwidth, int skipleft,
-                         int fg, int bg, int rop, unsigned int planemask);
-    void (*FillSolidRects) (ScrnInfoPtr pScrn, int fg, int rop,
-                            unsigned int planemask, int nBox, BoxPtr pBox);
-    void (*FillMono8x8PatternRects) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                     unsigned int planemask, int nBox,
-                                     BoxPtr pBox, int pat0, int pat1,
-                                     int xorg, int yorg);
-    void (*FillColor8x8PatternRects) (ScrnInfoPtr pScrn, int rop,
-                                      unsigned int planemask, int nBox,
-                                      BoxPtr pBox, int xorg, int yorg,
-                                      XAACacheInfoPtr pCache);
-    void (*FillCacheBltRects) (ScrnInfoPtr pScrn, int rop,
-                               unsigned int planemask, int nBox, BoxPtr pBox,
-                               int xorg, int yorg, XAACacheInfoPtr pCache);
-    void (*FillColorExpandRects) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                  unsigned int planemask, int nBox,
-                                  BoxPtr pBox, int xorg, int yorg,
-                                  PixmapPtr pPix);
-    void (*FillCacheExpandRects) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                  unsigned int planemask, int nBox, BoxPtr pBox,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    void (*FillImageWriteRects) (ScrnInfoPtr pScrn, int rop,
-                                 unsigned int planemask, int nBox, BoxPtr pBox,
-                                 int xorg, int yorg, PixmapPtr pPix);
-    void (*FillSolidSpans) (ScrnInfoPtr pScrn, int fg, int rop,
-                            unsigned int planemask, int n, DDXPointPtr points,
-                            int *widths, int fSorted);
-    void (*FillMono8x8PatternSpans) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                     unsigned int planemask, int n,
-                                     DDXPointPtr points, int *widths,
-                                     int fSorted, int pat0, int pat1,
-                                     int xorg, int yorg);
-    void (*FillColor8x8PatternSpans) (ScrnInfoPtr pScrn, int rop,
-                                      unsigned int planemask, int n,
-                                      DDXPointPtr points, int *widths,
-                                      int fSorted, XAACacheInfoPtr pCache,
-                                      int xorg, int yorg);
-    void (*FillCacheBltSpans) (ScrnInfoPtr pScrn, int rop,
-                               unsigned int planemask, int n,
-                               DDXPointPtr points, int *widths, int fSorted,
-                               XAACacheInfoPtr pCache, int xorg, int yorg);
-    void (*FillColorExpandSpans) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                  unsigned int planemask, int n,
-                                  DDXPointPtr points, int *widths, int fSorted,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    void (*FillCacheExpandSpans) (ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                  unsigned int planemask, int n,
-                                  DDXPointPtr ppt, int *pwidth, int fSorted,
-                                  int xorg, int yorg, PixmapPtr pPix);
-    void (*TEGlyphRenderer) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                             int skipleft, int startline, unsigned int **glyphs,
-                             int glyphWidth, int fg, int bg, int rop,
-                             unsigned planemask);
-    void (*NonTEGlyphRenderer) (ScrnInfoPtr pScrn, int x, int y, int n,
-                                NonTEGlyphPtr glyphs, BoxPtr pbox, int fg,
-                                int rop, unsigned int planemask);
-    void (*WritePixmap) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                         unsigned char *src, int srcwidth, int rop,
-                         unsigned int planemask, int transparency_color,
-                         int bpp, int depth);
-    void (*ReadPixmap) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                        unsigned char *dst, int dstwidth, int bpp, int depth);
-    RegionPtr (*CopyArea) (DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-                           GC * pGC, int srcx, int srcy, int width, int height,
-                           int dstx, int dsty);
-    RegionPtr (*CopyPlane) (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-                            int srcx, int srcy, int width, int height, int dstx,
-                            int dsty, unsigned long bitPlane);
-    void (*PushPixelsSolid) (GCPtr pGC, PixmapPtr pBitMap,
-                             DrawablePtr pDrawable, int dx, int dy, int xOrg,
-                             int yOrg);
-    void (*PolyFillRectSolid) (DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                               xRectangle *prectInit);
-    void (*PolyFillRectStippled) (DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                                  xRectangle *prectInit);
-    void (*PolyFillRectOpaqueStippled) (DrawablePtr pDraw, GCPtr pGC,
-                                        int nrectFill, xRectangle *prectInit);
-    void (*PolyFillRectTiled) (DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                               xRectangle *prectInit);
-    void (*FillSpansSolid) (DrawablePtr pDraw, GCPtr pGC, int nInit,
-                            DDXPointPtr ppt, int *pwidth, int fSorted);
-    void (*FillSpansStippled) (DrawablePtr pDraw, GCPtr pGC, int nInit,
-                               DDXPointPtr ppt, int *pwidth, int fSorted);
-    void (*FillSpansOpaqueStippled) (DrawablePtr pDraw, GCPtr pGC, int nInit,
-                                     DDXPointPtr ppt, int *pwidth, int fSorted);
-    void (*FillSpansTiled) (DrawablePtr pDraw, GCPtr pGC, int nInit,
-                            DDXPointPtr ppt, int *pwidth, int fSorted);
-    int (*PolyText8TE) (DrawablePtr pDraw, GCPtr pGC, int x, int y, int count,
-                        char *chars);
-    int (*PolyText16TE) (DrawablePtr pDraw, GCPtr pGC, int x, int y, int count,
-                         unsigned short *chars);
-    void (*ImageText8TE) (DrawablePtr pDraw, GCPtr pGC, int x, int y, int count,
-                          char *chars);
-    void (*ImageText16TE) (DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                           int count, unsigned short *chars);
-    void (*ImageGlyphBltTE) (DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                             int yInit, unsigned int nglyph, CharInfoPtr * ppci,
-                             pointer pglyphBase);
-    void (*PolyGlyphBltTE) (DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                            int yInit, unsigned int nglyph, CharInfoPtr * ppci,
-                            pointer pglyphBase);
-    int (*PolyText8NonTE) (DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                           int count, char *chars);
-    int (*PolyText16NonTE) (DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                            int count, unsigned short *chars);
-    void (*ImageText8NonTE) (DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                             int count, char *chars);
-    void (*ImageText16NonTE) (DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                              int count, unsigned short *chars);
-    void (*ImageGlyphBltNonTE) (DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                                int yInit, unsigned int nglyph,
-                                CharInfoPtr * ppci, pointer pglyphBase);
-    void (*PolyGlyphBltNonTE) (DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                               int yInit, unsigned int nglyph,
-                               CharInfoPtr * ppci, pointer pglyphBase);
-    void (*PolyRectangleThinSolid) (DrawablePtr pDrawable, GCPtr pGC,
-                                    int nRectsInit, xRectangle *pRectsInit);
-    void (*PolylinesWideSolid) (DrawablePtr pDrawable, GCPtr pGC, int mode,
-                                int npt, DDXPointPtr pPts);
-    void (*PolylinesThinSolid) (DrawablePtr pDrawable, GCPtr pGC, int mode,
-                                int npt, DDXPointPtr pPts);
-    void (*PolySegmentThinSolid) (DrawablePtr pDrawable, GCPtr pGC, int nseg,
-                                  xSegment * pSeg);
-    void (*PolylinesThinDashed) (DrawablePtr pDrawable, GCPtr pGC, int mode,
-                                 int npt, DDXPointPtr pPts);
-    void (*PolySegmentThinDashed) (DrawablePtr pDrawable, GCPtr pGC, int nseg,
-                                   xSegment * pSeg);
-    void (*FillPolygonSolid) (DrawablePtr pDrawable, GCPtr pGC, int shape,
-                              int mode, int count, DDXPointPtr ptsIn);
-    void (*FillPolygonStippled) (DrawablePtr pDrawable, GCPtr pGC, int shape,
-                                 int mode, int count, DDXPointPtr ptsIn);
-    void (*FillPolygonOpaqueStippled) (DrawablePtr pDrawable, GCPtr pGC,
-                                       int shape, int mode, int count,
-                                       DDXPointPtr ptsIn);
-    void (*FillPolygonTiled) (DrawablePtr pDrawable, GCPtr pGC, int shape,
-                              int mode, int count, DDXPointPtr ptsIn);
-    void (*PolyFillArcSolid) (DrawablePtr pDraw, GCPtr pGC, int narcs,
-                              xArc * parcs);
-    void (*PutImage) (DrawablePtr pDraw, GCPtr pGC, int depth, int x, int y,
-                      int w, int h, int leftPad, int format, char *pImage);
-    ValidateGCProcPtr ValidateFillSpans;
-    ValidateGCProcPtr ValidateSetSpans;
-    ValidateGCProcPtr ValidatePutImage;
-    ValidateGCProcPtr ValidateCopyArea;
-    ValidateGCProcPtr ValidateCopyPlane;
-    ValidateGCProcPtr ValidatePolyPoint;
-    ValidateGCProcPtr ValidatePolylines;
-    ValidateGCProcPtr ValidatePolySegment;
-    ValidateGCProcPtr ValidatePolyRectangle;
-    ValidateGCProcPtr ValidatePolyArc;
-    ValidateGCProcPtr ValidateFillPolygon;
-    ValidateGCProcPtr ValidatePolyFillRect;
-    ValidateGCProcPtr ValidatePolyFillArc;
-    ValidateGCProcPtr ValidatePolyText8;
-    ValidateGCProcPtr ValidatePolyText16;
-    ValidateGCProcPtr ValidateImageText8;
-    ValidateGCProcPtr ValidateImageText16;
-    ValidateGCProcPtr ValidatePolyGlyphBlt;
-    ValidateGCProcPtr ValidateImageGlyphBlt;
-    ValidateGCProcPtr ValidatePushPixels;
-    void (*ComputeDash) (GCPtr pGC);
-    void (*InitPixmapCache) (ScreenPtr pScreen, RegionPtr areas, pointer data);
-    void (*ClosePixmapCache) (ScreenPtr pScreen);
-    int (*StippledFillChooser) (GCPtr pGC);
-    int (*OpaqueStippledFillChooser) (GCPtr pGC);
-    int (*TiledFillChooser) (GCPtr pGC);
-     XAACacheInfoPtr(*CacheTile) (ScrnInfoPtr Scrn, PixmapPtr pPix);
-     XAACacheInfoPtr(*CacheStipple) (ScrnInfoPtr Scrn, PixmapPtr pPix, int fg,
-                                     int bg);
-     XAACacheInfoPtr(*CacheMonoStipple) (ScrnInfoPtr Scrn, PixmapPtr pPix);
-     XAACacheInfoPtr(*CacheMono8x8Pattern) (ScrnInfoPtr Scrn, int pat0,
-                                            int pat1);
-     XAACacheInfoPtr(*CacheColor8x8Pattern) (ScrnInfoPtr Scrn, PixmapPtr pPix,
-                                             int fg, int bg);
-    void (*WriteBitmapToCache) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                                unsigned char *src, int srcwidth, int fg,
-                                int bg);
-    void (*WritePixmapToCache) (ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                                unsigned char *src, int srcwidth, int bpp,
-                                int depth);
-    void (*WriteMono8x8PatternToCache) (ScrnInfoPtr pScrn,
-                                        XAACacheInfoPtr pCache);
-    void (*WriteColor8x8PatternToCache) (ScrnInfoPtr pScrn, PixmapPtr pPix,
-                                         XAACacheInfoPtr pCache);
-    GetImageProcPtr GetImage;
-    GetSpansProcPtr GetSpans;
-    CopyWindowProcPtr CopyWindow;
-    Bool (*SetupForCPUToScreenAlphaTexture2) (ScrnInfoPtr pScrn, int op,
-                                              CARD16 red, CARD16 green,
-                                              CARD16 blue, CARD16 alpha,
-                                              CARD32 maskFormat,
-                                              CARD32 dstFormat, CARD8 *alphaPtr,
-                                              int alphaPitch, int width,
-                                              int height, int flags);
-    Bool (*SetupForCPUToScreenTexture2) (ScrnInfoPtr pScrn, int op,
-                                         CARD32 srcFormat, CARD32 dstFormat,
-                                         CARD8 *texPtr, int texPitch, int width,
-                                         int height, int flags);
-} XAAStateWrapRec, *XAAStateWrapPtr;
-
-static DevPrivateKeyRec XAAStateKeyRec;
-
-#define XAAStateKey (&XAAStateKeyRec)
-
-/* Wrap functions start here */
-#define GET_STATEPRIV_GC(pGC)   XAAStateWrapPtr pStatePriv =\
-(XAAStateWrapPtr)dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAStateKey)
-
-#define GET_STATEPRIV_SCREEN(pScreen)   XAAStateWrapPtr pStatePriv =\
-(XAAStateWrapPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAStateKey)
-
-#define GET_STATEPRIV_PSCRN(pScrn)   XAAStateWrapPtr pStatePriv =\
-(XAAStateWrapPtr)dixLookupPrivate(&(pScrn)->pScreen->devPrivates, XAAStateKey)
-
-#define STATE_CHECK_SP(pStatePriv) {\
-	ScrnInfoPtr pScrn = pStatePriv->pScrn;\
-	int i = 0;\
-	int need_change = 0;\
-	while(i < pScrn->numEntities) {\
-		if(xf86IsEntityShared(pScrn->entityList[i]) &&\
-		   xf86GetLastScrnFlag(pScrn->entityList[i]) != pScrn->scrnIndex) {\
-			need_change = 1;\
-			xf86SetLastScrnFlag(pScrn->entityList[i],\
-					    pScrn->scrnIndex);\
-		}\
-		i++;\
-	}\
-	if(need_change == 1) (*pStatePriv->RestoreAccelState)(pScrn);\
-}
-
-#define STATE_CHECK_PSCRN(pScrn) {\
-	int i = 0;\
-	int need_change = 0;\
-	while(i < pScrn->numEntities) {\
-		if(xf86IsEntityShared(pScrn->entityList[i]) &&\
-		   xf86GetLastScrnFlag(pScrn->entityList[i]) != pScrn->scrnIndex) {\
-			need_change = 1;\
-			xf86SetLastScrnFlag(pScrn->entityList[i],\
-					    pScrn->scrnIndex);\
-		}\
-		i++;\
-	}\
-	if(need_change == 1) (*pStatePriv->RestoreAccelState)(pScrn);\
-}
-
-static void
-XAAStateWrapSync(ScrnInfoPtr pScrn)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->Sync) (pScrn);
-}
-
-static void
-XAAStateWrapSetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir,
-                                       int rop, unsigned int planemask,
-                                       int trans_color)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForScreenToScreenCopy) (pScrn, xdir, ydir, rop,
-                                               planemask, trans_color);
-}
-
-static void
-XAAStateWrapSetupForSolidFill(ScrnInfoPtr pScrn, int color, int rop,
-                              unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForSolidFill) (pScrn, color, rop, planemask);
-}
-
-static void
-XAAStateWrapSetupForSolidLine(ScrnInfoPtr pScrn, int color, int rop,
-                              unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForSolidLine) (pScrn, color, rop, planemask);
-}
-
-static void
-XAAStateWrapSetupForDashedLine(ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                               unsigned int planemask, int length,
-                               unsigned char *pattern)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForDashedLine) (pScrn, fg, bg, rop, planemask, length,
-                                       pattern);
-}
-
-static void
-XAAStateWrapSetClippingRectangle(ScrnInfoPtr pScrn, int left, int top,
-                                 int right, int bottom)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetClippingRectangle) (pScrn, left, top, right, bottom);
-}
-
-static void
-XAAStateWrapDisableClipping(ScrnInfoPtr pScrn)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->DisableClipping) (pScrn);
-}
-
-static void
-XAAStateWrapSetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForMono8x8PatternFill) (pScrn, patx, paty, fg, bg, rop,
-                                               planemask);
-}
-
-static void
-XAAStateWrapSetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
-                                        int rop, unsigned int planemask,
-                                        int transparency_color)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForColor8x8PatternFill) (pScrn, patx, paty, rop,
-                                                planemask, transparency_color);
-}
-
-static void
-XAAStateWrapSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int fg,
-                                               int bg, int rop,
-                                               unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                       planemask);
-}
-
-static void
-XAAStateWrapSetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
-                                                       int fg, int bg,
-                                                       int rop,
-                                                       unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg,
-                                                               rop, planemask);
-}
-
-static void
-XAAStateWrapSetupForScreenToScreenColorExpandFill(ScrnInfoPtr pScrn,
-                                                  int fg, int bg, int rop,
-                                                  unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForScreenToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                          planemask);
-}
-
-static void
-XAAStateWrapSetupForImageWrite(ScrnInfoPtr pScrn, int rop,
-                               unsigned int planemask, int transparency_color,
-                               int bpp, int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForImageWrite) (pScrn, rop, planemask,
-                                       transparency_color, bpp, depth);
-}
-
-static void
-XAAStateWrapSetupForScanlineImageWrite(ScrnInfoPtr pScrn, int rop,
-                                       unsigned int planemask,
-                                       int transparency_color,
-                                       int bpp, int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForScanlineImageWrite) (pScrn, rop, planemask,
-                                               transparency_color, bpp, depth);
-}
-
-static void
-XAAStateWrapSetupForImageRead(ScrnInfoPtr pScrn, int bpp, int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->SetupForImageRead) (pScrn, bpp, depth);
-}
-
-static void
-XAAStateWrapScreenToScreenBitBlt(ScrnInfoPtr pScrn, int nbox,
-                                 DDXPointPtr pptSrc, BoxPtr pbox, int xdir,
-                                 int ydir, int alu, unsigned int planmask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->ScreenToScreenBitBlt) (pScrn, nbox,
-                                         pptSrc, pbox, xdir,
-                                         ydir, alu, planmask);
-}
-
-static void
-XAAStateWrapWriteBitmap(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                        unsigned char *src, int srcwidth, int skipleft,
-                        int fg, int bg, int rop, unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WriteBitmap) (pScrn, x, y, w, h,
-                                src, srcwidth, skipleft,
-                                fg, bg, rop, planemask);
-}
-
-static void
-XAAStateWrapFillSolidRects(ScrnInfoPtr pScrn, int fg, int rop,
-                           unsigned int planemask, int nBox, BoxPtr pBox)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillSolidRects) (pScrn, fg, rop, planemask, nBox, pBox);
-}
-
-static void
-XAAStateWrapFillMono8x8PatternRects(ScrnInfoPtr pScrn, int fg, int bg,
-                                    int rop, unsigned int planemask, int nBox,
-                                    BoxPtr pBox, int pat0, int pat1,
-                                    int xorg, int yorg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillMono8x8PatternRects) (pScrn, fg, bg,
-                                            rop, planemask, nBox,
-                                            pBox, pat0, pat1, xorg, yorg);
-}
-
-static void
-XAAStateWrapFillColor8x8PatternRects(ScrnInfoPtr pScrn, int rop,
-                                     unsigned int planemask, int nBox,
-                                     BoxPtr pBox, int xorg, int yorg,
-                                     XAACacheInfoPtr pCache)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillColor8x8PatternRects) (pScrn, rop,
-                                             planemask, nBox,
-                                             pBox, xorg, yorg, pCache);
-}
-
-static void
-XAAStateWrapFillCacheBltRects(ScrnInfoPtr pScrn, int rop,
-                              unsigned int planemask, int nBox, BoxPtr pBox,
-                              int xorg, int yorg, XAACacheInfoPtr pCache)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillCacheBltRects) (pScrn, rop,
-                                      planemask, nBox, pBox,
-                                      xorg, yorg, pCache);
-}
-
-static void
-XAAStateWrapFillColorExpandRects(ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                 unsigned int planemask, int nBox,
-                                 BoxPtr pBox, int xorg, int yorg,
-                                 PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillColorExpandRects) (pScrn, fg, bg, rop,
-                                         planemask, nBox,
-                                         pBox, xorg, yorg, pPix);
-}
-
-static void
-XAAStateWrapFillCacheExpandRects(ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                 unsigned int planemask, int nBox,
-                                 BoxPtr pBox, int xorg, int yorg,
-                                 PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillCacheExpandRects) (pScrn, fg, bg, rop,
-                                         planemask, nBox,
-                                         pBox, xorg, yorg, pPix);
-}
-
-static void
-XAAStateWrapFillImageWriteRects(ScrnInfoPtr pScrn, int rop,
-                                unsigned int planemask, int nBox, BoxPtr pBox,
-                                int xorg, int yorg, PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillImageWriteRects) (pScrn, rop,
-                                        planemask, nBox, pBox,
-                                        xorg, yorg, pPix);
-}
-
-static void
-XAAStateWrapFillSolidSpans(ScrnInfoPtr pScrn, int fg, int rop,
-                           unsigned int planemask, int n, DDXPointPtr points,
-                           int *widths, int fSorted)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillSolidSpans) (pScrn, fg, rop,
-                                   planemask, n, points, widths, fSorted);
-}
-
-static void
-XAAStateWrapFillMono8x8PatternSpans(ScrnInfoPtr pScrn, int fg, int bg,
-                                    int rop, unsigned int planemask, int n,
-                                    DDXPointPtr points, int *widths,
-                                    int fSorted, int pat0, int pat1,
-                                    int xorg, int yorg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillMono8x8PatternSpans) (pScrn, fg, bg,
-                                            rop, planemask, n,
-                                            points, widths,
-                                            fSorted, pat0, pat1, xorg, yorg);
-}
-
-static void
-XAAStateWrapFillColor8x8PatternSpans(ScrnInfoPtr pScrn, int rop,
-                                     unsigned int planemask, int n,
-                                     DDXPointPtr points, int *widths,
-                                     int fSorted, XAACacheInfoPtr pCache,
-                                     int xorg, int yorg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillColor8x8PatternSpans) (pScrn, rop,
-                                             planemask, n,
-                                             points, widths,
-                                             fSorted, pCache, xorg, yorg);
-}
-
-static void
-XAAStateWrapFillCacheBltSpans(ScrnInfoPtr pScrn, int rop,
-                              unsigned int planemask, int n,
-                              DDXPointPtr points, int *widths,
-                              int fSorted, XAACacheInfoPtr pCache,
-                              int xorg, int yorg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillCacheBltSpans) (pScrn, rop,
-                                      planemask, n,
-                                      points, widths,
-                                      fSorted, pCache, xorg, yorg);
-}
-
-static void
-XAAStateWrapFillColorExpandSpans(ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                 unsigned int planemask, int n,
-                                 DDXPointPtr points, int *widths, int fSorted,
-                                 int xorg, int yorg, PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillColorExpandSpans) (pScrn, fg, bg, rop,
-                                         planemask, n,
-                                         points, widths, fSorted,
-                                         xorg, yorg, pPix);
-}
-
-static void
-XAAStateWrapFillCacheExpandSpans(ScrnInfoPtr pScrn, int fg, int bg, int rop,
-                                 unsigned int planemask, int n,
-                                 DDXPointPtr ppt, int *pwidth, int fSorted,
-                                 int xorg, int yorg, PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->FillCacheExpandSpans) (pScrn, fg, bg, rop,
-                                         planemask, n,
-                                         ppt, pwidth, fSorted,
-                                         xorg, yorg, pPix);
-}
-
-static void
-XAAStateWrapTEGlyphRenderer(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                            int skipleft, int startline,
-                            unsigned int **glyphs,
-                            int glyphWidth, int fg, int bg, int rop,
-                            unsigned planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->TEGlyphRenderer) (pScrn, x, y, w, h,
-                                    skipleft, startline,
-                                    glyphs, glyphWidth, fg, bg, rop, planemask);
-}
-
-static void
-XAAStateWrapNonTEGlyphRenderer(ScrnInfoPtr pScrn, int x, int y, int n,
-                               NonTEGlyphPtr glyphs, BoxPtr pbox,
-                               int fg, int rop, unsigned int planemask)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->NonTEGlyphRenderer) (pScrn, x, y, n,
-                                       glyphs, pbox, fg, rop, planemask);
-}
-
-static void
-XAAStateWrapWritePixmap(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                        unsigned char *src, int srcwidth, int rop,
-                        unsigned int planemask, int transparency_color,
-                        int bpp, int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WritePixmap) (pScrn, x, y, w, h,
-                                src, srcwidth, rop,
-                                planemask, transparency_color, bpp, depth);
-}
-
-static void
-XAAStateWrapReadPixmap(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                       unsigned char *dst, int dstwidth, int bpp, int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->ReadPixmap) (pScrn, x, y, w, h, dst, dstwidth, bpp, depth);
-}
-
-static RegionPtr
-XAAStateWrapCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
-                     GC * pGC, int srcx, int srcy, int width, int height,
-                     int dstx, int dsty)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->CopyArea) (pSrcDrawable, pDstDrawable,
-                                    pGC, srcx, srcy, width, height, dstx, dsty);
-}
-
-static RegionPtr
-XAAStateWrapCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-                      int srcx, int srcy, int width, int height,
-                      int dstx, int dsty, unsigned long bitPlane)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->CopyPlane) (pSrc, pDst, pGC,
-                                     srcx, srcy, width, height,
-                                     dstx, dsty, bitPlane);
-}
-
-static void
-XAAStateWrapPushPixelsSolid(GCPtr pGC, PixmapPtr pBitMap,
-                            DrawablePtr pDrawable, int dx, int dy, int xOrg,
-                            int yOrg)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PushPixelsSolid) (pGC, pBitMap,
-                                    pDrawable, dx, dy, xOrg, yOrg);
-}
-
-static void
-XAAStateWrapPolyFillRectSolid(DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                              xRectangle *prectInit)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyFillRectSolid) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAStateWrapPolyFillRectStippled(DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                                 xRectangle *prectInit)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyFillRectStippled) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAStateWrapPolyFillRectOpaqueStippled(DrawablePtr pDraw, GCPtr pGC,
-                                       int nrectFill, xRectangle *prectInit)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyFillRectOpaqueStippled) (pDraw, pGC,
-                                               nrectFill, prectInit);
-}
-
-static void
-XAAStateWrapPolyFillRectTiled(DrawablePtr pDraw, GCPtr pGC, int nrectFill,
-                              xRectangle *prectInit)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyFillRectTiled) (pDraw, pGC, nrectFill, prectInit);
-}
-
-static void
-XAAStateWrapFillSpansSolid(DrawablePtr pDraw, GCPtr pGC, int nInit,
-                           DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillSpansSolid) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static void
-XAAStateWrapFillSpansStippled(DrawablePtr pDraw, GCPtr pGC, int nInit,
-                              DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillSpansStippled) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static void
-XAAStateWrapFillSpansOpaqueStippled(DrawablePtr pDraw, GCPtr pGC, int nInit,
-                                    DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillSpansOpaqueStippled) (pDraw, pGC, nInit,
-                                            ppt, pwidth, fSorted);
-}
-
-static void
-XAAStateWrapFillSpansTiled(DrawablePtr pDraw, GCPtr pGC, int nInit,
-                           DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillSpansTiled) (pDraw, pGC, nInit, ppt, pwidth, fSorted);
-}
-
-static int
-XAAStateWrapPolyText8TE(DrawablePtr pDraw, GCPtr pGC, int x, int y, int count,
-                        char *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->PolyText8TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static int
-XAAStateWrapPolyText16TE(DrawablePtr pDraw, GCPtr pGC, int x, int y, int count,
-                         unsigned short *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->PolyText16TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageText8TE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                         int count, char *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageText8TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageText16TE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                          int count, unsigned short *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageText16TE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageGlyphBltTE(DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                            int yInit, unsigned int nglyph, CharInfoPtr * ppci,
-                            pointer pglyphBase)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageGlyphBltTE) (pDrawable, pGC, xInit,
-                                    yInit, nglyph, ppci, pglyphBase);
-}
-
-static void
-XAAStateWrapPolyGlyphBltTE(DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                           int yInit, unsigned int nglyph, CharInfoPtr * ppci,
-                           pointer pglyphBase)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyGlyphBltTE) (pDrawable, pGC, xInit,
-                                   yInit, nglyph, ppci, pglyphBase);
-}
-
-static int
-XAAStateWrapPolyText8NonTE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                           int count, char *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->PolyText8NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static int
-XAAStateWrapPolyText16NonTE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                            int count, unsigned short *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->PolyText16NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageText8NonTE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                            int count, char *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageText8NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageText16NonTE(DrawablePtr pDraw, GCPtr pGC, int x, int y,
-                             int count, unsigned short *chars)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageText16NonTE) (pDraw, pGC, x, y, count, chars);
-}
-
-static void
-XAAStateWrapImageGlyphBltNonTE(DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                               int yInit, unsigned int nglyph,
-                               CharInfoPtr * ppci, pointer pglyphBase)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ImageGlyphBltNonTE) (pDrawable, pGC, xInit,
-                                       yInit, nglyph, ppci, pglyphBase);
-}
-
-static void
-XAAStateWrapPolyGlyphBltNonTE(DrawablePtr pDrawable, GCPtr pGC, int xInit,
-                              int yInit, unsigned int nglyph,
-                              CharInfoPtr * ppci, pointer pglyphBase)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyGlyphBltNonTE) (pDrawable, pGC, xInit,
-                                      yInit, nglyph, ppci, pglyphBase);
-}
-
-static void
-XAAStateWrapPolyRectangleThinSolid(DrawablePtr pDrawable, GCPtr pGC,
-                                   int nRectsInit, xRectangle *pRectsInit)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyRectangleThinSolid) (pDrawable, pGC,
-                                           nRectsInit, pRectsInit);
-}
-
-static void
-XAAStateWrapPolylinesWideSolid(DrawablePtr pDrawable, GCPtr pGC, int mode,
-                               int npt, DDXPointPtr pPts)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolylinesWideSolid) (pDrawable, pGC, mode, npt, pPts);
-}
-
-static void
-XAAStateWrapPolylinesThinSolid(DrawablePtr pDrawable, GCPtr pGC, int mode,
-                               int npt, DDXPointPtr pPts)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolylinesThinSolid) (pDrawable, pGC, mode, npt, pPts);
-}
-
-static void
-XAAStateWrapPolySegmentThinSolid(DrawablePtr pDrawable, GCPtr pGC, int nseg,
-                                 xSegment * pSeg)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolySegmentThinSolid) (pDrawable, pGC, nseg, pSeg);
-}
-
-static void
-XAAStateWrapPolylinesThinDashed(DrawablePtr pDrawable, GCPtr pGC, int mode,
-                                int npt, DDXPointPtr pPts)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolylinesThinDashed) (pDrawable, pGC, mode, npt, pPts);
-}
-
-static void
-XAAStateWrapPolySegmentThinDashed(DrawablePtr pDrawable, GCPtr pGC, int nseg,
-                                  xSegment * pSeg)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolySegmentThinDashed) (pDrawable, pGC, nseg, pSeg);
-}
-
-static void
-XAAStateWrapFillPolygonSolid(DrawablePtr pDrawable, GCPtr pGC, int shape,
-                             int mode, int count, DDXPointPtr ptsIn)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillPolygonSolid) (pDrawable, pGC, shape, mode, count, ptsIn);
-}
-
-static void
-XAAStateWrapFillPolygonStippled(DrawablePtr pDrawable, GCPtr pGC, int shape,
-                                int mode, int count, DDXPointPtr ptsIn)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillPolygonStippled) (pDrawable, pGC, shape,
-                                        mode, count, ptsIn);
-}
-
-static void
-XAAStateWrapFillPolygonOpaqueStippled(DrawablePtr pDrawable, GCPtr pGC,
-                                      int shape, int mode, int count,
-                                      DDXPointPtr ptsIn)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillPolygonOpaqueStippled) (pDrawable, pGC,
-                                              shape, mode, count, ptsIn);
-}
-
-static void
-XAAStateWrapFillPolygonTiled(DrawablePtr pDrawable, GCPtr pGC, int shape,
-                             int mode, int count, DDXPointPtr ptsIn)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->FillPolygonTiled) (pDrawable, pGC, shape, mode, count, ptsIn);
-}
-
-static void
-XAAStateWrapPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs,
-                             xArc * parcs)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PolyFillArcSolid) (pDraw, pGC, narcs, parcs);
-}
-
-static void
-XAAStateWrapPutImage(DrawablePtr pDraw, GCPtr pGC, int depth, int x, int y,
-                     int w, int h, int leftPad, int format, char *pImage)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->PutImage) (pDraw, pGC, depth, x, y,
-                             w, h, leftPad, format, pImage);
-}
-
-static void
-XAAStateWrapValidateFillSpans(GCPtr pGC, unsigned long changes,
-                              DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateFillSpans) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateSetSpans(GCPtr pGC, unsigned long changes,
-                             DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateSetSpans) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePutImage(GCPtr pGC, unsigned long changes,
-                             DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePutImage) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateCopyArea(GCPtr pGC, unsigned long changes,
-                             DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateCopyArea) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateCopyPlane(GCPtr pGC, unsigned long changes,
-                              DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateCopyPlane) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyPoint(GCPtr pGC, unsigned long changes,
-                              DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyPoint) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolylines(GCPtr pGC, unsigned long changes,
-                              DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolylines) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolySegment(GCPtr pGC, unsigned long changes,
-                                DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolySegment) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyRectangle(GCPtr pGC, unsigned long changes,
-                                  DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyRectangle) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyArc(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyArc) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateFillPolygon(GCPtr pGC, unsigned long changes,
-                                DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateFillPolygon) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyFillRect(GCPtr pGC, unsigned long changes,
-                                 DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyFillRect) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyFillArc(GCPtr pGC, unsigned long changes,
-                                DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyFillArc) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyText8(GCPtr pGC, unsigned long changes,
-                              DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyText8) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyText16(GCPtr pGC, unsigned long changes,
-                               DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyText16) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateImageText8(GCPtr pGC, unsigned long changes,
-                               DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateImageText8) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateImageText16(GCPtr pGC, unsigned long changes,
-                                DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidateImageText16) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePolyGlyphBlt(GCPtr pGC, unsigned long changes,
-                                 DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePolyGlyphBlt) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidateImageGlyphBlt(GCPtr pGC, unsigned long changes,
-                                  DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-    (*pStatePriv->ValidateImageGlyphBlt) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapValidatePushPixels(GCPtr pGC, unsigned long changes,
-                               DrawablePtr pDraw)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ValidatePushPixels) (pGC, changes, pDraw);
-}
-
-static void
-XAAStateWrapComputeDash(GCPtr pGC)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ComputeDash) (pGC);
-}
-
-static void
-XAAStateWrapInitPixmapCache(ScreenPtr pScreen, RegionPtr areas, pointer data)
-{
-    GET_STATEPRIV_SCREEN(pScreen);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->InitPixmapCache) (pScreen, areas, data);
-}
-
-static void
-XAAStateWrapClosePixmapCache(ScreenPtr pScreen)
-{
-    GET_STATEPRIV_SCREEN(pScreen);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->ClosePixmapCache) (pScreen);
-}
-
-static int
-XAAStateWrapStippledFillChooser(GCPtr pGC)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->StippledFillChooser) (pGC);
-}
-
-static int
-XAAStateWrapOpaqueStippledFillChooser(GCPtr pGC)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->OpaqueStippledFillChooser) (pGC);
-}
-
-static int
-XAAStateWrapTiledFillChooser(GCPtr pGC)
-{
-    GET_STATEPRIV_GC(pGC);
-    STATE_CHECK_SP(pStatePriv);
-
-    return (*pStatePriv->TiledFillChooser) (pGC);
-}
-
-static XAACacheInfoPtr
-XAAStateWrapCacheTile(ScrnInfoPtr pScrn, PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->CacheTile) (pScrn, pPix);
-}
-
-static XAACacheInfoPtr
-XAAStateWrapCacheStipple(ScrnInfoPtr pScrn, PixmapPtr pPix, int fg, int bg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->CacheStipple) (pScrn, pPix, fg, bg);
-}
-
-static XAACacheInfoPtr
-XAAStateWrapCacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->CacheMonoStipple) (pScrn, pPix);
-}
-
-static XAACacheInfoPtr
-XAAStateWrapCacheMono8x8Pattern(ScrnInfoPtr pScrn, int pat0, int pat1)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->CacheMono8x8Pattern) (pScrn, pat0, pat1);
-}
-
-static XAACacheInfoPtr
-XAAStateWrapCacheColor8x8Pattern(ScrnInfoPtr pScrn, PixmapPtr pPix,
-                                 int fg, int bg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->CacheColor8x8Pattern) (pScrn, pPix, fg, bg);
-}
-
-static void
-XAAStateWrapWriteBitmapToCache(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                               unsigned char *src, int srcwidth, int fg, int bg)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WriteBitmapToCache) (pScrn, x, y, w, h,
-                                       src, srcwidth, fg, bg);
-}
-
-static void
-XAAStateWrapWritePixmapToCache(ScrnInfoPtr pScrn, int x, int y, int w, int h,
-                               unsigned char *src, int srcwidth, int bpp,
-                               int depth)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WritePixmapToCache) (pScrn, x, y, w, h,
-                                       src, srcwidth, bpp, depth);
-}
-
-static void
-XAAStateWrapWriteMono8x8PatternToCache(ScrnInfoPtr pScrn,
-                                       XAACacheInfoPtr pCache)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WriteMono8x8PatternToCache) (pScrn, pCache);
-}
-
-static void
-XAAStateWrapWriteColor8x8PatternToCache(ScrnInfoPtr pScrn, PixmapPtr pPix,
-                                        XAACacheInfoPtr pCache)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    (*pStatePriv->WriteColor8x8PatternToCache) (pScrn, pPix, pCache);
-}
-
-static void
-XAAStateWrapGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
-                     unsigned int format, unsigned long planeMask,
-                     char *pdstLine)
-{
-    GET_STATEPRIV_SCREEN(pDrawable->pScreen);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->GetImage) (pDrawable, sx, sy, w, h,
-                             format, planeMask, pdstLine);
-}
-
-static void
-XAAStateWrapGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
-                     int *pwidth, int nspans, char *pdstStart)
-{
-    GET_STATEPRIV_SCREEN(pDrawable->pScreen);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
-}
-
-static void
-XAAStateWrapCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg,
-                       RegionPtr prgnSrc)
-{
-    GET_STATEPRIV_SCREEN(pWindow->drawable.pScreen);
-    STATE_CHECK_SP(pStatePriv);
-
-    (*pStatePriv->CopyWindow) (pWindow, ptOldOrg, prgnSrc);
-}
-
-static Bool
-XAAStateWrapSetupForCPUToScreenAlphaTexture2(ScrnInfoPtr pScrn,
-                                             int op, CARD16 red,
-                                             CARD16 green,
-                                             CARD16 blue,
-                                             CARD16 alpha,
-                                             CARD32 srcFormat,
-                                             CARD32 dstFormat,
-                                             CARD8 *alphaPtr,
-                                             int alphaPitch,
-                                             int width, int height, int flags)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->SetupForCPUToScreenAlphaTexture2) (pScrn, op, red,
-                                                            green, blue, alpha,
-                                                            srcFormat,
-                                                            dstFormat, alphaPtr,
-                                                            alphaPitch, width,
-                                                            height, flags);
-}
-
-static Bool
-XAAStateWrapSetupForCPUToScreenTexture2(ScrnInfoPtr pScrn, int op,
-                                        CARD32 srcFormat,
-                                        CARD32 dstFormat,
-                                        CARD8 *texPtr, int texPitch,
-                                        int width, int height, int flags)
-{
-    GET_STATEPRIV_PSCRN(pScrn);
-    STATE_CHECK_PSCRN(pScrn);
-
-    return (*pStatePriv->SetupForCPUToScreenTexture2) (pScrn, op, srcFormat,
-                                                       dstFormat, texPtr,
-                                                       texPitch, width, height,
-                                                       flags);
-}
-
-/* Setup Function */
-Bool
-XAAInitStateWrap(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
-{
-    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
-    XAAStateWrapPtr pStatePriv;
-    int i = 0;
-
-    if (!dixRegisterPrivateKey(&XAAStateKeyRec, PRIVATE_SCREEN, 0))
-        return FALSE;
-    if (!(pStatePriv = malloc(sizeof(XAAStateWrapRec))))
-        return FALSE;
-    dixSetPrivate(&pScreen->devPrivates, XAAStateKey, pStatePriv);
-    pStatePriv->RestoreAccelState = infoRec->RestoreAccelState;
-    pStatePriv->pScrn = pScrn;
-
-    /* Initialize the last screen to -1 so whenever an accel function
-     * is called the proper state is setup
-     */
-    while (i < pScrn->numEntities) {
-        xf86SetLastScrnFlag(pScrn->entityList[i], -1);
-        i++;
-    }
-/* Do the wrapping */
-    XAA_STATE_WRAP(Sync);
-    XAA_STATE_WRAP(SetupForScreenToScreenCopy);
-    XAA_STATE_WRAP(SetupForSolidFill);
-    XAA_STATE_WRAP(SetupForSolidLine);
-    XAA_STATE_WRAP(SetupForDashedLine);
-    XAA_STATE_WRAP(SetClippingRectangle);
-    XAA_STATE_WRAP(DisableClipping);
-    XAA_STATE_WRAP(SetupForMono8x8PatternFill);
-    XAA_STATE_WRAP(SetupForColor8x8PatternFill);
-    XAA_STATE_WRAP(SetupForCPUToScreenColorExpandFill);
-    XAA_STATE_WRAP(SetupForScanlineCPUToScreenColorExpandFill);
-    XAA_STATE_WRAP(SetupForScreenToScreenColorExpandFill);
-    XAA_STATE_WRAP(SetupForImageWrite);
-    XAA_STATE_WRAP(SetupForScanlineImageWrite);
-    XAA_STATE_WRAP(SetupForImageRead);
-    XAA_STATE_WRAP(ScreenToScreenBitBlt);
-    XAA_STATE_WRAP(WriteBitmap);
-    XAA_STATE_WRAP(FillSolidRects);
-    XAA_STATE_WRAP(FillMono8x8PatternRects);
-    XAA_STATE_WRAP(FillColor8x8PatternRects);
-    XAA_STATE_WRAP(FillCacheBltRects);
-    XAA_STATE_WRAP(FillColorExpandRects);
-    XAA_STATE_WRAP(FillCacheExpandRects);
-    XAA_STATE_WRAP(FillImageWriteRects);
-    XAA_STATE_WRAP(FillSolidSpans);
-    XAA_STATE_WRAP(FillMono8x8PatternSpans);
-    XAA_STATE_WRAP(FillColor8x8PatternSpans);
-    XAA_STATE_WRAP(FillCacheBltSpans);
-    XAA_STATE_WRAP(FillColorExpandSpans);
-    XAA_STATE_WRAP(FillCacheExpandSpans);
-    XAA_STATE_WRAP(TEGlyphRenderer);
-    XAA_STATE_WRAP(NonTEGlyphRenderer);
-    XAA_STATE_WRAP(WritePixmap);
-    XAA_STATE_WRAP(ReadPixmap);
-    XAA_STATE_WRAP(CopyArea);
-    XAA_STATE_WRAP(CopyPlane);
-    XAA_STATE_WRAP(PushPixelsSolid);
-    XAA_STATE_WRAP(PolyFillRectSolid);
-    XAA_STATE_WRAP(PolyFillRectStippled);
-    XAA_STATE_WRAP(PolyFillRectOpaqueStippled);
-    XAA_STATE_WRAP(PolyFillRectTiled);
-    XAA_STATE_WRAP(FillSpansSolid);
-    XAA_STATE_WRAP(FillSpansStippled);
-    XAA_STATE_WRAP(FillSpansOpaqueStippled);
-    XAA_STATE_WRAP(FillSpansTiled);
-    XAA_STATE_WRAP(PolyText8TE);
-    XAA_STATE_WRAP(PolyText16TE);
-    XAA_STATE_WRAP(ImageText8TE);
-    XAA_STATE_WRAP(ImageText16TE);
-    XAA_STATE_WRAP(ImageGlyphBltTE);
-    XAA_STATE_WRAP(PolyGlyphBltTE);
-    XAA_STATE_WRAP(PolyText8NonTE);
-    XAA_STATE_WRAP(PolyText16NonTE);
-    XAA_STATE_WRAP(ImageText8NonTE);
-    XAA_STATE_WRAP(ImageText16NonTE);
-    XAA_STATE_WRAP(ImageGlyphBltNonTE);
-    XAA_STATE_WRAP(PolyGlyphBltNonTE);
-    XAA_STATE_WRAP(PolyRectangleThinSolid);
-    XAA_STATE_WRAP(PolylinesWideSolid);
-    XAA_STATE_WRAP(PolylinesThinSolid);
-    XAA_STATE_WRAP(PolySegmentThinSolid);
-    XAA_STATE_WRAP(PolylinesThinDashed);
-    XAA_STATE_WRAP(PolySegmentThinDashed);
-    XAA_STATE_WRAP(FillPolygonSolid);
-    XAA_STATE_WRAP(FillPolygonStippled);
-    XAA_STATE_WRAP(FillPolygonOpaqueStippled);
-    XAA_STATE_WRAP(FillPolygonTiled);
-    XAA_STATE_WRAP(PolyFillArcSolid);
-    XAA_STATE_WRAP(PutImage);
-    XAA_STATE_WRAP(ValidateFillSpans);
-    XAA_STATE_WRAP(ValidateSetSpans);
-    XAA_STATE_WRAP(ValidatePutImage);
-    XAA_STATE_WRAP(ValidateCopyArea);
-    XAA_STATE_WRAP(ValidateCopyPlane);
-    XAA_STATE_WRAP(ValidatePolyPoint);
-    XAA_STATE_WRAP(ValidatePolylines);
-    XAA_STATE_WRAP(ValidatePolySegment);
-    XAA_STATE_WRAP(ValidatePolyRectangle);
-    XAA_STATE_WRAP(ValidatePolyArc);
-    XAA_STATE_WRAP(ValidateFillPolygon);
-    XAA_STATE_WRAP(ValidatePolyFillRect);
-    XAA_STATE_WRAP(ValidatePolyFillArc);
-    XAA_STATE_WRAP(ValidatePolyText8);
-    XAA_STATE_WRAP(ValidatePolyText16);
-    XAA_STATE_WRAP(ValidateImageText8);
-    XAA_STATE_WRAP(ValidateImageText16);
-    XAA_STATE_WRAP(ValidatePolyGlyphBlt);
-    XAA_STATE_WRAP(ValidateImageGlyphBlt);
-    XAA_STATE_WRAP(ValidatePushPixels);
-    XAA_STATE_WRAP(ComputeDash);
-    XAA_STATE_WRAP(InitPixmapCache);
-    XAA_STATE_WRAP(ClosePixmapCache);
-    XAA_STATE_WRAP(StippledFillChooser);
-    XAA_STATE_WRAP(OpaqueStippledFillChooser);
-    XAA_STATE_WRAP(TiledFillChooser);
-    XAA_STATE_WRAP(CacheTile);
-    XAA_STATE_WRAP(CacheStipple);
-    XAA_STATE_WRAP(CacheMonoStipple);
-    XAA_STATE_WRAP(CacheMono8x8Pattern);
-    XAA_STATE_WRAP(CacheColor8x8Pattern);
-    XAA_STATE_WRAP(WriteBitmapToCache);
-    XAA_STATE_WRAP(WritePixmapToCache);
-    XAA_STATE_WRAP(WriteMono8x8PatternToCache);
-    XAA_STATE_WRAP(WriteColor8x8PatternToCache);
-    XAA_STATE_WRAP(GetImage);
-    XAA_STATE_WRAP(GetSpans);
-    XAA_STATE_WRAP(CopyWindow);
-    XAA_STATE_WRAP(SetupForCPUToScreenAlphaTexture2);
-    XAA_STATE_WRAP(SetupForCPUToScreenTexture2);
-    return TRUE;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaStipple.c b/xorg-server/hw/xfree86/xaa/xaaStipple.c
deleted file mode 100644
index fc74e3988..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaStipple.c
+++ /dev/null
@@ -1,915 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaacexp.h"
-#include "xf86.h"
-
-static CARD32 *StipplePowerOfTwo(CARD32 *, CARD32 *, int, int, int);
-static CARD32 *StipplePowerOfTwo_Inverted(CARD32 *, CARD32 *, int, int, int);
-static CARD32 *StippleUpTo32(CARD32 *, CARD32 *, int, int, int);
-static CARD32 *StippleUpTo32_Inverted(CARD32 *, CARD32 *, int, int, int);
-static CARD32 *StippleOver32(CARD32 *, CARD32 *, int, int, int);
-static CARD32 *StippleOver32_Inverted(CARD32 *, CARD32 *, int, int, int);
-
-#ifdef TRIPLE_BITS
-#define stipple_scanline_func EXPNAME(XAAStippleScanlineFunc3)
-#define stipple_get_scanline_func EXPNAME(XAAGetStippleScanlineFunc3)
-#else
-#define stipple_scanline_func EXPNAME(XAAStippleScanlineFunc)
-#define stipple_get_scanline_func EXPNAME(XAAGetStippleScanlineFunc)
-#endif
-
-StippleScanlineProcPtr stipple_scanline_func[6] = {
-    StipplePowerOfTwo,
-    StippleUpTo32,
-    StippleOver32,
-    StipplePowerOfTwo_Inverted,
-    StippleUpTo32_Inverted,
-    StippleOver32_Inverted
-};
-
-StippleScanlineProcPtr *
-stipple_get_scanline_func(void)
-{
-    return stipple_scanline_func;
-}
-
-#ifdef FIXEDBASE
-#define DEST(i)	*dest
-#define RETURN(i)	return(dest)
-#else
-#define DEST(i)	dest[i]
-#define RETURN(i)	return(dest + i)
-#endif
-
-/* TRIPLE_BITS pattern expansion */
-#ifdef TRIPLE_BITS
-#define EXPAND_PAT \
-	CARD32 pat1 = byte_expand3[pat & 0xFF], \
-	       pat2 = byte_expand3[(pat & 0xFF00) >> 8], \
-	       pat3 = byte_expand3[(pat & 0xFF0000) >> 16], \
-	       pat4 = byte_expand3[(pat & 0xFF000000) >> 24], \
-	       patA = pat1 | (pat2 << 24), \
-	       patB = (pat2 >> 8) | (pat3 << 16), \
-	       patC = (pat3 >> 16) | (pat4 << 8)
-#ifdef FIXED_BASE
-#define WRITE_PAT1 { \
-	*dest = patA; }
-#define WRITE_PAT2 { \
-	*dest = patA; \
-	*dest = patB; }
-#define WRITE_PAT3 { \
-	*dest = patA; \
-	*dest = patB; \
-	*dest = patC; }
-#else
-#define WRITE_PAT1 { \
-	*(dest++) = patA; }
-#define WRITE_PAT2 { \
-	*(dest) = patA; \
-	*(dest + 1) = patB; \
-	dest += 2; }
-#define WRITE_PAT3 { \
-	*(dest) = patA; \
-	*(dest + 1) = patB; \
-	*(dest + 2) = patC; \
-	dest += 3; }
-#endif
-#endif
-
-#if !defined(FIXEDBASE) && !defined(MSBFIRST) && !defined(TRIPLE_BITS)
-
-unsigned int XAAShiftMasks[32] = {
-    /* gcc is rather pedantic about SHIFT_R(0xFFFFFFFF,32) */
-    0x00000000, SHIFT_R(0xFFFFFFFF, 31),
-    SHIFT_R(0xFFFFFFFF, 30), SHIFT_R(0xFFFFFFFF, 29),
-    SHIFT_R(0xFFFFFFFF, 28), SHIFT_R(0xFFFFFFFF, 27),
-    SHIFT_R(0xFFFFFFFF, 26), SHIFT_R(0xFFFFFFFF, 25),
-    SHIFT_R(0xFFFFFFFF, 24), SHIFT_R(0xFFFFFFFF, 23),
-    SHIFT_R(0xFFFFFFFF, 22), SHIFT_R(0xFFFFFFFF, 21),
-    SHIFT_R(0xFFFFFFFF, 20), SHIFT_R(0xFFFFFFFF, 19),
-    SHIFT_R(0xFFFFFFFF, 18), SHIFT_R(0xFFFFFFFF, 17),
-    SHIFT_R(0xFFFFFFFF, 16), SHIFT_R(0xFFFFFFFF, 15),
-    SHIFT_R(0xFFFFFFFF, 14), SHIFT_R(0xFFFFFFFF, 13),
-    SHIFT_R(0xFFFFFFFF, 12), SHIFT_R(0xFFFFFFFF, 11),
-    SHIFT_R(0xFFFFFFFF, 10), SHIFT_R(0xFFFFFFFF, 9),
-    SHIFT_R(0xFFFFFFFF, 8), SHIFT_R(0xFFFFFFFF, 7),
-    SHIFT_R(0xFFFFFFFF, 6), SHIFT_R(0xFFFFFFFF, 5),
-    SHIFT_R(0xFFFFFFFF, 4), SHIFT_R(0xFFFFFFFF, 3),
-    SHIFT_R(0xFFFFFFFF, 2), SHIFT_R(0xFFFFFFFF, 1)
-};
-
-#endif
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAFillColorExpandRects3) (
-#else
- EXPNAME(XAAFillColorExpandRects) (
-#endif
-                                      ScrnInfoPtr pScrn,
-                                      int fg, int bg, int rop,
-                                      unsigned int planemask,
-                                      int nBox,
-                                      BoxPtr pBox,
-                                      int xorg, int yorg, PixmapPtr pPix) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    Bool TwoPass = FALSE, FirstPass = TRUE;
-    StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
-    int stipplewidth = pPix->drawable.width;
-    int stippleheight = pPix->drawable.height;
-    int srcwidth = pPix->devKind;
-    int dwords, srcy, srcx, funcNo = 2, h;
-    unsigned char *src = (unsigned char *) pPix->devPrivate.ptr;
-    unsigned char *srcp;
-    int flag;
-
-    if (stipplewidth <= 32) {
-        if (stipplewidth & (stipplewidth - 1))
-            funcNo = 1;
-        else
-            funcNo = 0;
-    }
-    StippleFunc = stipple_scanline_func[funcNo];
-    SecondFunc = stipple_scanline_func[funcNo];
-    FirstFunc = stipple_scanline_func[funcNo + 3];
-
-#ifdef TRIPLE_BITS
-    if ((bg == -1) ||
-        (!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) &&
-         (!(infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
-          (CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg == -1) ||
-        !(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        /* one pass */
-    }
-    else if ((rop == GXcopy) && infoRec->FillSolidRects) {
-        /* one pass but we fill background rects first */
-        (*infoRec->FillSolidRects) (pScrn, bg, rop, planemask, nBox, pBox);
-        bg = -1;
-    }
-    else {
-        /* gotta do two passes */
-        TwoPass = TRUE;
-    }
-
-    if (!TwoPass)
-        (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                        planemask);
-
-    while (nBox--) {
-#ifdef TRIPLE_BITS
-        dwords = (3 * (pBox->x2 - pBox->x1) + 31) >> 5;
-#else
-        dwords = (pBox->x2 - pBox->x1 + 31) >> 5;
-#endif
-
- SECOND_PASS:
-        if (TwoPass) {
-            (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn,
-                                                            (FirstPass) ? bg :
-                                                            fg, -1, rop,
-                                                            planemask);
-            StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
-        }
-
-        h = pBox->y2 - pBox->y1;
-        flag = (infoRec->CPUToScreenColorExpandFillFlags
-                & CPU_TRANSFER_PAD_QWORD) && ((dwords * h) & 0x01);
-
-        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, pBox->x1,
-                                                          pBox->y1,
-                                                          pBox->x2 - pBox->x1,
-                                                          h, 0);
-
-        base = (CARD32 *) infoRec->ColorExpandBase;
-
-        srcy = (pBox->y1 - yorg) % stippleheight;
-        if (srcy < 0)
-            srcy += stippleheight;
-        srcx = (pBox->x1 - xorg) % stipplewidth;
-        if (srcx < 0)
-            srcx += stipplewidth;
-
-        srcp = (srcwidth * srcy) + src;
-
-#ifndef FIXEDBASE
-        if ((dwords * h) <= infoRec->ColorExpandRange) {
-            while (h--) {
-                base =
-                    (*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth,
-                                    dwords);
-                srcy++;
-                srcp += srcwidth;
-                if (srcy >= stippleheight) {
-                    srcy = 0;
-                    srcp = src;
-                }
-            }
-        }
-        else
-#endif
-            while (h--) {
-                (*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth,
-                                dwords);
-                srcy++;
-                srcp += srcwidth;
-                if (srcy >= stippleheight) {
-                    srcy = 0;
-                    srcp = src;
-                }
-            }
-
-        if (flag) {
-            base = (CARD32 *) infoRec->ColorExpandBase;
-            base[0] = 0x00000000;
-        }
-
-        if (TwoPass) {
-            if (FirstPass) {
-                FirstPass = FALSE;
-                goto SECOND_PASS;
-            }
-            else
-                FirstPass = TRUE;
-        }
-
-        pBox++;
-    }
-
-    if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAFillColorExpandSpans3) (
-#else
- EXPNAME(XAAFillColorExpandSpans) (
-#endif
-                                      ScrnInfoPtr pScrn,
-                                      int fg, int bg, int rop,
-                                      unsigned int planemask,
-                                      int n,
-                                      DDXPointPtr ppt,
-                                      int *pwidth,
-                                      int fSorted,
-                                      int xorg, int yorg, PixmapPtr pPix) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    Bool TwoPass = FALSE, FirstPass = TRUE;
-    StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
-    int stipplewidth = pPix->drawable.width;
-    int stippleheight = pPix->drawable.height;
-    int dwords, srcy, srcx, funcNo = 2;
-    unsigned char *srcp;
-
-    if (stipplewidth <= 32) {
-        if (stipplewidth & (stipplewidth - 1))
-            funcNo = 1;
-        else
-            funcNo = 0;
-    }
-    StippleFunc = stipple_scanline_func[funcNo];
-    SecondFunc = stipple_scanline_func[funcNo];
-    FirstFunc = stipple_scanline_func[funcNo + 3];
-
-#ifdef TRIPLE_BITS
-    if ((bg == -1) ||
-        (!(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY) &&
-         (!(infoRec->CPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
-          (CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg == -1) ||
-        !(infoRec->CPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        /* one pass */
-    }
-    else if ((rop == GXcopy) && infoRec->FillSolidSpans) {
-        /* one pass but we fill background rects first */
-        (*infoRec->FillSolidSpans) (pScrn, bg, rop, planemask, n, ppt, pwidth,
-                                    fSorted);
-        bg = -1;
-    }
-    else {
-        /* gotta do two passes */
-        TwoPass = TRUE;
-    }
-
-    if (!TwoPass)
-        (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                        planemask);
-
-    while (n--) {
-#ifdef TRIPLE_BITS
-        dwords = (3 * *pwidth + 31) >> 5;
-#else
-        dwords = (*pwidth + 31) >> 5;
-#endif
-
-        srcy = (ppt->y - yorg) % stippleheight;
-        if (srcy < 0)
-            srcy += stippleheight;
-        srcx = (ppt->x - xorg) % stipplewidth;
-        if (srcx < 0)
-            srcx += stipplewidth;
-
-        srcp = (pPix->devKind * srcy) + (unsigned char *) pPix->devPrivate.ptr;
-
- SECOND_PASS:
-        if (TwoPass) {
-            (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn,
-                                                            (FirstPass) ? bg :
-                                                            fg, -1, rop,
-                                                            planemask);
-            StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
-        }
-
-        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, ppt->x, ppt->y,
-                                                          *pwidth, 1, 0);
-
-        base = (CARD32 *) infoRec->ColorExpandBase;
-
-        (*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
-
-        if ((infoRec->CPUToScreenColorExpandFillFlags & CPU_TRANSFER_PAD_QWORD)
-            && (dwords & 0x01)) {
-            base = (CARD32 *) infoRec->ColorExpandBase;
-            base[0] = 0x00000000;
-        }
-
-        if (TwoPass) {
-            if (FirstPass) {
-                FirstPass = FALSE;
-                goto SECOND_PASS;
-            }
-            else
-                FirstPass = TRUE;
-        }
-
-        ppt++;
-        pwidth++;
-    }
-
-    if (infoRec->CPUToScreenColorExpandFillFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-#ifndef FIXEDBASE
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAFillScanlineColorExpandRects3) (
-#else
- EXPNAME(XAAFillScanlineColorExpandRects) (
-#endif
-                                              ScrnInfoPtr pScrn,
-                                              int fg, int bg, int rop,
-                                              unsigned int planemask,
-                                              int nBox,
-                                              BoxPtr pBox,
-                                              int xorg, int yorg,
-                                              PixmapPtr pPix) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    Bool TwoPass = FALSE, FirstPass = TRUE;
-    StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
-    int stipplewidth = pPix->drawable.width;
-    int stippleheight = pPix->drawable.height;
-    int srcwidth = pPix->devKind;
-    int dwords, srcy, srcx, funcNo = 2, bufferNo, h;
-    unsigned char *src = pPix->devPrivate.ptr;
-    unsigned char *srcp;
-
-    if (stipplewidth <= 32) {
-        if (stipplewidth & (stipplewidth - 1))
-            funcNo = 1;
-        else
-            funcNo = 0;
-    }
-    StippleFunc = stipple_scanline_func[funcNo];
-    SecondFunc = stipple_scanline_func[funcNo];
-    FirstFunc = stipple_scanline_func[funcNo + 3];
-
-#ifdef TRIPLE_BITS
-    if ((bg == -1) ||
-        (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
-         && (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
-             (CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg == -1) ||
-        !(infoRec->
-          ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        /* one pass */
-    }
-    else if ((rop == GXcopy) && infoRec->FillSolidRects) {
-        /* one pass but we fill background rects first */
-        (*infoRec->FillSolidRects) (pScrn, bg, rop, planemask, nBox, pBox);
-        bg = -1;
-    }
-    else {
-        /* gotta do two passes */
-        TwoPass = TRUE;
-    }
-
-    if (!TwoPass)
-        (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg,
-                                                                rop, planemask);
-
-    while (nBox--) {
-#ifdef TRIPLE_BITS
-        dwords = (3 * (pBox->x2 - pBox->x1) + 31) >> 5;
-#else
-        dwords = (pBox->x2 - pBox->x1 + 31) >> 5;
-#endif
-
- SECOND_PASS:
-        if (TwoPass) {
-            (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn,
-                                                                    (FirstPass)
-                                                                    ? bg : fg,
-                                                                    -1, rop,
-                                                                    planemask);
-            StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
-        }
-
-        h = pBox->y2 - pBox->y1;
-
-        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn,
-                                                                  pBox->x1,
-                                                                  pBox->y1,
-                                                                  pBox->x2 -
-                                                                  pBox->x1, h,
-                                                                  0);
-
-        bufferNo = 0;
-
-        srcy = (pBox->y1 - yorg) % stippleheight;
-        if (srcy < 0)
-            srcy += stippleheight;
-        srcx = (pBox->x1 - xorg) % stipplewidth;
-        if (srcx < 0)
-            srcx += stipplewidth;
-
-        srcp = (srcwidth * srcy) + src;
-
-        while (h--) {
-            base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-            (*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
-            (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-            if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-                bufferNo = 0;
-            srcy++;
-            srcp += srcwidth;
-            if (srcy >= stippleheight) {
-                srcy = 0;
-                srcp = src;
-            }
-        }
-
-        if (TwoPass) {
-            if (FirstPass) {
-                FirstPass = FALSE;
-                goto SECOND_PASS;
-            }
-            else
-                FirstPass = TRUE;
-        }
-
-        pBox++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-#ifdef TRIPLE_BITS
- EXPNAME(XAAFillScanlineColorExpandSpans3) (
-#else
- EXPNAME(XAAFillScanlineColorExpandSpans) (
-#endif
-                                              ScrnInfoPtr pScrn,
-                                              int fg, int bg, int rop,
-                                              unsigned int planemask,
-                                              int n,
-                                              DDXPointPtr ppt,
-                                              int *pwidth,
-                                              int fSorted,
-                                              int xorg, int yorg,
-                                              PixmapPtr pPix) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    Bool TwoPass = FALSE, FirstPass = TRUE;
-    StippleScanlineProcPtr StippleFunc, FirstFunc, SecondFunc;
-    int stipplewidth = pPix->drawable.width;
-    int stippleheight = pPix->drawable.height;
-    int dwords, srcy, srcx, funcNo = 2;
-    unsigned char *srcp;
-
-    if (stipplewidth <= 32) {
-        if (stipplewidth & (stipplewidth - 1))
-            funcNo = 1;
-        else
-            funcNo = 0;
-    }
-    StippleFunc = stipple_scanline_func[funcNo];
-    SecondFunc = stipple_scanline_func[funcNo];
-    FirstFunc = stipple_scanline_func[funcNo + 3];
-
-#ifdef TRIPLE_BITS
-    if ((bg == -1) ||
-        (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)
-         && (!(infoRec->ScanlineCPUToScreenColorExpandFillFlags & RGB_EQUAL) ||
-             (CHECK_RGB_EQUAL(bg))))) {
-#else
-    if ((bg == -1) ||
-        !(infoRec->
-          ScanlineCPUToScreenColorExpandFillFlags & TRANSPARENCY_ONLY)) {
-#endif
-        /* one pass */
-    }
-    else if ((rop == GXcopy) && infoRec->FillSolidSpans) {
-        /* one pass but we fill background rects first */
-        (*infoRec->FillSolidSpans) (pScrn, bg, rop, planemask, n, ppt, pwidth,
-                                    fSorted);
-        bg = -1;
-    }
-    else {
-        /* gotta do two passes */
-        TwoPass = TRUE;
-    }
-
-    if (!TwoPass)
-        (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg,
-                                                                rop, planemask);
-
-    while (n--) {
-#ifdef TRIPLE_BITS
-        dwords = (3 * *pwidth + 31) >> 5;
-#else
-        dwords = (*pwidth + 31) >> 5;
-#endif
-
-        srcy = (ppt->y - yorg) % stippleheight;
-        if (srcy < 0)
-            srcy += stippleheight;
-        srcx = (ppt->x - xorg) % stipplewidth;
-        if (srcx < 0)
-            srcx += stipplewidth;
-
-        srcp = (pPix->devKind * srcy) + (unsigned char *) pPix->devPrivate.ptr;
-
- SECOND_PASS:
-        if (TwoPass) {
-            (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn,
-                                                                    (FirstPass)
-                                                                    ? bg : fg,
-                                                                    -1, rop,
-                                                                    planemask);
-            StippleFunc = (FirstPass) ? FirstFunc : SecondFunc;
-        }
-
-        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, ppt->x,
-                                                                  ppt->y,
-                                                                  *pwidth, 1,
-                                                                  0);
-
-        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[0];
-
-        (*StippleFunc) (base, (CARD32 *) srcp, srcx, stipplewidth, dwords);
-        (*infoRec->SubsequentColorExpandScanline) (pScrn, 0);
-
-        if (TwoPass) {
-            if (FirstPass) {
-                FirstPass = FALSE;
-                goto SECOND_PASS;
-            }
-            else
-                FirstPass = TRUE;
-        }
-
-        ppt++;
-        pwidth++;
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-#endif
-
-static CARD32 *
-StipplePowerOfTwo(CARD32 *dest, CARD32 *src, int shift, int width, int dwords)
-{
-    CARD32 pat = *src;
-
-    if (width < 32) {
-        pat &= XAAShiftMasks[width];
-        while (width < 32) {
-            pat |= SHIFT_L(pat, width);
-            width <<= 1;
-        }
-    }
-
-    if (shift)
-        pat = SHIFT_R(pat, shift) | SHIFT_L(pat, 32 - shift);
-
-#ifdef MSBFIRST
-    pat = SWAP_BITS_IN_BYTES(pat);
-#endif
-
-#ifdef TRIPLE_BITS
-    {
-        EXPAND_PAT;
-
-        while (dwords >= 3) {
-            WRITE_PAT3;
-            dwords -= 3;
-        }
-        if (dwords == 2) {
-            WRITE_PAT2;
-        }
-        else if (dwords == 1) {
-            WRITE_PAT1;
-        }
-
-        return dest;
-    }
-#else                           /* TRIPLE_BITS */
-    while (dwords >= 4) {
-        DEST(0) = pat;
-        DEST(1) = pat;
-        DEST(2) = pat;
-        DEST(3) = pat;
-        dwords -= 4;
-#ifndef FIXEDBASE
-        dest += 4;
-#endif
-    }
-
-    if (!dwords)
-        return dest;
-    DEST(0) = pat;
-    if (dwords == 1)
-        RETURN(1);
-    DEST(1) = pat;
-    if (dwords == 2)
-        RETURN(2);
-    DEST(2) = pat;
-    RETURN(3);
-#endif                          /* TRIPLE_BITS */
-}
-
-static CARD32 *
-StipplePowerOfTwo_Inverted(CARD32 *dest, CARD32 *src,
-                           int shift, int width, int dwords)
-{
-    CARD32 pat = *src;
-
-    if (width < 32) {
-        pat &= XAAShiftMasks[width];
-        while (width < 32) {
-            pat |= SHIFT_L(pat, width);
-            width <<= 1;
-        }
-    }
-
-    if (shift)
-        pat = SHIFT_R(pat, shift) | SHIFT_L(pat, 32 - shift);
-
-#ifdef MSBFIRST
-    pat = SWAP_BITS_IN_BYTES(pat);
-#endif
-
-    pat = ~pat;
-
-#ifdef TRIPLE_BITS
-    {
-        EXPAND_PAT;
-
-        while (dwords >= 3) {
-            WRITE_PAT3;
-            dwords -= 3;
-        }
-        if (dwords == 2) {
-            WRITE_PAT2;
-        }
-        else if (dwords == 1) {
-            WRITE_PAT1;
-        }
-
-        return dest;
-    }
-#else                           /* TRIPLE_BITS */
-    while (dwords >= 4) {
-        DEST(0) = pat;
-        DEST(1) = pat;
-        DEST(2) = pat;
-        DEST(3) = pat;
-        dwords -= 4;
-#ifndef FIXEDBASE
-        dest += 4;
-#endif
-    }
-
-    if (!dwords)
-        return dest;
-    DEST(0) = pat;
-    if (dwords == 1)
-        RETURN(1);
-    DEST(1) = pat;
-    if (dwords == 2)
-        RETURN(2);
-    DEST(2) = pat;
-    RETURN(3);
-#endif                          /* TRIPLE_BITS */
-}
-
-static CARD32 *
-StippleUpTo32(CARD32 *base, CARD32 *src, int shift, int width, int dwords)
-{
-    CARD32 pat = *src & XAAShiftMasks[width];
-
-    while (width <= 15) {
-        pat |= SHIFT_L(pat, width);
-        width <<= 1;
-    }
-    pat |= SHIFT_L(pat, width);
-
-    while (dwords--) {
-        CARD32 bits = SHIFT_R(pat, shift) | SHIFT_L(pat, width - shift);
-
-#ifdef TRIPLE_BITS
-        if (dwords >= 2) {
-            WRITE_BITS3(bits);
-            dwords -= 2;
-        }
-        else if (dwords > 0) {
-            WRITE_BITS2(bits);
-            dwords--;
-        }
-        else {
-            WRITE_BITS1(bits);
-        }
-#else
-        WRITE_BITS(bits);
-#endif
-
-        shift += 32;
-        shift %= width;
-    }
-    return base;
-}
-
-static CARD32 *
-StippleUpTo32_Inverted(CARD32 *base, CARD32 *src,
-                       int shift, int width, int dwords)
-{
-    CARD32 pat = *src & XAAShiftMasks[width];
-
-    while (width <= 15) {
-        pat |= SHIFT_L(pat, width);
-        width <<= 1;
-    }
-    pat |= SHIFT_L(pat, width);
-
-    while (dwords--) {
-        CARD32 bits = ~(SHIFT_R(pat, shift) | SHIFT_L(pat, width - shift));
-
-#ifdef TRIPLE_BITS
-        if (dwords >= 2) {
-            WRITE_BITS3(bits);
-            dwords -= 2;
-        }
-        else if (dwords > 0) {
-            WRITE_BITS2(bits);
-            dwords--;
-        }
-        else {
-            WRITE_BITS1(bits);
-        }
-#else
-        WRITE_BITS(bits);
-#endif
-
-        shift += 32;
-        shift %= width;
-    }
-    return base;
-}
-
-static CARD32 *
-StippleOver32(CARD32 *base, CARD32 *src, int offset, int width, int dwords)
-{
-    CARD32 *srcp;
-    CARD32 bits;
-    int bitsleft, shift, usable;
-
-    while (dwords--) {
-        bitsleft = width - offset;
-        srcp = src + (offset >> 5);
-        shift = offset & 31;
-        usable = 32 - shift;
-
-        if (bitsleft < 32) {
-            if (bitsleft <= usable) {
-                bits = SHIFT_L(*src, bitsleft) |
-                    (SHIFT_R(*srcp, shift) & XAAShiftMasks[bitsleft]);
-            }
-            else {
-                bits = SHIFT_L(*src, bitsleft) |
-                    (SHIFT_L(srcp[1], usable) & XAAShiftMasks[bitsleft]) |
-                    (SHIFT_R(*srcp, shift) & XAAShiftMasks[usable]);
-            }
-        }
-        else if (shift)
-            bits = SHIFT_R(*srcp, shift) | SHIFT_L(srcp[1], usable);
-        else
-            bits = *srcp;
-
-#ifdef TRIPLE_BITS
-        if (dwords >= 2) {
-            WRITE_BITS3(bits);
-            dwords -= 2;
-        }
-        else if (dwords > 0) {
-            WRITE_BITS2(bits);
-            dwords--;
-        }
-        else {
-            WRITE_BITS1(bits);
-        }
-#else
-        WRITE_BITS(bits);
-#endif
-
-        offset += 32;
-        offset %= width;
-    }
-    return base;
-}
-
-static CARD32 *
-StippleOver32_Inverted(CARD32 *base, CARD32 *src,
-                       int offset, int width, int dwords)
-{
-    CARD32 *srcp;
-    CARD32 bits;
-    int bitsleft, shift, usable;
-
-    while (dwords--) {
-        bitsleft = width - offset;
-        srcp = src + (offset >> 5);
-        shift = offset & 31;
-        usable = 32 - shift;
-
-        if (bitsleft < 32) {
-            if (bitsleft <= usable) {
-                bits = SHIFT_L(*src, bitsleft) |
-                    (SHIFT_R(*srcp, shift) & XAAShiftMasks[bitsleft]);
-            }
-            else {
-                bits = SHIFT_L(*src, bitsleft) |
-                    (SHIFT_L(srcp[1], usable) & XAAShiftMasks[bitsleft]) |
-                    (SHIFT_R(*srcp, shift) & XAAShiftMasks[usable]);
-            }
-        }
-        else if (shift)
-            bits = SHIFT_R(*srcp, shift) | SHIFT_L(srcp[1], usable);
-        else
-            bits = *srcp;
-
-        bits = ~bits;
-
-#ifdef TRIPLE_BITS
-        if (dwords >= 2) {
-            WRITE_BITS3(bits);
-            dwords -= 2;
-        }
-        else if (dwords > 0) {
-            WRITE_BITS2(bits);
-            dwords--;
-        }
-        else {
-            WRITE_BITS1(bits);
-        }
-#else
-        WRITE_BITS(bits);
-#endif
-
-        offset += 32;
-        offset %= width;
-    }
-    return base;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaTEGlyph.c b/xorg-server/hw/xfree86/xaa/xaaTEGlyph.c
deleted file mode 100644
index 2926c1df2..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaTEGlyph.c
+++ /dev/null
@@ -1,1083 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaacexp.h"
-#include "xf86.h"
-
-/* scanline function for TRIPLE_BITS_24BPP */
-static CARD32 *DrawTextScanline3(CARD32 *base, CARD32 *mem, int width);
-
-/* Loop unrolled functions for common font widths */
-static CARD32 *DrawTETextScanlineGeneric(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth7(CARD32 *base, unsigned int **glyphp,
-                                        int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth10(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth12(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth14(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth16(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth18(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth24(CARD32 *base, unsigned int **glyphp,
-                                         int line, int width, int glyphwidth);
-
-#ifdef USEASSEMBLER
-#ifdef FIXEDBASE
-#ifdef MSBFIRST
-CARD32 *DrawTETextScanlineWidth6PMSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-CARD32 *DrawTETextScanlineWidth8PMSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-CARD32 *DrawTETextScanlineWidth9PMSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-#else
-CARD32 *DrawTETextScanlineWidth6PLSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-CARD32 *DrawTETextScanlineWidth8PLSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-CARD32 *DrawTETextScanlineWidth9PLSBFirstFixedBase(CARD32 *base,
-                                                   unsigned int **glyphp,
-                                                   int line, int width,
-                                                   int glyphwidth);
-#endif
-#else
-#ifdef MSBFIRST
-CARD32 *DrawTETextScanlineWidth6PMSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-CARD32 *DrawTETextScanlineWidth8PMSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-CARD32 *DrawTETextScanlineWidth9PMSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-#else
-CARD32 *DrawTETextScanlineWidth6PLSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-CARD32 *DrawTETextScanlineWidth8PLSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-CARD32 *DrawTETextScanlineWidth9PLSBFirst(CARD32 *base, unsigned int **glyphp,
-                                          int line, int width, int glyphwidth);
-#endif
-#endif
-#else
-static CARD32 *DrawTETextScanlineWidth6(CARD32 *base, unsigned int **glyphp,
-                                        int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth8(CARD32 *base, unsigned int **glyphp,
-                                        int line, int width, int glyphwidth);
-static CARD32 *DrawTETextScanlineWidth9(CARD32 *base, unsigned int **glyphp,
-                                        int line, int width, int glyphwidth);
-#endif
-
-#define glyph_scanline_func EXPNAME(XAAGlyphScanlineFunc)
-#define glyph_get_scanline_func EXPNAME(XAAGetGlyphScanlineFunc)
-
-GlyphScanlineFuncPtr glyph_scanline_func[32] = {
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric,
-#ifdef USEASSEMBLER
-#ifdef FIXEDBASE
-#ifdef MSBFIRST
-    DrawTETextScanlineWidth6PMSBFirstFixedBase,
-    DrawTETextScanlineWidth7,
-    DrawTETextScanlineWidth8PMSBFirstFixedBase,
-    DrawTETextScanlineWidth9PMSBFirstFixedBase,
-#else
-    DrawTETextScanlineWidth6PLSBFirstFixedBase,
-    DrawTETextScanlineWidth7,
-    DrawTETextScanlineWidth8PLSBFirstFixedBase,
-    DrawTETextScanlineWidth9PLSBFirstFixedBase,
-#endif
-#else
-#ifdef MSBFIRST
-    DrawTETextScanlineWidth6PMSBFirst,
-    DrawTETextScanlineWidth7,
-    DrawTETextScanlineWidth8PMSBFirst,
-    DrawTETextScanlineWidth9PMSBFirst,
-#else
-    DrawTETextScanlineWidth6PLSBFirst,
-    DrawTETextScanlineWidth7,
-    DrawTETextScanlineWidth8PLSBFirst,
-    DrawTETextScanlineWidth9PLSBFirst,
-#endif
-#endif
-#else
-    DrawTETextScanlineWidth6, DrawTETextScanlineWidth7,
-    DrawTETextScanlineWidth8, DrawTETextScanlineWidth9,
-#endif
-    DrawTETextScanlineWidth10,
-    DrawTETextScanlineGeneric, DrawTETextScanlineWidth12,
-    DrawTETextScanlineGeneric, DrawTETextScanlineWidth14,
-    DrawTETextScanlineGeneric, DrawTETextScanlineWidth16,
-    DrawTETextScanlineGeneric, DrawTETextScanlineWidth18,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineWidth24,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
-    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric
-};
-
-GlyphScanlineFuncPtr *
-glyph_get_scanline_func(void)
-{
-    return glyph_scanline_func;
-}
-
-/********************************************************************
-
-   Here we have TEGlyphRenders for a bunch of different color
-   expansion types.  The driver may provide its own renderer, but
-   this is the default one which renders using lower-level primitives
-   exported by the chipset driver.
-
-********************************************************************/
-
-/* This gets built for MSBFIRST or LSBFIRST with FIXEDBASE or not.
-	A total of 4 versions */
-
-void
-
-EXPNAME(XAATEGlyphRenderer) (ScrnInfoPtr pScrn,
-                             int x, int y, int w, int h, int skipleft,
-                             int startline, unsigned int **glyphs,
-                             int glyphWidth, int fg, int bg, int rop,
-                             unsigned planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base;
-    GlyphScanlineFuncPtr GlyphFunc = glyph_scanline_func[glyphWidth - 1];
-    int dwords = 0;
-
-    if ((bg != -1) && (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
-        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        bg = -1;
-    }
-
-    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                    planemask);
-
-    if (skipleft &&
-        (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING) ||
-         (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
-          (skipleft > x)))) {
-        /* draw the first character only */
-
-        int count = h, line = startline;
-        int width = glyphWidth - skipleft;
-
-        if (width > w)
-            width = w;
-
-        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, width, h,
-                                                          0);
-
-        base = (CARD32 *) infoRec->ColorExpandBase;
-
-        while (count--) {
-            register CARD32 tmp = SHIFT_R(glyphs[0][line++], skipleft);
-
-            WRITE_BITS(tmp);
-        }
-
-        w -= width;
-        if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
-            ((((width + 31) >> 5) * h) & 1)) {
-            base = (CARD32 *) infoRec->ColorExpandBase;
-            base[0] = 0x00000000;
-        }
-        if (!w)
-            goto THE_END;
-        glyphs++;
-        x += width;
-        skipleft = 0;           /* nicely aligned again */
-    }
-
-    w += skipleft;
-    x -= skipleft;
-    dwords = ((w + 31) >> 5) * h;
-
-    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
-                                                      skipleft);
-
-    base = (CARD32 *) infoRec->ColorExpandBase;
-
-#ifndef FIXEDBASE
-    if ((((w + 31) >> 5) * h) <= infoRec->ColorExpandRange)
-        while (h--) {
-            base = (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
-        }
-    else
-#endif
-        while (h--) {
-            (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
-        }
-
-    if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
-        (dwords & 1)) {
-        base = (CARD32 *) infoRec->ColorExpandBase;
-        base[0] = 0x00000000;
-    }
-
- THE_END:
-
-    if (infoRec->TEGlyphRendererFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-/********************************************************************
- 
-   This is the GlyphRenderer for TRIPLE_BITS_24BPP. It renders to a buffer
-   with the non FIXEDBASE LSB_FIRST code before tripling, and possibly
-   reversing the bits and sending them to the screen
-
-********************************************************************/
-
-void
-
-EXPNAME(XAATEGlyphRenderer3) (ScrnInfoPtr pScrn,
-                              int x, int y, int w, int h, int skipleft,
-                              int startline, unsigned int **glyphs,
-                              int glyphWidth, int fg, int bg, int rop,
-                              unsigned planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    CARD32 *base, *mem;
-    GlyphScanlineFuncPtr GlyphFunc =
-        XAAGlyphScanlineFuncLSBFirst[glyphWidth - 1];
-    int dwords = 0;
-
-    if ((bg != -1) &&
-        ((infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY) ||
-         ((infoRec->TEGlyphRendererFlags & RGB_EQUAL) &&
-          (!CHECK_RGB_EQUAL(bg))))) {
-        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        bg = -1;
-    }
-
-    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                    planemask);
-
-    if (skipleft) {
-        /* draw the first character only */
-
-        int count = h, line = startline;
-        int width = glyphWidth - skipleft;
-        CARD32 bits;
-
-        if (width > w)
-            width = w;
-        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, width, h,
-                                                          0);
-
-        base = (CARD32 *) infoRec->ColorExpandBase;
-
-        while (count--) {
-            bits = SHIFT_R(glyphs[0][line++], skipleft);
-            if (width >= 22) {
-                WRITE_BITS3(bits);
-            }
-            else if (width >= 11) {
-                WRITE_BITS2(bits);
-            }
-            else {
-                WRITE_BITS1(bits);
-            }
-        }
-
-        w -= width;
-        if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
-            ((((3 * width + 31) >> 5) * h) & 1)) {
-            base = (CARD32 *) infoRec->ColorExpandBase;
-            base[0] = 0x00000000;
-        }
-        if (!w)
-            goto THE_END;
-        glyphs++;
-        x += width;
-        skipleft = 0;           /* nicely aligned again */
-    }
-
-    dwords = ((3 * w + 31) >> 5) * h;
-    mem = (CARD32 *) malloc(((w + 31) >> 3) * sizeof(char));
-    if (!mem)
-        return;
-
-    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h, 0);
-
-    base = (CARD32 *) infoRec->ColorExpandBase;
-
-#ifndef FIXEDBASE
-    if ((((3 * w + 31) >> 5) * h) <= infoRec->ColorExpandRange)
-        while (h--) {
-            (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
-            base = DrawTextScanline3(base, mem, w);
-        }
-    else
-#endif
-        while (h--) {
-            (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
-            DrawTextScanline3(base, mem, w);
-        }
-
-    free(mem);
-
-    if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
-        (dwords & 1)) {
-        base = (CARD32 *) infoRec->ColorExpandBase;
-        base[0] = 0x00000000;
-    }
-
- THE_END:
-
-    if (infoRec->TEGlyphRendererFlags & SYNC_AFTER_COLOR_EXPAND)
-        (*infoRec->Sync) (pScrn);
-    else
-        SET_SYNC_FLAG(infoRec);
-}
-
-#ifndef FIXEDBASE
-/*  Scanline version of above gets built for LSBFIRST and MSBFIRST */
-
-void
-
-EXPNAME(XAATEGlyphRendererScanline) (ScrnInfoPtr pScrn,
-                                     int x, int y, int w, int h, int skipleft,
-                                     int startline, unsigned int **glyphs,
-                                     int glyphWidth, int fg, int bg, int rop,
-                                     unsigned planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int bufferNo;
-    CARD32 *base;
-    GlyphScanlineFuncPtr GlyphFunc = glyph_scanline_func[glyphWidth - 1];
-
-    if ((bg != -1) && (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
-        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        bg = -1;
-    }
-
-    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                            planemask);
-
-    if (skipleft &&
-        (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING) ||
-         (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
-          (skipleft > x)))) {
-        /* draw the first character only */
-
-        int count = h, line = startline;
-        int width = glyphWidth - skipleft;
-
-        if (width > w)
-            width = w;
-
-        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y,
-                                                                  width, h, 0);
-
-        bufferNo = 0;
-
-        while (count--) {
-            register CARD32 tmp = SHIFT_R(glyphs[0][line++], skipleft);
-
-            base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-            WRITE_BITS(tmp);
-            (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-            if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-                bufferNo = 0;
-        }
-
-        w -= width;
-        if (!w)
-            goto THE_END;
-        glyphs++;
-        x += width;
-        skipleft = 0;           /* nicely aligned again */
-    }
-
-    w += skipleft;
-    x -= skipleft;
-
-    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
-                                                              skipleft);
-
-    bufferNo = 0;
-
-    while (h--) {
-        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-        (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
-        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-            bufferNo = 0;
-    }
-
- THE_END:
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-void
-
-EXPNAME(XAATEGlyphRendererScanline3) (ScrnInfoPtr pScrn,
-                                      int x, int y, int w, int h, int skipleft,
-                                      int startline, unsigned int **glyphs,
-                                      int glyphWidth, int fg, int bg, int rop,
-                                      unsigned planemask) {
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int bufferNo;
-    CARD32 *base, *mem;
-    GlyphScanlineFuncPtr GlyphFunc =
-        XAAGlyphScanlineFuncLSBFirst[glyphWidth - 1];
-
-    if ((bg != -1) &&
-        ((infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY) ||
-         ((infoRec->TEGlyphRendererFlags & RGB_EQUAL) &&
-          (!CHECK_RGB_EQUAL(bg))))) {
-        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
-        bg = -1;
-    }
-
-    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
-                                                            planemask);
-
-    if (skipleft) {
-        /* draw the first character only */
-
-        int count = h, line = startline;
-        int width = glyphWidth - skipleft;
-        CARD32 bits;
-
-        if (width > w)
-            width = w;
-
-        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y,
-                                                                  width, h, 0);
-
-        bufferNo = 0;
-
-        while (count--) {
-            base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-            bits = SHIFT_R(glyphs[0][line++], skipleft);
-            if (width >= 22) {
-                WRITE_BITS3(bits);
-            }
-            else if (width >= 11) {
-                WRITE_BITS2(bits);
-            }
-            else {
-                WRITE_BITS1(bits);
-            }
-            (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-            if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-                bufferNo = 0;
-        }
-
-        w -= width;
-        if (!w)
-            goto THE_END;
-        glyphs++;
-        x += width;
-        skipleft = 0;           /* nicely aligned again */
-    }
-
-    w += skipleft;
-    x -= skipleft;
-    mem = (CARD32 *) malloc(((w + 31) >> 3) * sizeof(char));
-    if (!mem)
-        return;
-
-    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
-                                                              skipleft);
-
-    bufferNo = 0;
-
-    while (h--) {
-        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
-        (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
-        DrawTextScanline3(base, mem, w);
-        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
-        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
-            bufferNo = 0;
-    }
-
-    free(mem);
-
- THE_END:
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-#endif
-
-/********************************************************************
-
-   TRIPLE_BITS_24BPP scanline rendering code.
-
-********************************************************************/
-
-static CARD32 *
-DrawTextScanline3(CARD32 *base, CARD32 *mem, int width)
-{
-
-    while (width > 32) {
-        WRITE_BITS3(*mem);
-        mem++;
-        width -= 32;
-    }
-    if (width) {
-        if (width >= 22) {
-            WRITE_BITS3(*mem);
-        }
-        else if (width >= 11) {
-            WRITE_BITS2(*mem);
-        }
-        else {
-            WRITE_BITS1(*mem);
-        }
-    }
-
-    return base;
-}
-
-/********************************************************************
-
-   Generic TE scanline rendering code.
-
-********************************************************************/
-
-static CARD32 *
-DrawTETextScanlineGeneric(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    CARD32 bits = (*glyphp)[line];
-    int shift = glyphwidth;
-
-    while (width > 32) {
-        while (shift < 32) {
-            glyphp++;
-            bits |= SHIFT_L((*glyphp)[line], shift);
-            shift += glyphwidth;
-        }
-        WRITE_BITS(bits);
-        shift &= 31;
-        if (shift)
-            bits = SHIFT_R((*glyphp)[line], (glyphwidth - shift));
-        else
-            bits = 0;
-        width -= 32;
-    }
-
-    if (width) {
-        width -= shift;
-        while (width > 0) {
-            glyphp++;
-            bits |= SHIFT_L((*glyphp)[line], shift);
-            shift += glyphwidth;
-            width -= glyphwidth;
-        }
-        WRITE_BITS(bits);
-    }
-
-    return base;
-}
-
-/********************************************************************
-
-   Loop unrolled TE font scanline rendering code
-
-********************************************************************/
-
-#ifndef USEASSEMBLER
-static CARD32 *
-DrawTETextScanlineWidth6(CARD32 *base,
-                         unsigned int **glyphp,
-                         int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 6);
-        bits |= SHIFT_L(glyphp[2][line], 12);
-        bits |= SHIFT_L(glyphp[3][line], 18);
-        bits |= SHIFT_L(glyphp[4][line], 24);
-        bits |= SHIFT_L(glyphp[5][line], 30);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[5][line], 2);
-        bits |= SHIFT_L(glyphp[6][line], 4);
-        bits |= SHIFT_L(glyphp[7][line], 10);
-        bits |= SHIFT_L(glyphp[8][line], 16);
-        bits |= SHIFT_L(glyphp[9][line], 22);
-        bits |= SHIFT_L(glyphp[10][line], 28);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[10][line], 4);
-        bits |= SHIFT_L(glyphp[11][line], 2);
-        bits |= SHIFT_L(glyphp[12][line], 8);
-        bits |= SHIFT_L(glyphp[13][line], 14);
-        bits |= SHIFT_L(glyphp[14][line], 20);
-        bits |= SHIFT_L(glyphp[15][line], 26);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-#ifndef FIXEDBASE
-        base += 3;
-#endif
-        width -= 96;
-        glyphp += 16;
-    }
-    return base;
-}
-#endif
-
-static CARD32 *
-DrawTETextScanlineWidth7(CARD32 *base,
-                         unsigned int **glyphp,
-                         int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 7);
-        bits |= SHIFT_L(glyphp[2][line], 14);
-        bits |= SHIFT_L(glyphp[3][line], 21);
-        bits |= SHIFT_L(glyphp[4][line], 28);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[4][line], 4);
-        bits |= SHIFT_L(glyphp[5][line], 3);
-        bits |= SHIFT_L(glyphp[6][line], 10);
-        bits |= SHIFT_L(glyphp[7][line], 17);
-        bits |= SHIFT_L(glyphp[8][line], 24);
-        bits |= SHIFT_L(glyphp[9][line], 31);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[9][line], 1);
-        bits |= SHIFT_L(glyphp[10][line], 6);
-        bits |= SHIFT_L(glyphp[11][line], 13);
-        bits |= SHIFT_L(glyphp[12][line], 20);
-        bits |= SHIFT_L(glyphp[13][line], 27);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = SHIFT_R(glyphp[13][line], 5);
-        bits |= SHIFT_L(glyphp[14][line], 2);
-        bits |= SHIFT_L(glyphp[15][line], 9);
-        bits |= SHIFT_L(glyphp[16][line], 16);
-        bits |= SHIFT_L(glyphp[17][line], 23);
-        bits |= SHIFT_L(glyphp[18][line], 30);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-        bits = SHIFT_R(glyphp[18][line], 2);
-        bits |= SHIFT_L(glyphp[19][line], 5);
-        bits |= SHIFT_L(glyphp[20][line], 12);
-        bits |= SHIFT_L(glyphp[21][line], 19);
-        bits |= SHIFT_L(glyphp[22][line], 26);
-        WRITE_IN_BITORDER(base, 4, bits);
-        CHECKRETURN(5);
-        bits = SHIFT_R(glyphp[22][line], 6);
-        bits |= SHIFT_L(glyphp[23][line], 1);
-        bits |= SHIFT_L(glyphp[24][line], 8);
-        bits |= SHIFT_L(glyphp[25][line], 15);
-        bits |= SHIFT_L(glyphp[26][line], 22);
-        bits |= SHIFT_L(glyphp[27][line], 29);
-        WRITE_IN_BITORDER(base, 5, bits);
-        CHECKRETURN(6);
-        bits = SHIFT_R(glyphp[27][line], 3);
-        bits |= SHIFT_L(glyphp[28][line], 4);
-        bits |= SHIFT_L(glyphp[29][line], 11);
-        bits |= SHIFT_L(glyphp[30][line], 18);
-        bits |= SHIFT_L(glyphp[31][line], 25);
-        WRITE_IN_BITORDER(base, 6, bits);
-        CHECKRETURN(7);
-#ifndef FIXEDBASE
-        base += 7;
-#endif
-        width -= 224;
-        glyphp += 32;
-    }
-    return base;
-}
-
-#ifndef USEASSEMBLER
-static CARD32 *
-DrawTETextScanlineWidth8(CARD32 *base,
-                         unsigned int **glyphp,
-                         int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 8);
-        bits |= SHIFT_L(glyphp[2][line], 16);
-        bits |= SHIFT_L(glyphp[3][line], 24);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = glyphp[4][line];
-        bits |= SHIFT_L(glyphp[5][line], 8);
-        bits |= SHIFT_L(glyphp[6][line], 16);
-        bits |= SHIFT_L(glyphp[7][line], 24);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-#ifndef FIXEDBASE
-        base += 2;
-#endif
-        width -= 64;
-        glyphp += 8;
-    }
-    return base;
-}
-#endif
-
-#ifndef USEASSEMBLER
-static CARD32 *
-DrawTETextScanlineWidth9(CARD32 *base,
-                         unsigned int **glyphp,
-                         int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 9);
-        bits |= SHIFT_L(glyphp[2][line], 18);
-        bits |= SHIFT_L(glyphp[3][line], 27);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[3][line], 5);
-        bits |= SHIFT_L(glyphp[4][line], 4);
-        bits |= SHIFT_L(glyphp[5][line], 13);
-        bits |= SHIFT_L(glyphp[6][line], 22);
-        bits |= SHIFT_L(glyphp[7][line], 31);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[7][line], 1);
-        bits |= SHIFT_L(glyphp[8][line], 8);
-        bits |= SHIFT_L(glyphp[9][line], 17);
-        bits |= SHIFT_L(glyphp[10][line], 26);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = SHIFT_R(glyphp[10][line], 6);
-        bits |= SHIFT_L(glyphp[11][line], 3);
-        bits |= SHIFT_L(glyphp[12][line], 12);
-        bits |= SHIFT_L(glyphp[13][line], 21);
-        bits |= SHIFT_L(glyphp[14][line], 30);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-        bits = SHIFT_R(glyphp[14][line], 2);
-        bits |= SHIFT_L(glyphp[15][line], 7);
-        bits |= SHIFT_L(glyphp[16][line], 16);
-        bits |= SHIFT_L(glyphp[17][line], 25);
-        WRITE_IN_BITORDER(base, 4, bits);
-        CHECKRETURN(5);
-        bits = SHIFT_R(glyphp[17][line], 7);
-        bits |= SHIFT_L(glyphp[18][line], 2);
-        bits |= SHIFT_L(glyphp[19][line], 11);
-        bits |= SHIFT_L(glyphp[20][line], 20);
-        bits |= SHIFT_L(glyphp[21][line], 29);
-        WRITE_IN_BITORDER(base, 5, bits);
-        CHECKRETURN(6);
-        bits = SHIFT_R(glyphp[21][line], 3);
-        bits |= SHIFT_L(glyphp[22][line], 6);
-        bits |= SHIFT_L(glyphp[23][line], 15);
-        bits |= SHIFT_L(glyphp[24][line], 24);
-        WRITE_IN_BITORDER(base, 6, bits);
-        CHECKRETURN(7);
-        bits = SHIFT_R(glyphp[24][line], 8);
-        bits |= SHIFT_L(glyphp[25][line], 1);
-        bits |= SHIFT_L(glyphp[26][line], 10);
-        bits |= SHIFT_L(glyphp[27][line], 19);
-        bits |= SHIFT_L(glyphp[28][line], 28);
-        WRITE_IN_BITORDER(base, 7, bits);
-        CHECKRETURN(8);
-        bits = SHIFT_R(glyphp[28][line], 4);
-        bits |= SHIFT_L(glyphp[29][line], 5);
-        bits |= SHIFT_L(glyphp[30][line], 14);
-        bits |= SHIFT_L(glyphp[31][line], 23);
-        WRITE_IN_BITORDER(base, 8, bits);
-        CHECKRETURN(9);
-#ifndef FIXEDBASE
-        base += 9;
-#endif
-        width -= 288;
-        glyphp += 32;
-    }
-    return base;
-}
-#endif
-
-static CARD32 *
-DrawTETextScanlineWidth10(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 10);
-        bits |= SHIFT_L(glyphp[2][line], 20);
-        bits |= SHIFT_L(glyphp[3][line], 30);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[3][line], 2);
-        bits |= SHIFT_L(glyphp[4][line], 8);
-        bits |= SHIFT_L(glyphp[5][line], 18);
-        bits |= SHIFT_L(glyphp[6][line], 28);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[6][line], 4);
-        bits |= SHIFT_L(glyphp[7][line], 6);
-        bits |= SHIFT_L(glyphp[8][line], 16);
-        bits |= SHIFT_L(glyphp[9][line], 26);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = SHIFT_R(glyphp[9][line], 6);
-        bits |= SHIFT_L(glyphp[10][line], 4);
-        bits |= SHIFT_L(glyphp[11][line], 14);
-        bits |= SHIFT_L(glyphp[12][line], 24);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-        bits = SHIFT_R(glyphp[12][line], 8);
-        bits |= SHIFT_L(glyphp[13][line], 2);
-        bits |= SHIFT_L(glyphp[14][line], 12);
-        bits |= SHIFT_L(glyphp[15][line], 22);
-        WRITE_IN_BITORDER(base, 4, bits);
-        CHECKRETURN(5);
-#ifndef FIXEDBASE
-        base += 5;
-#endif
-        width -= 160;
-        glyphp += 16;
-    }
-    return base;
-}
-
-static CARD32 *
-DrawTETextScanlineWidth12(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 12);
-        bits |= SHIFT_L(glyphp[2][line], 24);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[2][line], 8);
-        bits |= SHIFT_L(glyphp[3][line], 4);
-        bits |= SHIFT_L(glyphp[4][line], 16);
-        bits |= SHIFT_L(glyphp[5][line], 28);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[5][line], 4);
-        bits |= SHIFT_L(glyphp[6][line], 8);
-        bits |= SHIFT_L(glyphp[7][line], 20);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-#ifndef FIXEDBASE
-        base += 3;
-#endif
-        width -= 96;
-        glyphp += 8;
-    }
-    return base;
-}
-
-static CARD32 *
-DrawTETextScanlineWidth14(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 14);
-        bits |= SHIFT_L(glyphp[2][line], 28);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[2][line], 4);
-        bits |= SHIFT_L(glyphp[3][line], 10);
-        bits |= SHIFT_L(glyphp[4][line], 24);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[4][line], 8);
-        bits |= SHIFT_L(glyphp[5][line], 6);
-        bits |= SHIFT_L(glyphp[6][line], 20);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = SHIFT_R(glyphp[6][line], 12);
-        bits |= SHIFT_L(glyphp[7][line], 2);
-        bits |= SHIFT_L(glyphp[8][line], 16);
-        bits |= SHIFT_L(glyphp[9][line], 30);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-        bits = SHIFT_R(glyphp[9][line], 2);
-        bits |= SHIFT_L(glyphp[10][line], 12);
-        bits |= SHIFT_L(glyphp[11][line], 26);
-        WRITE_IN_BITORDER(base, 4, bits);
-        CHECKRETURN(5);
-        bits = SHIFT_R(glyphp[11][line], 6);
-        bits |= SHIFT_L(glyphp[12][line], 8);
-        bits |= SHIFT_L(glyphp[13][line], 22);
-        WRITE_IN_BITORDER(base, 5, bits);
-        CHECKRETURN(6);
-        bits = SHIFT_R(glyphp[13][line], 10);
-        bits |= SHIFT_L(glyphp[14][line], 4);
-        bits |= SHIFT_L(glyphp[15][line], 18);
-        WRITE_IN_BITORDER(base, 6, bits);
-        CHECKRETURN(7);
-#ifndef FIXEDBASE
-        base += 7;
-#endif
-        width -= 224;
-        glyphp += 16;
-    }
-    return base;
-}
-
-static CARD32 *
-DrawTETextScanlineWidth16(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 16);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = glyphp[2][line];
-        bits |= SHIFT_L(glyphp[3][line], 16);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = glyphp[4][line];
-        bits |= SHIFT_L(glyphp[5][line], 16);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = glyphp[6][line];
-        bits |= SHIFT_L(glyphp[7][line], 16);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-#ifndef FIXEDBASE
-        base += 4;
-#endif
-        width -= 128;
-        glyphp += 8;
-    }
-    return base;
-}
-
-static CARD32 *
-DrawTETextScanlineWidth18(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 18);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[1][line], 14);
-        bits |= SHIFT_L(glyphp[2][line], 4);
-        bits |= SHIFT_L(glyphp[3][line], 22);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[3][line], 10);
-        bits |= SHIFT_L(glyphp[4][line], 8);
-        bits |= SHIFT_L(glyphp[5][line], 26);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-        bits = SHIFT_R(glyphp[5][line], 6);
-        bits |= SHIFT_L(glyphp[6][line], 12);
-        bits |= SHIFT_L(glyphp[7][line], 30);
-        WRITE_IN_BITORDER(base, 3, bits);
-        CHECKRETURN(4);
-        bits = SHIFT_R(glyphp[7][line], 2);
-        bits |= SHIFT_L(glyphp[8][line], 16);
-        WRITE_IN_BITORDER(base, 4, bits);
-        CHECKRETURN(5);
-        bits = SHIFT_R(glyphp[8][line], 16);
-        bits |= SHIFT_L(glyphp[9][line], 2);
-        bits |= SHIFT_L(glyphp[10][line], 20);
-        WRITE_IN_BITORDER(base, 5, bits);
-        CHECKRETURN(6);
-        bits = SHIFT_R(glyphp[10][line], 12);
-        bits |= SHIFT_L(glyphp[11][line], 6);
-        bits |= SHIFT_L(glyphp[12][line], 24);
-        WRITE_IN_BITORDER(base, 6, bits);
-        CHECKRETURN(7);
-        bits = SHIFT_R(glyphp[12][line], 8);
-        bits |= SHIFT_L(glyphp[13][line], 10);
-        bits |= SHIFT_L(glyphp[14][line], 28);
-        WRITE_IN_BITORDER(base, 7, bits);
-        CHECKRETURN(8);
-        bits = SHIFT_R(glyphp[14][line], 4);
-        bits |= SHIFT_L(glyphp[15][line], 14);
-        WRITE_IN_BITORDER(base, 8, bits);
-        CHECKRETURN(9);
-#ifndef FIXEDBASE
-        base += 9;
-#endif
-        width -= 288;
-        glyphp += 16;
-    }
-    return base;
-}
-
-static CARD32 *
-DrawTETextScanlineWidth24(CARD32 *base,
-                          unsigned int **glyphp,
-                          int line, int width, int glyphwidth)
-{
-    while (1) {
-        unsigned int bits;
-
-        bits = glyphp[0][line];
-        bits |= SHIFT_L(glyphp[1][line], 24);
-        WRITE_IN_BITORDER(base, 0, bits);
-        CHECKRETURN(1);
-        bits = SHIFT_R(glyphp[1][line], 8);
-        bits |= SHIFT_L(glyphp[2][line], 16);
-        WRITE_IN_BITORDER(base, 1, bits);
-        CHECKRETURN(2);
-        bits = SHIFT_R(glyphp[2][line], 16);
-        bits |= SHIFT_L(glyphp[3][line], 8);
-        WRITE_IN_BITORDER(base, 2, bits);
-        CHECKRETURN(3);
-#ifndef FIXEDBASE
-        base += 3;
-#endif
-        width -= 96;
-        glyphp += 4;
-    }
-    return base;
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaTEText.c b/xorg-server/hw/xfree86/xaa/xaaTEText.c
deleted file mode 100644
index a5ef44768..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaTEText.c
+++ /dev/null
@@ -1,295 +0,0 @@
-
-/********************************************************************
-
-   In this file we have GC level replacements for PolyText8/16,
-   ImageText8/16, ImageGlyphBlt and PolyGlyphBlt for TE (fixed) fonts.
-   The idea is that everything in this file is device independent.
-   The mentioned GCOps are merely wrappers for XAAGlyphBltTEColorExpansion
-   which calculates the boxes containing arbitrarily clipped text
-   and passes them to the TEGlyphRenderer which will usually be a lower 
-   level XAA function which renders these clipped glyphs using
-   the basic color expansion functions exported by the chipset driver.
-   The TEGlyphRenderer itself may optionally be driver supplied to
-   facilitate work-arounds/optimizations at a higher level than usual.
-
-   v1.0 - Mark Vojkovich (mvojkovi@ucsd.edu)
-
-********************************************************************/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include <X11/fonts/font.h>
-#include "scrnintstr.h"
-#include "dixfontstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "gcstruct.h"
-#include "pixmapstr.h"
-
-static void XAAGlyphBltTEColorExpansion(ScrnInfoPtr pScrn, int xInit,
-                                        int yInit, FontPtr font, int fg, int bg,
-                                        int rop, unsigned int planemask,
-                                        RegionPtr cclip, int nglyph,
-                                        unsigned char *gBase,
-                                        CharInfoPtr * ppci);
-
-/********************************************************************
-
-   GC level replacements for PolyText8/16 and ImageText8/16
-   for TE fonts when using color expansion.
-
-********************************************************************/
-
-int
-XAAPolyText8TEColorExpansion(DrawablePtr pDraw,
-                             GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars, Linear8Bit, &n,
-                              infoRec->CharInfo);
-
-    /* we have divorced XAAGlyphBltTEColorExpansion from the drawable */
-    if (n)
-        XAAGlyphBltTEColorExpansion(infoRec->pScrn, x + pDraw->x, y + pDraw->y,
-                                    pGC->font, pGC->fgPixel, -1, pGC->alu,
-                                    pGC->planemask, pGC->pCompositeClip, n,
-                                    FONTGLYPHS(pGC->font), infoRec->CharInfo);
-
-    return (x + (n * FONTMAXBOUNDS(pGC->font, characterWidth)));
-}
-
-int
-XAAPolyText16TEColorExpansion(DrawablePtr pDraw,
-                              GCPtr pGC,
-                              int x, int y, int count, unsigned short *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars,
-                              (FONTLASTROW(pGC->font) ==
-                               0) ? Linear16Bit : TwoD16Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n)
-        XAAGlyphBltTEColorExpansion(infoRec->pScrn, x + pDraw->x, y + pDraw->y,
-                                    pGC->font, pGC->fgPixel, -1, pGC->alu,
-                                    pGC->planemask, pGC->pCompositeClip, n,
-                                    FONTGLYPHS(pGC->font), infoRec->CharInfo);
-
-    return (x + (n * FONTMAXBOUNDS(pGC->font, characterWidth)));
-}
-
-void
-XAAImageText8TEColorExpansion(DrawablePtr pDraw,
-                              GCPtr pGC, int x, int y, int count, char *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars, Linear8Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n)
-        XAAGlyphBltTEColorExpansion(infoRec->pScrn, x + pDraw->x, y + pDraw->y,
-                                    pGC->font, pGC->fgPixel, pGC->bgPixel,
-                                    GXcopy, pGC->planemask, pGC->pCompositeClip,
-                                    n, FONTGLYPHS(pGC->font),
-                                    infoRec->CharInfo);
-}
-
-void
-XAAImageText16TEColorExpansion(DrawablePtr pDraw,
-                               GCPtr pGC,
-                               int x, int y, int count, unsigned short *chars)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    unsigned long n;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    (*pGC->font->get_glyphs) (pGC->font, (unsigned long) count,
-                              (unsigned char *) chars,
-                              (FONTLASTROW(pGC->font) ==
-                               0) ? Linear16Bit : TwoD16Bit, &n,
-                              infoRec->CharInfo);
-
-    if (n)
-        XAAGlyphBltTEColorExpansion(infoRec->pScrn, x + pDraw->x, y + pDraw->y,
-                                    pGC->font, pGC->fgPixel, pGC->bgPixel,
-                                    GXcopy, pGC->planemask, pGC->pCompositeClip,
-                                    n, FONTGLYPHS(pGC->font),
-                                    infoRec->CharInfo);
-}
-
-/********************************************************************
-
-   GC level replacements for ImageGlyphBlt and PolyGlyphBlt for
-   TE fonts when using color expansion.
-
-********************************************************************/
-
-void
-XAAImageGlyphBltTEColorExpansion(DrawablePtr pDrawable,
-                                 GCPtr pGC,
-                                 int xInit, int yInit,
-                                 unsigned int nglyph,
-                                 CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    XAAGlyphBltTEColorExpansion(infoRec->pScrn, xInit + pDrawable->x,
-                                yInit + pDrawable->y, pGC->font, pGC->fgPixel,
-                                pGC->bgPixel, GXcopy, pGC->planemask,
-                                pGC->pCompositeClip, nglyph,
-                                (unsigned char *) pglyphBase, ppci);
-}
-
-void
-XAAPolyGlyphBltTEColorExpansion(DrawablePtr pDrawable,
-                                GCPtr pGC,
-                                int xInit, int yInit,
-                                unsigned int nglyph,
-                                CharInfoPtr * ppci, pointer pglyphBase)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    XAAGlyphBltTEColorExpansion(infoRec->pScrn, xInit + pDrawable->x,
-                                yInit + pDrawable->y, pGC->font, pGC->fgPixel,
-                                -1, pGC->alu, pGC->planemask,
-                                pGC->pCompositeClip, nglyph,
-                                (unsigned char *) pglyphBase, ppci);
-}
-
-/********************************************************************
-
-   XAAGlyphBltTEColorExpansion -
-
-   This guy computes the clipped pieces of text and sends it to
-   the lower-level function which will handle acceleration of 
-   arbitrarily clipped text.
-  
-********************************************************************/
-
-static void
-XAAGlyphBltTEColorExpansion(ScrnInfoPtr pScrn,
-                            int xInit, int yInit,
-                            FontPtr font,
-                            int fg, int bg,
-                            int rop,
-                            unsigned int planemask,
-                            RegionPtr cclip,
-                            int nglyph,
-                            unsigned char *gBase, CharInfoPtr * ppci)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int skippix, skipglyphs;
-    int Left, Right, Top, Bottom;
-    int LeftEdge, RightEdge, ytop, ybot;
-    int nbox = RegionNumRects(cclip);
-    BoxPtr pbox = RegionRects(cclip);
-    unsigned int **glyphs = NULL;
-    int glyphWidth = FONTMAXBOUNDS(font, characterWidth);
-
-    /* find the size of the box */
-    Left = xInit;
-    Right = Left + (glyphWidth * nglyph);
-    Top = yInit - FONTASCENT(font);
-    Bottom = yInit + FONTDESCENT(font);
-
-    /* get into the first band that may contain part of our string */
-    while (nbox && (Top >= pbox->y2)) {
-        pbox++;
-        nbox--;
-    }
-
-    /* stop when the lower edge of the box is beyond our string */
-    while (nbox && (Bottom > pbox->y1)) {
-        LeftEdge = max(Left, pbox->x1);
-        RightEdge = min(Right, pbox->x2);
-
-        if (RightEdge > LeftEdge) {     /* we have something to draw */
-            unsigned int *fallbackBits = NULL;
-
-            ytop = max(Top, pbox->y1);
-            ybot = min(Bottom, pbox->y2);
-
-            if ((skippix = LeftEdge - Left)) {
-                skipglyphs = skippix / glyphWidth;
-                skippix %= glyphWidth;
-            }
-            else
-                skipglyphs = 0;
-
-            if (!glyphs) {
-                int count;
-
-                glyphs = (unsigned int **) (infoRec->PreAllocMem);
-
-                for (count = 0; count < nglyph; count++) {
-                    glyphs[count] = (unsigned int *)
-                        FONTGLYPHBITS(gBase, *ppci++);
-                    if (!glyphs[count]) {
-                        /* Glyphs with NULL bits do exist in the wild.
-                           Replace with blank bits in that case */
-
-                        if (!fallbackBits) {
-                            int fontHeight = Bottom - Top + 1;
-
-                            fallbackBits = calloc(glyphWidth * fontHeight, 1);
-                            if (!fallbackBits)
-                                return;
-                        }
-                        glyphs[count] = fallbackBits;
-                    }
-                }
-
-                /* our new unrolled TE code only writes DWORDS at a time 
-                   so it can read up to 6 characters past the last one 
-                   we're displaying */
-                glyphs[count + 0] = glyphs[0];
-                glyphs[count + 1] = glyphs[0];
-                glyphs[count + 2] = glyphs[0];
-                glyphs[count + 3] = glyphs[0];
-                glyphs[count + 4] = glyphs[0];
-                glyphs[count + 5] = glyphs[0];
-            }
-
-            /* x, y, w, h, skipleft, skiptop, glyphp, glyphWidth, fg, bg, rop, pm */
-
-            (*infoRec->TEGlyphRenderer) (pScrn,
-                                         LeftEdge, ytop, RightEdge - LeftEdge,
-                                         ybot - ytop, skippix, ytop - Top,
-                                         glyphs + skipglyphs, glyphWidth, fg,
-                                         bg, rop, planemask);
-
-            free(fallbackBits);
-        }
-
-        nbox--;
-        pbox++;
-    }
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaaTables.c b/xorg-server/hw/xfree86/xaa/xaaTables.c
deleted file mode 100644
index 35641da59..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaTables.c
+++ /dev/null
@@ -1,152 +0,0 @@
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-#include "xaalocal.h"
-/*
- * This is a table of 24-bit values, indexed with an 8-bit byte value, then
- * expands each bit to three consecutive bits. This is required for color
- * expansion in 24bpp mode with the coprocessor in 8bpp mode, with LSB-first
- * bit order within a byte.
- */
-
-unsigned int byte_expand3[256] = {
-    0x000000, 0x000007, 0x000038, 0x00003F, 0x0001C0, 0x0001C7, 0x0001F8,
-        0x0001FF,
-    0x000E00, 0x000E07, 0x000E38, 0x000E3F, 0x000FC0, 0x000FC7, 0x000FF8,
-        0x000FFF,
-    0x007000, 0x007007, 0x007038, 0x00703F, 0x0071C0, 0x0071C7, 0x0071F8,
-        0x0071FF,
-    0x007E00, 0x007E07, 0x007E38, 0x007E3F, 0x007FC0, 0x007FC7, 0x007FF8,
-        0x007FFF,
-    0x038000, 0x038007, 0x038038, 0x03803F, 0x0381C0, 0x0381C7, 0x0381F8,
-        0x0381FF,
-    0x038E00, 0x038E07, 0x038E38, 0x038E3F, 0x038FC0, 0x038FC7, 0x038FF8,
-        0x038FFF,
-    0x03F000, 0x03F007, 0x03F038, 0x03F03F, 0x03F1C0, 0x03F1C7, 0x03F1F8,
-        0x03F1FF,
-    0x03FE00, 0x03FE07, 0x03FE38, 0x03FE3F, 0x03FFC0, 0x03FFC7, 0x03FFF8,
-        0x03FFFF,
-    0x1C0000, 0x1C0007, 0x1C0038, 0x1C003F, 0x1C01C0, 0x1C01C7, 0x1C01F8,
-        0x1C01FF,
-    0x1C0E00, 0x1C0E07, 0x1C0E38, 0x1C0E3F, 0x1C0FC0, 0x1C0FC7, 0x1C0FF8,
-        0x1C0FFF,
-    0x1C7000, 0x1C7007, 0x1C7038, 0x1C703F, 0x1C71C0, 0x1C71C7, 0x1C71F8,
-        0x1C71FF,
-    0x1C7E00, 0x1C7E07, 0x1C7E38, 0x1C7E3F, 0x1C7FC0, 0x1C7FC7, 0x1C7FF8,
-        0x1C7FFF,
-    0x1F8000, 0x1F8007, 0x1F8038, 0x1F803F, 0x1F81C0, 0x1F81C7, 0x1F81F8,
-        0x1F81FF,
-    0x1F8E00, 0x1F8E07, 0x1F8E38, 0x1F8E3F, 0x1F8FC0, 0x1F8FC7, 0x1F8FF8,
-        0x1F8FFF,
-    0x1FF000, 0x1FF007, 0x1FF038, 0x1FF03F, 0x1FF1C0, 0x1FF1C7, 0x1FF1F8,
-        0x1FF1FF,
-    0x1FFE00, 0x1FFE07, 0x1FFE38, 0x1FFE3F, 0x1FFFC0, 0x1FFFC7, 0x1FFFF8,
-        0x1FFFFF,
-    0xE00000, 0xE00007, 0xE00038, 0xE0003F, 0xE001C0, 0xE001C7, 0xE001F8,
-        0xE001FF,
-    0xE00E00, 0xE00E07, 0xE00E38, 0xE00E3F, 0xE00FC0, 0xE00FC7, 0xE00FF8,
-        0xE00FFF,
-    0xE07000, 0xE07007, 0xE07038, 0xE0703F, 0xE071C0, 0xE071C7, 0xE071F8,
-        0xE071FF,
-    0xE07E00, 0xE07E07, 0xE07E38, 0xE07E3F, 0xE07FC0, 0xE07FC7, 0xE07FF8,
-        0xE07FFF,
-    0xE38000, 0xE38007, 0xE38038, 0xE3803F, 0xE381C0, 0xE381C7, 0xE381F8,
-        0xE381FF,
-    0xE38E00, 0xE38E07, 0xE38E38, 0xE38E3F, 0xE38FC0, 0xE38FC7, 0xE38FF8,
-        0xE38FFF,
-    0xE3F000, 0xE3F007, 0xE3F038, 0xE3F03F, 0xE3F1C0, 0xE3F1C7, 0xE3F1F8,
-        0xE3F1FF,
-    0xE3FE00, 0xE3FE07, 0xE3FE38, 0xE3FE3F, 0xE3FFC0, 0xE3FFC7, 0xE3FFF8,
-        0xE3FFFF,
-    0xFC0000, 0xFC0007, 0xFC0038, 0xFC003F, 0xFC01C0, 0xFC01C7, 0xFC01F8,
-        0xFC01FF,
-    0xFC0E00, 0xFC0E07, 0xFC0E38, 0xFC0E3F, 0xFC0FC0, 0xFC0FC7, 0xFC0FF8,
-        0xFC0FFF,
-    0xFC7000, 0xFC7007, 0xFC7038, 0xFC703F, 0xFC71C0, 0xFC71C7, 0xFC71F8,
-        0xFC71FF,
-    0xFC7E00, 0xFC7E07, 0xFC7E38, 0xFC7E3F, 0xFC7FC0, 0xFC7FC7, 0xFC7FF8,
-        0xFC7FFF,
-    0xFF8000, 0xFF8007, 0xFF8038, 0xFF803F, 0xFF81C0, 0xFF81C7, 0xFF81F8,
-        0xFF81FF,
-    0xFF8E00, 0xFF8E07, 0xFF8E38, 0xFF8E3F, 0xFF8FC0, 0xFF8FC7, 0xFF8FF8,
-        0xFF8FFF,
-    0xFFF000, 0xFFF007, 0xFFF038, 0xFFF03F, 0xFFF1C0, 0xFFF1C7, 0xFFF1F8,
-        0xFFF1FF,
-    0xFFFE00, 0xFFFE07, 0xFFFE38, 0xFFFE3F, 0xFFFFC0, 0xFFFFC7, 0xFFFFF8,
-        0xFFFFFF
-};
-
-/*
- * This is a table of 24-bit values, indexed with an 8-bit byte value,
- * that reverses the bit order of a byte and then expands each bit to three
- * consecutive bits. This is required for color expansion in 24bpp mode
- * with the coprocessor in 8bpp mode, with MSB-first bit order within a
- * byte.
- */
-
-unsigned int byte_reversed_expand3[256] = {
-    0x000000, 0x0000E0, 0x00001C, 0x0000FC, 0x008003, 0x0080E3, 0x00801F,
-        0x0080FF,
-    0x007000, 0x0070E0, 0x00701C, 0x0070FC, 0x00F003, 0x00F0E3, 0x00F01F,
-        0x00F0FF,
-    0x000E00, 0x000EE0, 0x000E1C, 0x000EFC, 0x008E03, 0x008EE3, 0x008E1F,
-        0x008EFF,
-    0x007E00, 0x007EE0, 0x007E1C, 0x007EFC, 0x00FE03, 0x00FEE3, 0x00FE1F,
-        0x00FEFF,
-    0xC00100, 0xC001E0, 0xC0011C, 0xC001FC, 0xC08103, 0xC081E3, 0xC0811F,
-        0xC081FF,
-    0xC07100, 0xC071E0, 0xC0711C, 0xC071FC, 0xC0F103, 0xC0F1E3, 0xC0F11F,
-        0xC0F1FF,
-    0xC00F00, 0xC00FE0, 0xC00F1C, 0xC00FFC, 0xC08F03, 0xC08FE3, 0xC08F1F,
-        0xC08FFF,
-    0xC07F00, 0xC07FE0, 0xC07F1C, 0xC07FFC, 0xC0FF03, 0xC0FFE3, 0xC0FF1F,
-        0xC0FFFF,
-    0x380000, 0x3800E0, 0x38001C, 0x3800FC, 0x388003, 0x3880E3, 0x38801F,
-        0x3880FF,
-    0x387000, 0x3870E0, 0x38701C, 0x3870FC, 0x38F003, 0x38F0E3, 0x38F01F,
-        0x38F0FF,
-    0x380E00, 0x380EE0, 0x380E1C, 0x380EFC, 0x388E03, 0x388EE3, 0x388E1F,
-        0x388EFF,
-    0x387E00, 0x387EE0, 0x387E1C, 0x387EFC, 0x38FE03, 0x38FEE3, 0x38FE1F,
-        0x38FEFF,
-    0xF80100, 0xF801E0, 0xF8011C, 0xF801FC, 0xF88103, 0xF881E3, 0xF8811F,
-        0xF881FF,
-    0xF87100, 0xF871E0, 0xF8711C, 0xF871FC, 0xF8F103, 0xF8F1E3, 0xF8F11F,
-        0xF8F1FF,
-    0xF80F00, 0xF80FE0, 0xF80F1C, 0xF80FFC, 0xF88F03, 0xF88FE3, 0xF88F1F,
-        0xF88FFF,
-    0xF87F00, 0xF87FE0, 0xF87F1C, 0xF87FFC, 0xF8FF03, 0xF8FFE3, 0xF8FF1F,
-        0xF8FFFF,
-    0x070000, 0x0700E0, 0x07001C, 0x0700FC, 0x078003, 0x0780E3, 0x07801F,
-        0x0780FF,
-    0x077000, 0x0770E0, 0x07701C, 0x0770FC, 0x07F003, 0x07F0E3, 0x07F01F,
-        0x07F0FF,
-    0x070E00, 0x070EE0, 0x070E1C, 0x070EFC, 0x078E03, 0x078EE3, 0x078E1F,
-        0x078EFF,
-    0x077E00, 0x077EE0, 0x077E1C, 0x077EFC, 0x07FE03, 0x07FEE3, 0x07FE1F,
-        0x07FEFF,
-    0xC70100, 0xC701E0, 0xC7011C, 0xC701FC, 0xC78103, 0xC781E3, 0xC7811F,
-        0xC781FF,
-    0xC77100, 0xC771E0, 0xC7711C, 0xC771FC, 0xC7F103, 0xC7F1E3, 0xC7F11F,
-        0xC7F1FF,
-    0xC70F00, 0xC70FE0, 0xC70F1C, 0xC70FFC, 0xC78F03, 0xC78FE3, 0xC78F1F,
-        0xC78FFF,
-    0xC77F00, 0xC77FE0, 0xC77F1C, 0xC77FFC, 0xC7FF03, 0xC7FFE3, 0xC7FF1F,
-        0xC7FFFF,
-    0x3F0000, 0x3F00E0, 0x3F001C, 0x3F00FC, 0x3F8003, 0x3F80E3, 0x3F801F,
-        0x3F80FF,
-    0x3F7000, 0x3F70E0, 0x3F701C, 0x3F70FC, 0x3FF003, 0x3FF0E3, 0x3FF01F,
-        0x3FF0FF,
-    0x3F0E00, 0x3F0EE0, 0x3F0E1C, 0x3F0EFC, 0x3F8E03, 0x3F8EE3, 0x3F8E1F,
-        0x3F8EFF,
-    0x3F7E00, 0x3F7EE0, 0x3F7E1C, 0x3F7EFC, 0x3FFE03, 0x3FFEE3, 0x3FFE1F,
-        0x3FFEFF,
-    0xFF0100, 0xFF01E0, 0xFF011C, 0xFF01FC, 0xFF8103, 0xFF81E3, 0xFF811F,
-        0xFF81FF,
-    0xFF7100, 0xFF71E0, 0xFF711C, 0xFF71FC, 0xFFF103, 0xFFF1E3, 0xFFF11F,
-        0xFFF1FF,
-    0xFF0F00, 0xFF0FE0, 0xFF0F1C, 0xFF0FFC, 0xFF8F03, 0xFF8FE3, 0xFF8F1F,
-        0xFF8FFF,
-    0xFF7F00, 0xFF7FE0, 0xFF7F1C, 0xFF7FFC, 0xFFFF03, 0xFFFFE3, 0xFFFF1F,
-        0xFFFFFF,
-};
diff --git a/xorg-server/hw/xfree86/xaa/xaaWideLine.c b/xorg-server/hw/xfree86/xaa/xaaWideLine.c
deleted file mode 100644
index b8a53c1c8..000000000
--- a/xorg-server/hw/xfree86/xaa/xaaWideLine.c
+++ /dev/null
@@ -1,924 +0,0 @@
-/*
-
-XAAPolylinesWideSolid does not maintain a span list and subsequently does
-not follow the "touch-each-pixel-once" rules for wide lines and arcs.
-This means it can only be used in the case where we have
-miSpansEasyRop(pGC->alu).  Since we clip spans on the fly, we
-limited usage of this function to one rect situations. This
-function is used only for solid lines. 
-
-  Adapted from miWideLine by Mark Vojkovich (mvojkovi@ucsd.edu)
-Original mi code written by Keith Packard.
-
-*/
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <math.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "windowstr.h"
-#include "gcstruct.h"
-#include "regionstr.h"
-#include "miwideline.h"
-#include "mi.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-
-#define DRAW_POINT(pScrn, x, y) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, 1, 1); \
-  else XAAPointHelper(pScrn, x, y)
-
-#define FILL_RECT(pScrn, x, y, w, h) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, h); \
-  else XAAFillRectHelper(pScrn, x, y, w, h)
-
-#define FILL_SPAN(pScrn, x, y, w) \
-  if(hardClip) (*infoRec->SubsequentSolidFillRect)(pScrn, x, y, w, 1); \
-  else XAASpanHelper(pScrn, x, y, w)
-
-#define CLIPSTEPEDGE(edgey,edge,edgeleft) \
-    if (ybase == edgey) { \
-	if (edgeleft) { \
-	    if (edge->x > xcl) \
-		xcl = edge->x; \
-	} else { \
-	    if (edge->x < xcr) \
-		xcr = edge->x; \
-	} \
-	edgey++; \
-	edge->x += edge->stepx; \
-	edge->e += edge->dx; \
-	if (edge->e > 0) { \
-	    edge->x += edge->signdx; \
-	    edge->e -= edge->dy; \
-	} \
-    }
-
-static void
-XAAPointHelper(ScrnInfoPtr pScrn, int x, int y)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    BoxPtr extents = infoRec->ClipBox;
-
-    if ((x >= extents->x1) && (x < extents->x2) &&
-        (y >= extents->y1) && (y < extents->y2))
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, 1, 1);
-}
-
-static void
-XAAFillRectHelper(ScrnInfoPtr pScrn, int x1, int y1, int dx, int dy)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    BoxPtr extents = infoRec->ClipBox;
-    int x2 = x1 + dx;
-    int y2 = y1 + dy;
-
-    if (x1 < extents->x1)
-        x1 = extents->x1;
-    if (x2 >= extents->x2)
-        x2 = extents->x2;
-    if ((dx = x2 - x1) < 1)
-        return;
-    if (y1 < extents->y1)
-        y1 = extents->y1;
-    if (y2 >= extents->y2)
-        y2 = extents->y2;
-    if ((dy = y2 - y1) < 1)
-        return;
-
-    (*infoRec->SubsequentSolidFillRect) (pScrn, x1, y1, dx, dy);
-}
-
-static void
-XAASpanHelper(ScrnInfoPtr pScrn, int x1, int y, int width)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    BoxPtr extents = infoRec->ClipBox;
-    int x2;
-
-    if ((y < extents->y1) || (y >= extents->y2))
-        return;
-
-    x2 = x1 + width;
-    if (x1 < extents->x1)
-        x1 = extents->x1;
-    if (x2 > extents->x2)
-        x2 = extents->x2;
-    width = x2 - x1;
-
-    if (width > 0)
-        (*infoRec->SubsequentSolidFillRect) (pScrn, x1, y, width, 1);
-
-}
-
-#define FixError(x, dx, dy, e, sign, step, h)	{	\
-	   e += (h) * dx;				\
-	   x += (h) * step;				\
-	   if(e > 0) {					\
-		x += e * sign/dy;			\
-		e %= dy;				\
-	   	if(e) {					\
-		   x += sign;				\
-		   e -= dy;				\
-		}					\
-	   } 	 					\
-}
-
-static void
-XAAFillPolyHelper(GCPtr pGC, int y,     /* start y coordinate */
-                  int overall_height,   /* height of entire segment */
-                  PolyEdgePtr left, PolyEdgePtr right,
-                  int left_count, int right_count)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    BoxPtr extents = infoRec->ClipBox;
-    int left_x, left_e, left_stepx, left_signdx, left_dy, left_dx;
-    int right_x, right_e, right_stepx, right_signdx, right_dy, right_dx;
-    int height, left_height, right_height;
-    int xorg;
-    Bool hardClip;
-
-    if ((y >= extents->y2) || ((y + overall_height) <= extents->y1))
-        return;
-
-    /* Muffle compiler */
-    left_x = left_e = left_stepx = left_signdx = left_dy = left_dx = 0;
-    right_x = right_e = right_stepx = right_signdx = right_dy = right_dx = 0;
-
-    left_height = right_height = 0;
-    xorg = 0;
-
-    hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    while ((left_count || left_height) && (right_count || right_height)) {
-        if (!left_height && left_count) {
-            left_height = left->height;
-            left_x = left->x + xorg;
-            left_stepx = left->stepx;
-            left_signdx = left->signdx;
-            left_e = left->e;
-            left_dy = left->dy;
-            left_dx = left->dx;
-            left_count--;
-            left++;
-        }
-        if (!right_height && right_count) {
-            right_height = right->height;
-            right_x = right->x + xorg + 1;
-            right_stepx = right->stepx;
-            right_signdx = right->signdx;
-            right_e = right->e;
-            right_dy = right->dy;
-            right_dx = right->dx;
-            right_count--;
-            right++;
-        }
-
-        height = (left_height > right_height) ? right_height : left_height;
-
-        left_height -= height;
-        right_height -= height;
-
-        if (hardClip && infoRec->SubsequentSolidFillTrap && (height > 6)) {
-            int right_DX, left_DX;
-
-            right_DX = (right_dx * right_signdx) + (right_stepx * right_dy);
-            left_DX = (left_dx * left_signdx) + (left_stepx * left_dy);
-
-            (*infoRec->SubsequentSolidFillTrap) (infoRec->pScrn, y, height,
-                                                 left_x, left_DX, left_dy,
-                                                 left_e, right_x - 1, right_DX,
-                                                 right_dy, right_e);
-
-            FixError(left_x, left_dx, left_dy, left_e, left_signdx,
-                     left_stepx, height);
-            FixError(right_x, right_dx, right_dy, right_e, right_signdx,
-                     right_stepx, height);
-            y += height;
-            continue;
-        }
-
-        while (height--) {
-            if (right_x > left_x) {
-                FILL_SPAN(infoRec->pScrn, left_x, y, right_x - left_x);
-            }
-            y++;
-
-            left_x += left_stepx;
-            left_e += left_dx;
-            if (left_e > 0) {
-                left_x += left_signdx;
-                left_e -= left_dy;
-            }
-            right_x += right_stepx;
-            right_e += right_dx;
-            if (right_e > 0) {
-                right_x += right_signdx;
-                right_e -= right_dy;
-            }
-
-        }
-    }
-}
-
-static void
-XAAWideSegment(GCPtr pGC,
-               int x1, int y1, int x2, int y2,
-               Bool projectLeft, Bool projectRight,
-               LineFacePtr leftFace, LineFacePtr rightFace)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    double l, L, r;
-    double xa, ya;
-    double projectXoff, projectYoff;
-    double k;
-    double maxy;
-    int x, y;
-    int dx, dy;
-    int finaly;
-    PolyEdgePtr left, right;
-    PolyEdgePtr top, bottom;
-    int lefty, righty, topy, bottomy;
-    int signdx;
-    PolyEdgeRec lefts[2], rights[2];
-    LineFacePtr tface;
-    int lw = pGC->lineWidth;
-    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    /* draw top-to-bottom always */
-    if ((y2 < y1) || ((y2 == y1) && (x2 < x1))) {
-        x = x1;
-        x1 = x2;
-        x2 = x;
-
-        y = y1;
-        y1 = y2;
-        y2 = y;
-
-        x = projectLeft;
-        projectLeft = projectRight;
-        projectRight = x;
-
-        tface = leftFace;
-        leftFace = rightFace;
-        rightFace = tface;
-    }
-
-    dy = y2 - y1;
-    signdx = 1;
-    dx = x2 - x1;
-    if (dx < 0)
-        signdx = -1;
-
-    leftFace->x = x1;
-    leftFace->y = y1;
-    leftFace->dx = dx;
-    leftFace->dy = dy;
-
-    rightFace->x = x2;
-    rightFace->y = y2;
-    rightFace->dx = -dx;
-    rightFace->dy = -dy;
-
-    if (!dy) {
-        rightFace->xa = 0;
-        rightFace->ya = (double) lw / 2.0;
-        rightFace->k = -(double) (lw * dx) / 2.0;
-        leftFace->xa = 0;
-        leftFace->ya = -rightFace->ya;
-        leftFace->k = rightFace->k;
-        x = x1;
-        if (projectLeft)
-            x -= (lw >> 1);
-        y = y1 - (lw >> 1);
-        dx = x2 - x;
-        if (projectRight)
-            dx += ((lw + 1) >> 1);
-        dy = lw;
-        FILL_RECT(infoRec->pScrn, x, y, dx, dy);
-    }
-    else if (!dx) {
-        leftFace->xa = (double) lw / 2.0;
-        leftFace->ya = 0;
-        leftFace->k = (double) (lw * dy) / 2.0;
-        rightFace->xa = -leftFace->xa;
-        rightFace->ya = 0;
-        rightFace->k = leftFace->k;
-        y = y1;
-        if (projectLeft)
-            y -= lw >> 1;
-        x = x1 - (lw >> 1);
-        dy = y2 - y;
-        if (projectRight)
-            dy += ((lw + 1) >> 1);
-        dx = lw;
-        FILL_RECT(infoRec->pScrn, x, y, dx, dy);
-    }
-    else {
-        l = ((double) lw) / 2.0;
-        L = sqrt((double) (dx * dx + dy * dy));
-
-        if (dx < 0) {
-            right = &rights[1];
-            left = &lefts[0];
-            top = &rights[0];
-            bottom = &lefts[1];
-        }
-        else {
-            right = &rights[0];
-            left = &lefts[1];
-            top = &lefts[0];
-            bottom = &rights[1];
-        }
-        r = l / L;
-
-        /* coord of upper bound at integral y */
-        ya = -r * dx;
-        xa = r * dy;
-
-        projectXoff = -ya;
-        projectYoff = xa;
-
-        /* xa * dy - ya * dx */
-        k = l * L;
-
-        leftFace->xa = xa;
-        leftFace->ya = ya;
-        leftFace->k = k;
-        rightFace->xa = -xa;
-        rightFace->ya = -ya;
-        rightFace->k = k;
-
-        if (projectLeft)
-            righty = miPolyBuildEdge(xa - projectXoff, ya - projectYoff,
-                                     k, dx, dy, x1, y1, 0, right);
-        else
-            righty = miPolyBuildEdge(xa, ya, k, dx, dy, x1, y1, 0, right);
-
-        /* coord of lower bound at integral y */
-        ya = -ya;
-        xa = -xa;
-
-        /* xa * dy - ya * dx */
-        k = -k;
-
-        if (projectLeft)
-            lefty = miPolyBuildEdge(xa - projectXoff, ya - projectYoff,
-                                    k, dx, dy, x1, y1, 1, left);
-        else
-            lefty = miPolyBuildEdge(xa, ya, k, dx, dy, x1, y1, 1, left);
-
-        /* coord of top face at integral y */
-
-        if (signdx > 0) {
-            ya = -ya;
-            xa = -xa;
-        }
-
-        if (projectLeft) {
-            double xap = xa - projectXoff;
-            double yap = ya - projectYoff;
-
-            topy = miPolyBuildEdge(xap, yap, xap * dx + yap * dy,
-                                   -dy, dx, x1, y1, dx > 0, top);
-        }
-        else
-            topy = miPolyBuildEdge(xa, ya, 0.0, -dy, dx, x1, y1, dx > 0, top);
-
-        /* coord of bottom face at integral y */
-
-        if (projectRight) {
-            double xap = xa + projectXoff;
-            double yap = ya + projectYoff;
-
-            bottomy = miPolyBuildEdge(xap, yap, xap * dx + yap * dy,
-                                      -dy, dx, x2, y2, dx < 0, bottom);
-            maxy = -ya + projectYoff;
-        }
-        else {
-            bottomy = miPolyBuildEdge(xa, ya, 0.0,
-                                      -dy, dx, x2, y2, dx < 0, bottom);
-            maxy = -ya;
-        }
-
-        finaly = ICEIL(maxy) + y2;
-
-        if (dx < 0) {
-            left->height = bottomy - lefty;
-            right->height = finaly - righty;
-            top->height = righty - topy;
-        }
-        else {
-            right->height = bottomy - righty;
-            left->height = finaly - lefty;
-            top->height = lefty - topy;
-        }
-        bottom->height = finaly - bottomy;
-        XAAFillPolyHelper(pGC, topy,
-                          bottom->height + bottomy - topy, lefts, rights, 2, 2);
-    }
-}
-
-static void
-XAALineArcI(GCPtr pGC, int xorg, int yorg)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int x, y, e, ex;
-    int slw = pGC->lineWidth;
-    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    y = (slw >> 1) + 1;
-    if (slw & 1)
-        e = -((y << 2) + 3);
-    else
-        e = -(y << 3);
-    ex = -4;
-    x = 0;
-    while (y) {
-        e += (y << 3) - 4;
-        while (e >= 0) {
-            x++;
-            e += (ex = -((x << 3) + 4));
-        }
-        y--;
-        slw = (x << 1) + 1;
-        if ((e == ex) && (slw > 1))
-            slw--;
-
-        FILL_SPAN(infoRec->pScrn, xorg - x, yorg - y, slw);
-
-        if ((y != 0) && ((slw > 1) || (e != ex))) {
-            FILL_SPAN(infoRec->pScrn, xorg - x, yorg + y, slw);
-        }
-    }
-}
-
-static void
-XAALineArcD(GCPtr pGC,
-            double xorg,
-            double yorg,
-            PolyEdgePtr edge1,
-            int edgey1,
-            Bool edgeleft1, PolyEdgePtr edge2, int edgey2, Bool edgeleft2)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    double radius, x0, y0, el, er, yk, xlk, xrk, k;
-    int xbase, ybase, y, boty, xl, xr, xcl, xcr;
-    int ymin, ymax;
-    Bool edge1IsMin, edge2IsMin;
-    int ymin1, ymin2;
-    Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-    xbase = floor(xorg);
-    x0 = xorg - xbase;
-    ybase = ICEIL(yorg);
-    y0 = yorg - ybase;
-
-    xlk = x0 + x0 + 1.0;
-    xrk = x0 + x0 - 1.0;
-    yk = y0 + y0 - 1.0;
-    radius = ((double) pGC->lineWidth) / 2.0;
-    y = floor(radius - y0 + 1.0);
-    ybase -= y;
-    ymin = ybase;
-    ymax = 65536;
-    edge1IsMin = FALSE;
-    ymin1 = edgey1;
-    if (edge1->dy >= 0) {
-        if (!edge1->dy) {
-            if (edgeleft1)
-                edge1IsMin = TRUE;
-            else
-                ymax = edgey1;
-            edgey1 = 65536;
-        }
-        else if ((edge1->signdx < 0) == edgeleft1)
-            edge1IsMin = TRUE;
-    }
-    edge2IsMin = FALSE;
-    ymin2 = edgey2;
-    if (edge2->dy >= 0) {
-        if (!edge2->dy) {
-            if (edgeleft2)
-                edge2IsMin = TRUE;
-            else
-                ymax = edgey2;
-            edgey2 = 65536;
-        }
-        else if ((edge2->signdx < 0) == edgeleft2)
-            edge2IsMin = TRUE;
-    }
-    if (edge1IsMin) {
-        ymin = ymin1;
-        if (edge2IsMin && (ymin1 > ymin2))
-            ymin = ymin2;
-    }
-    else if (edge2IsMin)
-        ymin = ymin2;
-    el = radius * radius - ((y + y0) * (y + y0)) - (x0 * x0);
-    er = el + xrk;
-    xl = 1;
-    xr = 0;
-    if (x0 < 0.5) {
-        xl = 0;
-        el -= xlk;
-    }
-    boty = (y0 < -0.5) ? 1 : 0;
-    if (ybase + y - boty > ymax)
-        boty = ymax - ybase - y;
-    while (y > boty) {
-        k = (y << 1) + yk;
-        er += k;
-        while (er > 0.0) {
-            xr++;
-            er += xrk - (xr << 1);
-        }
-        el += k;
-        while (el >= 0.0) {
-            xl--;
-            el += (xl << 1) - xlk;
-        }
-        y--;
-        ybase++;
-        if (ybase < ymin)
-            continue;
-        xcl = xl + xbase;
-        xcr = xr + xbase;
-        CLIPSTEPEDGE(edgey1, edge1, edgeleft1);
-        CLIPSTEPEDGE(edgey2, edge2, edgeleft2);
-        if (xcr >= xcl) {
-            FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);
-        }
-    }
-    er = xrk - (xr << 1) - er;
-    el = (xl << 1) - xlk - el;
-    boty = floor(-y0 - radius + 1.0);
-    if (ybase + y - boty > ymax)
-        boty = ymax - ybase - y;
-    while (y > boty) {
-        k = (y << 1) + yk;
-        er -= k;
-        while ((er >= 0.0) && (xr >= 0)) {
-            xr--;
-            er += xrk - (xr << 1);
-        }
-        el -= k;
-        while ((el > 0.0) && (xl <= 0)) {
-            xl++;
-            el += (xl << 1) - xlk;
-        }
-        y--;
-        ybase++;
-        if (ybase < ymin)
-            continue;
-        xcl = xl + xbase;
-        xcr = xr + xbase;
-        CLIPSTEPEDGE(edgey1, edge1, edgeleft1);
-        CLIPSTEPEDGE(edgey2, edge2, edgeleft2);
-        if (xcr >= xcl) {
-            FILL_SPAN(infoRec->pScrn, xcl, ybase, xcr - xcl + 1);
-        }
-    }
-}
-
-static void
-XAALineArc(GCPtr pGC,
-           LineFacePtr leftFace,
-           LineFacePtr rightFace, double xorg, double yorg, Bool isInt)
-{
-    int xorgi, yorgi;
-    PolyEdgeRec edge1, edge2;
-    int edgey1, edgey2;
-    Bool edgeleft1, edgeleft2;
-
-    if (isInt) {
-        xorgi = leftFace ? leftFace->x : rightFace->x;
-        yorgi = leftFace ? leftFace->y : rightFace->y;
-    }
-    else {                      /* Muffle compiler */
-        xorgi = yorgi = 0;
-    }
-    edgey1 = 65536;
-    edgey2 = 65536;
-    edge1.x = 0;                /* not used, keep memory checkers happy */
-    edge1.dy = -1;
-    edge2.x = 0;                /* not used, keep memory checkers happy */
-    edge2.dy = -1;
-    edgeleft1 = FALSE;
-    edgeleft2 = FALSE;
-
-    if ((pGC->lineWidth > 2) &&
-        ((pGC->capStyle == CapRound && pGC->joinStyle != JoinRound) ||
-         (pGC->joinStyle == JoinRound && pGC->capStyle == CapButt))) {
-        if (isInt) {
-            xorg = (double) xorgi;
-            yorg = (double) yorgi;
-        }
-
-        if (leftFace && rightFace)
-            miRoundJoinClip(leftFace, rightFace, &edge1, &edge2,
-                            &edgey1, &edgey2, &edgeleft1, &edgeleft2);
-        else if (leftFace)
-            edgey1 = miRoundCapClip(leftFace, isInt, &edge1, &edgeleft1);
-        else if (rightFace)
-            edgey2 = miRoundCapClip(rightFace, isInt, &edge2, &edgeleft2);
-
-        isInt = FALSE;
-    }
-
-    if (isInt) {
-        if (pGC->lineWidth == 1) {
-            XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-            Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-            DRAW_POINT(infoRec->pScrn, xorgi, yorgi);
-        }
-        else
-            XAALineArcI(pGC, xorgi, yorgi);
-    }
-    else
-        XAALineArcD(pGC, xorg, yorg, &edge1, edgey1, edgeleft1,
-                    &edge2, edgey2, edgeleft2);
-
-}
-
-static void
-XAALineJoin(GCPtr pGC, LineFacePtr pLeft, LineFacePtr pRight)
-{
-    double mx = 0, my = 0;
-    double denom = 0;
-    PolyVertexRec vertices[4];
-    PolySlopeRec slopes[4];
-    int edgecount;
-    PolyEdgeRec left[4], right[4];
-    int nleft, nright;
-    int y, height;
-    int swapslopes;
-    int joinStyle = pGC->joinStyle;
-    int lw = pGC->lineWidth;
-
-    if (lw == 1) {
-        /* Lines going in the same direction have no join */
-        if ((pLeft->dx >= 0) == (pRight->dx <= 0))
-            return;
-        if (joinStyle != JoinRound) {
-            denom = -pLeft->dx * (double) pRight->dy + pRight->dx *
-                (double) pLeft->dy;
-            if (denom == 0.0)
-                return;         /* no join to draw */
-        }
-        if (joinStyle != JoinMiter) {
-            XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-            Bool hardClip = (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL);
-
-            DRAW_POINT(infoRec->pScrn, pLeft->x, pLeft->y);
-            return;
-        }
-    }
-    else {
-        if (joinStyle == JoinRound) {
-            XAALineArc(pGC, pLeft, pRight, (double) 0.0, (double) 0.0, TRUE);
-            return;
-        }
-        denom = -pLeft->dx * (double) pRight->dy + pRight->dx *
-            (double) pLeft->dy;
-        if (denom == 0.0)
-            return;             /* no join to draw */
-    }
-
-    swapslopes = 0;
-    if (denom > 0) {
-        pLeft->xa = -pLeft->xa;
-        pLeft->ya = -pLeft->ya;
-        pLeft->dx = -pLeft->dx;
-        pLeft->dy = -pLeft->dy;
-    }
-    else {
-        swapslopes = 1;
-        pRight->xa = -pRight->xa;
-        pRight->ya = -pRight->ya;
-        pRight->dx = -pRight->dx;
-        pRight->dy = -pRight->dy;
-    }
-
-    vertices[0].x = pRight->xa;
-    vertices[0].y = pRight->ya;
-    slopes[0].dx = -pRight->dy;
-    slopes[0].dy = pRight->dx;
-    slopes[0].k = 0;
-
-    vertices[1].x = 0;
-    vertices[1].y = 0;
-    slopes[1].dx = pLeft->dy;
-    slopes[1].dy = -pLeft->dx;
-    slopes[1].k = 0;
-
-    vertices[2].x = pLeft->xa;
-    vertices[2].y = pLeft->ya;
-
-    if (joinStyle == JoinMiter) {
-        my = (pLeft->dy * (pRight->xa * pRight->dy - pRight->ya * pRight->dx) -
-              pRight->dy * (pLeft->xa * pLeft->dy - pLeft->ya * pLeft->dx)) /
-            denom;
-        if (pLeft->dy != 0)
-            mx = pLeft->xa + (my - pLeft->ya) *
-                (double) pLeft->dx / (double) pLeft->dy;
-        else
-            mx = pRight->xa + (my - pRight->ya) *
-                (double) pRight->dx / (double) pRight->dy;
-
-        /* check miter limit */
-        if ((mx * mx + my * my) * 4 > SQSECANT * lw * lw)
-            joinStyle = JoinBevel;
-    }
-
-    if (joinStyle == JoinMiter) {
-        slopes[2].dx = pLeft->dx;
-        slopes[2].dy = pLeft->dy;
-        slopes[2].k = pLeft->k;
-        if (swapslopes) {
-            slopes[2].dx = -slopes[2].dx;
-            slopes[2].dy = -slopes[2].dy;
-            slopes[2].k = -slopes[2].k;
-        }
-        vertices[3].x = mx;
-        vertices[3].y = my;
-        slopes[3].dx = pRight->dx;
-        slopes[3].dy = pRight->dy;
-        slopes[3].k = pRight->k;
-        if (swapslopes) {
-            slopes[3].dx = -slopes[3].dx;
-            slopes[3].dy = -slopes[3].dy;
-            slopes[3].k = -slopes[3].k;
-        }
-        edgecount = 4;
-    }
-    else {
-        double scale, dx, dy, adx, ady;
-
-        adx = dx = pRight->xa - pLeft->xa;
-        ady = dy = pRight->ya - pLeft->ya;
-        if (adx < 0)
-            adx = -adx;
-        if (ady < 0)
-            ady = -ady;
-        scale = ady;
-        if (adx > ady)
-            scale = adx;
-        slopes[2].dx = (dx * 65536) / scale;
-        slopes[2].dy = (dy * 65536) / scale;
-        slopes[2].k = ((pLeft->xa + pRight->xa) * slopes[2].dy -
-                       (pLeft->ya + pRight->ya) * slopes[2].dx) / 2.0;
-        edgecount = 3;
-    }
-
-    y = miPolyBuildPoly(vertices, slopes, edgecount, pLeft->x, pLeft->y,
-                        left, right, &nleft, &nright, &height);
-    XAAFillPolyHelper(pGC, y, height, left, right, nleft, nright);
-}
-
-void
-XAAPolylinesWideSolid(DrawablePtr pDrawable,
-                      GCPtr pGC, int mode, int npt, DDXPointPtr pPts)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int x1, y1, x2, y2;
-    Bool projectLeft, projectRight;
-    LineFaceRec leftFace, rightFace, prevRightFace, firstFace;
-    int first = TRUE;
-    Bool somethingDrawn = FALSE;
-    Bool selfJoin = FALSE;
-    int xorg = pDrawable->x;
-    int yorg = pDrawable->y;
-    Bool hardClip = FALSE;
-
-    if (!RegionNumRects(pGC->pCompositeClip))
-        return;
-
-    if (RegionNumRects(pGC->pCompositeClip) != 1) {
-        miWideLine(pDrawable, pGC, mode, npt, pPts);
-        return;
-    }
-
-    x2 = pPts->x;
-    y2 = pPts->y;
-    if (npt > 1) {
-        if (mode == CoordModePrevious) {
-            int nptTmp;
-            register DDXPointPtr pPtsTmp;
-
-            x1 = x2;
-            y1 = y2;
-            nptTmp = npt;
-            pPtsTmp = pPts + 1;
-            while (--nptTmp) {
-                x1 += pPtsTmp->x;
-                y1 += pPtsTmp->y;
-                ++pPtsTmp;
-            }
-            if ((x2 == x1) && (y2 == y1))
-                selfJoin = TRUE;
-        }
-        else if ((x2 == pPts[npt - 1].x) && (y2 == pPts[npt - 1].y))
-            selfJoin = TRUE;
-    }
-
-    projectLeft = ((pGC->capStyle == CapProjecting) && !selfJoin);
-    projectRight = FALSE;
-
-    (*infoRec->SetupForSolidFill) (infoRec->pScrn, pGC->fgPixel, pGC->alu,
-                                   pGC->planemask);
-
-    infoRec->ClipBox = &pGC->pCompositeClip->extents;
-
-    if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) {
-        hardClip = TRUE;
-        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
-                                          infoRec->ClipBox->x1,
-                                          infoRec->ClipBox->y1,
-                                          infoRec->ClipBox->x2 - 1,
-                                          infoRec->ClipBox->y2 - 1);
-    }
-
-    x2 += xorg;
-    y2 += yorg;
-    while (--npt) {
-        x1 = x2;
-        y1 = y2;
-        ++pPts;
-        x2 = pPts->x;
-        y2 = pPts->y;
-        if (mode == CoordModePrevious) {
-            x2 += x1;
-            y2 += y1;
-        }
-        else {
-            x2 += xorg;
-            y2 += yorg;
-        }
-        if ((x1 != x2) || (y1 != y2)) {
-            somethingDrawn = TRUE;
-            if ((npt == 1) && (pGC->capStyle == CapProjecting) && !selfJoin)
-                projectRight = TRUE;
-            XAAWideSegment(pGC, x1, y1, x2, y2,
-                           projectLeft, projectRight, &leftFace, &rightFace);
-            if (first) {
-                if (selfJoin)
-                    firstFace = leftFace;
-                else if (pGC->capStyle == CapRound) {
-                    if (pGC->lineWidth == 1) {
-                        DRAW_POINT(infoRec->pScrn, x1, y1);
-                    }
-                    else
-                        XAALineArc(pGC, &leftFace, (LineFacePtr) NULL,
-                                   (double) 0.0, (double) 0.0, TRUE);
-                }
-            }
-            else
-                XAALineJoin(pGC, &leftFace, &prevRightFace);
-
-            prevRightFace = rightFace;
-            first = FALSE;
-            projectLeft = FALSE;
-        }
-        if (npt == 1 && somethingDrawn) {
-            if (selfJoin)
-                XAALineJoin(pGC, &firstFace, &rightFace);
-            else if (pGC->capStyle == CapRound) {
-                if (pGC->lineWidth == 1) {
-                    DRAW_POINT(infoRec->pScrn, x2, y2);
-                }
-                else
-                    XAALineArc(pGC, (LineFacePtr) NULL, &rightFace,
-                               (double) 0.0, (double) 0.0, TRUE);
-            }
-        }
-    }
-    /* handle crock where all points are coincedent */
-    if (!somethingDrawn) {
-        projectLeft = (pGC->capStyle == CapProjecting);
-        XAAWideSegment(pGC, x2, y2, x2, y2, projectLeft, projectLeft,
-                       &leftFace, &rightFace);
-        if (pGC->capStyle == CapRound) {
-            XAALineArc(pGC, &leftFace, (LineFacePtr) NULL,
-                       (double) 0.0, (double) 0.0, TRUE);
-            rightFace.dx = -1;  /* sleezy hack to make it work */
-            XAALineArc(pGC, (LineFacePtr) NULL, &rightFace,
-                       (double) 0.0, (double) 0.0, TRUE);
-        }
-    }
-
-    infoRec->ClipBox = NULL;
-    if (hardClip)
-        (*infoRec->DisableClipping) (infoRec->pScrn);
-
-    SET_SYNC_FLAG(infoRec);
-}
diff --git a/xorg-server/hw/xfree86/xaa/xaacexp.h b/xorg-server/hw/xfree86/xaa/xaacexp.h
deleted file mode 100644
index 6fde54c65..000000000
--- a/xorg-server/hw/xfree86/xaa/xaacexp.h
+++ /dev/null
@@ -1,126 +0,0 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <X11/Xarch.h>
-
-#ifndef FIXEDBASE
-#define CHECKRETURN(b) if(width <= ((b) * 32)) return(base + (b))
-#else
-#define CHECKRETURN(b) if(width <= ((b) * 32)) return(base)
-#endif
-
-#if X_BYTE_ORDER == X_BIG_ENDIAN
-#define SHIFT_L(value, shift) ((value) >> (shift))
-#define SHIFT_R(value, shift) ((value) << (shift))
-#else
-#define SHIFT_L(value, shift) ((value) << (shift))
-#define SHIFT_R(value, shift) ((value) >> (shift))
-#endif
-
-#ifndef MSBFIRST
-#ifdef FIXEDBASE
-#define WRITE_IN_BITORDER(dest, offset, data) *(dest) = data;
-#else
-#define WRITE_IN_BITORDER(dest, offset, data) *(dest + offset) = data;
-#endif
-#else
-#ifdef FIXEDBASE
-#define WRITE_IN_BITORDER(dest, offset, data) *(dest) = SWAP_BITS_IN_BYTES(data);
-#else
-#define WRITE_IN_BITORDER(dest, offset, data) *(dest + offset) = SWAP_BITS_IN_BYTES(data)
-#endif
-#endif
-
-#ifdef FIXEDBASE
-#ifdef MSBFIRST
-#define WRITE_BITS(b)   *base = SWAP_BITS_IN_BYTES(b)
-#define WRITE_BITS1(b) { \
-	*base = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; }
-#define WRITE_BITS2(b) { \
-	*base = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*base = byte_reversed_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_reversed_expand3[((b) & 0xFF0000) >> 16] << 16; }
-#define WRITE_BITS3(b) { \
-	*base = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*base = byte_reversed_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_reversed_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	*base = byte_reversed_expand3[((b) & 0xFF0000) >> 16] >> 16 | \
-		byte_reversed_expand3[((b) & 0xFF000000) >> 24] << 8; }
-#else
-#define WRITE_BITS(b)   *base = (b)
-#define WRITE_BITS1(b) { \
-	*base = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; }
-#define WRITE_BITS2(b) { \
-	*base = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*base = byte_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_expand3[((b) & 0xFF0000) >> 16] << 16; }
-#define WRITE_BITS3(b) { \
-	*base = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*base = byte_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	*base = byte_expand3[((b) & 0xFF0000) >> 16] >> 16 | \
-		byte_expand3[((b) & 0xFF000000) >> 24] << 8; }
-#endif
-#else
-#ifdef MSBFIRST
-#define WRITE_BITS(b)   *(base++) = SWAP_BITS_IN_BYTES(b)
-#define WRITE_BITS1(b) { \
-	*(base++) = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; }
-#define WRITE_BITS2(b) { \
-	*(base) = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*(base + 1) = byte_reversed_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_reversed_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	base += 2; }
-#define WRITE_BITS3(b) { \
-	*(base) = byte_reversed_expand3[(b) & 0xFF] | \
-		byte_reversed_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*(base + 1) = byte_reversed_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_reversed_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	*(base + 2) = byte_reversed_expand3[((b) & 0xFF0000) >> 16] >> 16 | \
-		byte_reversed_expand3[((b) & 0xFF000000) >> 24] << 8; \
-	base += 3; }
-#else
-#define WRITE_BITS(b)   *(base++) = (b)
-#define WRITE_BITS1(b) { \
-	*(base++) = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; }
-#define WRITE_BITS2(b) { \
-	*(base) = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*(base + 1) = byte_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	base += 2; }
-#define WRITE_BITS3(b) { \
-	*(base) = byte_expand3[(b) & 0xFF] | \
-		byte_expand3[((b) & 0xFF00) >> 8] << 24; \
-	*(base + 1) = byte_expand3[((b) & 0xFF00) >> 8] >> 8 | \
-		byte_expand3[((b) & 0xFF0000) >> 16] << 16; \
-	*(base + 2) = byte_expand3[((b) & 0xFF0000) >> 16] >> 16 | \
-		byte_expand3[((b) & 0xFF000000) >> 24] << 8; \
-	base += 3; }
-#endif
-#endif
-
-#ifdef FIXEDBASE
-#ifdef MSBFIRST
-#define EXPNAME(x) x##MSBFirstFixedBase
-#else
-#define EXPNAME(x) x##LSBFirstFixedBase
-#endif
-#else
-#ifdef MSBFIRST
-#define EXPNAME(x) x##MSBFirst
-#else
-#define EXPNAME(x) x##LSBFirst
-#endif
-#endif
diff --git a/xorg-server/hw/xfree86/xaa/xaalocal.h b/xorg-server/hw/xfree86/xaa/xaalocal.h
deleted file mode 100644
index 61d9eebe5..000000000
--- a/xorg-server/hw/xfree86/xaa/xaalocal.h
+++ /dev/null
@@ -1,1437 +0,0 @@
-
-#ifndef _XAALOCAL_H
-#define _XAALOCAL_H
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-/* This file is very unorganized ! */
-
-#include "gcstruct.h"
-#include "regionstr.h"
-#include "xf86fbman.h"
-#include "xaa.h"
-#include "mi.h"
-#include "picturestr.h"
-
-#define GCWhenForced		(GCArcMode << 1)
-
-#define DO_COLOR_8x8		0x00000001
-#define DO_MONO_8x8		0x00000002
-#define DO_CACHE_BLT		0x00000003
-#define DO_COLOR_EXPAND		0x00000004
-#define DO_CACHE_EXPAND		0x00000005
-#define DO_IMAGE_WRITE		0x00000006
-#define DO_PIXMAP_COPY		0x00000007
-#define DO_SOLID		0x00000008
-
-typedef CARD32 *(*GlyphScanlineFuncPtr) (CARD32 *base, unsigned int **glyphp,
-                                         int line, int nglyph, int width);
-
-typedef CARD32 *(*StippleScanlineProcPtr) (CARD32 *, CARD32 *, int, int, int);
-
-typedef void (*RectFuncPtr) (ScrnInfoPtr, int, int, int, int, int, int,
-                             XAACacheInfoPtr);
-typedef void (*TrapFuncPtr) (ScrnInfoPtr, int, int, int, int, int, int,
-                             int, int, int, int, int, int, XAACacheInfoPtr);
-
-typedef struct _XAAScreen {
-    CreateGCProcPtr CreateGC;
-    CloseScreenProcPtr CloseScreen;
-    GetImageProcPtr GetImage;
-    GetSpansProcPtr GetSpans;
-    CopyWindowProcPtr CopyWindow;
-    WindowExposuresProcPtr WindowExposures;
-    CreatePixmapProcPtr CreatePixmap;
-    DestroyPixmapProcPtr DestroyPixmap;
-    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
-    XAAInfoRecPtr AccelInfoRec;
-    Bool (*EnterVT) (ScrnInfoPtr);
-    void (*LeaveVT) (ScrnInfoPtr);
-    int (*SetDGAMode) (ScrnInfoPtr, int, DGADevicePtr);
-    void (*EnableDisableFBAccess) (ScrnInfoPtr, Bool);
-    CompositeProcPtr Composite;
-    GlyphsProcPtr Glyphs;
-} XAAScreenRec, *XAAScreenPtr;
-
-#define	OPS_ARE_PIXMAP		0x00000001
-#define OPS_ARE_ACCEL		0x00000002
-
-typedef struct _XAAGC {
-    GCOps *wrapOps;
-    GCFuncs *wrapFuncs;
-    GCOps *XAAOps;
-    int DashLength;
-    unsigned char *DashPattern;
-    unsigned long changes;
-    unsigned long flags;
-} XAAGCRec, *XAAGCPtr;
-
-#define REDUCIBILITY_CHECKED	0x00000001
-#define REDUCIBLE_TO_8x8	0x00000002
-#define REDUCIBLE_TO_2_COLOR	0x00000004
-#define DIRTY			0x00010000
-#define OFFSCREEN		0x00020000
-#define DGA_PIXMAP		0x00040000
-#define SHARED_PIXMAP		0x00080000
-#define LOCKED_PIXMAP		0x00100000
-
-#define REDUCIBILITY_MASK \
- (REDUCIBILITY_CHECKED | REDUCIBLE_TO_8x8 | REDUCIBLE_TO_2_COLOR)
-
-typedef struct _XAAPixmap {
-    unsigned long flags;
-    CARD32 pattern0;
-    CARD32 pattern1;
-    int fg;
-    int bg;
-    FBAreaPtr offscreenArea;
-    Bool freeData;
-} XAAPixmapRec, *XAAPixmapPtr;
-
-extern _X_EXPORT Bool
- XAACreateGC(GCPtr pGC);
-
-extern _X_EXPORT Bool
- XAAInitAccel(ScreenPtr pScreen, XAAInfoRecPtr infoRec);
-
-extern _X_EXPORT RegionPtr
-
-XAABitBlt(DrawablePtr pSrcDrawable,
-          DrawablePtr pDstDrawable,
-          GC * pGC,
-          int srcx,
-          int srcy,
-          int width,
-          int height,
-          int dstx,
-          int dsty,
-          void (*doBitBlt) (DrawablePtr, DrawablePtr, GCPtr, RegionPtr,
-                            DDXPointPtr), unsigned long bitPlane);
-
-extern _X_EXPORT void
-
-XAAScreenToScreenBitBlt(ScrnInfoPtr pScrn,
-                        int nbox,
-                        DDXPointPtr pptSrc,
-                        BoxPtr pbox,
-                        int xdir, int ydir, int alu, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAADoBitBlt(DrawablePtr pSrc,
-            DrawablePtr pDst, GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc);
-
-extern _X_EXPORT void
-
-XAADoImageWrite(DrawablePtr pSrc,
-                DrawablePtr pDst,
-                GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc);
-
-extern _X_EXPORT void
-
-XAADoImageRead(DrawablePtr pSrc,
-               DrawablePtr pDst,
-               GC * pGC, RegionPtr prgnDst, DDXPointPtr pptSrc);
-
-extern _X_EXPORT void
- XAACopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
-
-extern _X_EXPORT RegionPtr
-
-XAACopyArea(DrawablePtr pSrcDrawable,
-            DrawablePtr pDstDrawable,
-            GC * pGC,
-            int srcx, int srcy, int width, int height, int dstx, int dsty);
-
-extern _X_EXPORT void
- XAAValidateCopyArea(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidatePutImage(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidateCopyPlane(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidatePushPixels(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidateFillSpans(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidatePolyGlyphBlt(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidateImageGlyphBlt(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT void
- XAAValidatePolylines(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
-
-extern _X_EXPORT RegionPtr
-
-XAACopyPlaneColorExpansion(DrawablePtr pSrc,
-                           DrawablePtr pDst,
-                           GCPtr pGC,
-                           int srcx,
-                           int srcy,
-                           int width,
-                           int height,
-                           int dstx, int dsty, unsigned long bitPlane);
-
-extern _X_EXPORT void
-
-XAAPushPixelsSolidColorExpansion(GCPtr pGC,
-                                 PixmapPtr pBitMap,
-                                 DrawablePtr pDrawable,
-                                 int dx, int dy, int xOrg, int yOrg);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpandMSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                           int x, int y, int w, int h,
-                                           unsigned char *src,
-                                           int srcwidth,
-                                           int skipleft,
-                                           int fg, int bg,
-                                           int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpand3MSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                            int x, int y, int w, int h,
-                                            unsigned char *src,
-                                            int srcwidth,
-                                            int skipleft,
-                                            int fg, int bg,
-                                            int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpandMSBFirst(ScrnInfoPtr pScrn,
-                                  int x, int y, int w, int h,
-                                  unsigned char *src,
-                                  int srcwidth,
-                                  int skipleft,
-                                  int fg, int bg,
-                                  int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpand3MSBFirst(ScrnInfoPtr pScrn,
-                                   int x, int y, int w, int h,
-                                   unsigned char *src,
-                                   int srcwidth,
-                                   int skipleft,
-                                   int fg, int bg,
-                                   int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpandLSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                           int x, int y, int w, int h,
-                                           unsigned char *src,
-                                           int srcwidth,
-                                           int skipleft,
-                                           int fg, int bg,
-                                           int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpand3LSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                            int x, int y, int w, int h,
-                                            unsigned char *src,
-                                            int srcwidth,
-                                            int skipleft,
-                                            int fg, int bg,
-                                            int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpandLSBFirst(ScrnInfoPtr pScrn,
-                                  int x, int y, int w, int h,
-                                  unsigned char *src,
-                                  int srcwidth,
-                                  int skipleft,
-                                  int fg, int bg,
-                                  int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapColorExpand3LSBFirst(ScrnInfoPtr pScrn,
-                                   int x, int y, int w, int h,
-                                   unsigned char *src,
-                                   int srcwidth,
-                                   int skipleft,
-                                   int fg, int bg,
-                                   int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpandMSBFirst(ScrnInfoPtr pScrn,
-                                          int x, int y, int w, int h,
-                                          unsigned char *src,
-                                          int srcwidth,
-                                          int skipleft,
-                                          int fg, int bg,
-                                          int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpand3MSBFirst(ScrnInfoPtr pScrn,
-                                           int x, int y, int w, int h,
-                                           unsigned char *src,
-                                           int srcwidth,
-                                           int skipleft,
-                                           int fg, int bg,
-                                           int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpandMSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                                   int x, int y, int w, int h,
-                                                   unsigned char *src,
-                                                   int srcwidth,
-                                                   int skipleft,
-                                                   int fg, int bg,
-                                                   int rop,
-                                                   unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpand3MSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                                    int x, int y, int w, int h,
-                                                    unsigned char *src,
-                                                    int srcwidth,
-                                                    int skipleft,
-                                                    int fg, int bg,
-                                                    int rop,
-                                                    unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpandLSBFirst(ScrnInfoPtr pScrn,
-                                          int x, int y, int w, int h,
-                                          unsigned char *src,
-                                          int srcwidth,
-                                          int skipleft,
-                                          int fg, int bg,
-                                          int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpand3LSBFirst(ScrnInfoPtr pScrn,
-                                           int x, int y, int w, int h,
-                                           unsigned char *src,
-                                           int srcwidth,
-                                           int skipleft,
-                                           int fg, int bg,
-                                           int rop, unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpandLSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                                   int x, int y, int w, int h,
-                                                   unsigned char *src,
-                                                   int srcwidth,
-                                                   int skipleft,
-                                                   int fg, int bg,
-                                                   int rop,
-                                                   unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapScanlineColorExpand3LSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                                    int x, int y, int w, int h,
-                                                    unsigned char *src,
-                                                    int srcwidth,
-                                                    int skipleft,
-                                                    int fg, int bg,
-                                                    int rop,
-                                                    unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAWritePixmap(ScrnInfoPtr pScrn,
-               int x, int y, int w, int h,
-               unsigned char *src,
-               int srcwidth,
-               int rop,
-               unsigned int planemask,
-               int transparency_color, int bpp, int depth);
-
-extern _X_EXPORT void
-
-XAAWritePixmapScanline(ScrnInfoPtr pScrn,
-                       int x, int y, int w, int h,
-                       unsigned char *src,
-                       int srcwidth,
-                       int rop,
-                       unsigned int planemask,
-                       int transparency_color, int bpp, int depth);
-
-typedef void (*ClipAndRenderRectsFunc) (GCPtr, int, BoxPtr, int, int);
-
-extern _X_EXPORT void
-
-XAAClipAndRenderRects(GCPtr pGC,
-                      ClipAndRenderRectsFunc func,
-                      int nrectFill, xRectangle *prectInit, int xorg, int yorg);
-
-typedef void (*ClipAndRenderSpansFunc) (GCPtr, int, DDXPointPtr, int *,
-                                        int, int, int);
-
-extern _X_EXPORT void
-
-XAAClipAndRenderSpans(GCPtr pGC,
-                      DDXPointPtr ppt,
-                      int *pwidth,
-                      int nspans,
-                      int fSorted,
-                      ClipAndRenderSpansFunc func, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillSolidRects(ScrnInfoPtr pScrn,
-                  int fg, int rop,
-                  unsigned int planemask, int nBox, BoxPtr pBox);
-
-extern _X_EXPORT void
-
-XAAFillMono8x8PatternRects(ScrnInfoPtr pScrn,
-                           int fg, int bg, int rop,
-                           unsigned int planemask,
-                           int nBox,
-                           BoxPtr pBox, int pat0, int pat1, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillMono8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask,
-                                       int nBox,
-                                       BoxPtr pBox,
-                                       int pat0, int pat1, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillColor8x8PatternRectsScreenOrigin(ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int nBox,
-                                        BoxPtr pBox,
-                                        int xorigin, int yorigin,
-                                        XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
-
-XAAFillColor8x8PatternRects(ScrnInfoPtr pScrn,
-                            int rop,
-                            unsigned int planemask,
-                            int nBox,
-                            BoxPtr pBox,
-                            int xorigin, int yorigin, XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
-
-XAAFillCacheBltRects(ScrnInfoPtr pScrn,
-                     int rop,
-                     unsigned int planemask,
-                     int nBox,
-                     BoxPtr pBox, int xorg, int yorg, XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
-
-XAAFillCacheExpandRects(ScrnInfoPtr pScrn,
-                        int fg, int bg, int rop,
-                        unsigned int planemask,
-                        int nBox,
-                        BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillImageWriteRects(ScrnInfoPtr pScrn,
-                       int rop,
-                       unsigned int planemask,
-                       int nBox,
-                       BoxPtr pBox, int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAPolyFillRect(DrawablePtr pDraw,
-                GCPtr pGC, int nrectFill, xRectangle *prectInit);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererMSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                    int x, int y, int w, int h, int skipleft,
-                                    int startline, unsigned int **glyphs,
-                                    int glyphWidth, int fg, int bg, int rop,
-                                    unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRenderer3MSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                     int x, int y, int w, int h, int skipleft,
-                                     int startline, unsigned int **glyphs,
-                                     int glyphWidth, int fg, int bg, int rop,
-                                     unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererMSBFirst(ScrnInfoPtr pScrn,
-                           int x, int y, int w, int h, int skipleft,
-                           int startline, unsigned int **glyphs, int glyphWidth,
-                           int fg, int bg, int rop, unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRenderer3MSBFirst(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h, int skipleft,
-                            int startline, unsigned int **glyphs,
-                            int glyphWidth, int fg, int bg, int rop,
-                            unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererLSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                    int x, int y, int w, int h, int skipleft,
-                                    int startline, unsigned int **glyphs,
-                                    int glyphWidth, int fg, int bg, int rop,
-                                    unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRenderer3LSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                     int x, int y, int w, int h, int skipleft,
-                                     int startline, unsigned int **glyphs,
-                                     int glyphWidth, int fg, int bg, int rop,
-                                     unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererLSBFirst(ScrnInfoPtr pScrn,
-                           int x, int y, int w, int h, int skipleft,
-                           int startline, unsigned int **glyphs, int glyphWidth,
-                           int fg, int bg, int rop, unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRenderer3LSBFirst(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h, int skipleft,
-                            int startline, unsigned int **glyphs,
-                            int glyphWidth, int fg, int bg, int rop,
-                            unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererScanlineMSBFirst(ScrnInfoPtr pScrn,
-                                   int x, int y, int w, int h, int skipleft,
-                                   int startline, unsigned int **glyphs,
-                                   int glyphWidth, int fg, int bg, int rop,
-                                   unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererScanline3MSBFirst(ScrnInfoPtr pScrn,
-                                    int x, int y, int w, int h, int skipleft,
-                                    int startline, unsigned int **glyphs,
-                                    int glyphWidth, int fg, int bg, int rop,
-                                    unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererScanlineLSBFirst(ScrnInfoPtr pScrn,
-                                   int x, int y, int w, int h, int skipleft,
-                                   int startline, unsigned int **glyphs,
-                                   int glyphWidth, int fg, int bg, int rop,
-                                   unsigned planemask);
-
-extern _X_EXPORT void
-
-XAATEGlyphRendererScanline3LSBFirst(ScrnInfoPtr pScrn,
-                                    int x, int y, int w, int h, int skipleft,
-                                    int startline, unsigned int **glyphs,
-                                    int glyphWidth, int fg, int bg, int rop,
-                                    unsigned planemask);
-
-extern _X_EXPORT CARD32 *(*XAAGlyphScanlineFuncMSBFirstFixedBase[32]) (CARD32
-                                                                       *base,
-                                                                       unsigned
-                                                                       int
-                                                                       **glyphp,
-                                                                       int line,
-                                                                       int
-                                                                       nglyph,
-                                                                       int
-                                                                       width);
-
-extern _X_EXPORT CARD32 *(*XAAGlyphScanlineFuncMSBFirst[32]) (CARD32 *base,
-                                                              unsigned int
-                                                              **glyphp,
-                                                              int line,
-                                                              int nglyph,
-                                                              int width);
-
-extern _X_EXPORT CARD32 *(*XAAGlyphScanlineFuncLSBFirstFixedBase[32]) (CARD32
-                                                                       *base,
-                                                                       unsigned
-                                                                       int
-                                                                       **glyphp,
-                                                                       int line,
-                                                                       int
-                                                                       nglyph,
-                                                                       int
-                                                                       width);
-
-extern _X_EXPORT CARD32 *(*XAAGlyphScanlineFuncLSBFirst[32]) (CARD32 *base,
-                                                              unsigned int
-                                                              **glyphp,
-                                                              int line,
-                                                              int nglyph,
-                                                              int width);
-
-extern _X_EXPORT GlyphScanlineFuncPtr
-    *XAAGetGlyphScanlineFuncMSBFirstFixedBase(void);
-extern _X_EXPORT GlyphScanlineFuncPtr *XAAGetGlyphScanlineFuncMSBFirst(void);
-extern _X_EXPORT GlyphScanlineFuncPtr
-    *XAAGetGlyphScanlineFuncLSBFirstFixedBase(void);
-extern _X_EXPORT GlyphScanlineFuncPtr *XAAGetGlyphScanlineFuncLSBFirst(void);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRectsLSBFirst(ScrnInfoPtr pScrn,
-                                int fg, int bg, int rop,
-                                unsigned int planemask,
-                                int nBox,
-                                BoxPtr pBox,
-                                int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRects3LSBFirst(ScrnInfoPtr pScrn,
-                                 int fg, int bg, int rop,
-                                 unsigned int planemask,
-                                 int nBox,
-                                 BoxPtr pBox,
-                                 int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRectsLSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int nBox,
-                                         BoxPtr pBox,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRects3LSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                          int fg, int bg, int rop,
-                                          unsigned int planemask,
-                                          int nBox,
-                                          BoxPtr pBox,
-                                          int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRectsMSBFirst(ScrnInfoPtr pScrn,
-                                int fg, int bg, int rop,
-                                unsigned int planemask,
-                                int nBox,
-                                BoxPtr pBox,
-                                int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRects3MSBFirst(ScrnInfoPtr pScrn,
-                                 int fg, int bg, int rop,
-                                 unsigned int planemask,
-                                 int nBox,
-                                 BoxPtr pBox,
-                                 int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRectsMSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int nBox,
-                                         BoxPtr pBox,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandRects3MSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                          int fg, int bg, int rop,
-                                          unsigned int planemask,
-                                          int nBox,
-                                          BoxPtr pBox,
-                                          int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandRectsLSBFirst(ScrnInfoPtr pScrn,
-                                        int fg, int bg, int rop,
-                                        unsigned int planemask,
-                                        int nBox,
-                                        BoxPtr pBox,
-                                        int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandRects3LSBFirst(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int nBox,
-                                         BoxPtr pBox,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandRectsMSBFirst(ScrnInfoPtr pScrn,
-                                        int fg, int bg, int rop,
-                                        unsigned int planemask,
-                                        int nBox,
-                                        BoxPtr pBox,
-                                        int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandRects3MSBFirst(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int nBox,
-                                         BoxPtr pBox,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpansLSBFirst(ScrnInfoPtr pScrn,
-                                int fg, int bg, int rop,
-                                unsigned int planemask,
-                                int n,
-                                DDXPointPtr ppt,
-                                int *pwidth,
-                                int fSorted,
-                                int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpans3LSBFirst(ScrnInfoPtr pScrn,
-                                 int fg, int bg, int rop,
-                                 unsigned int planemask,
-                                 int n,
-                                 DDXPointPtr ppt,
-                                 int *pwidth,
-                                 int fSorted,
-                                 int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpansLSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int n,
-                                         DDXPointPtr ppt,
-                                         int *pwidth,
-                                         int fSorted,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpans3LSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                          int fg, int bg, int rop,
-                                          unsigned int planemask,
-                                          int n,
-                                          DDXPointPtr ppt,
-                                          int *pwidth,
-                                          int fSorted,
-                                          int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpansMSBFirst(ScrnInfoPtr pScrn,
-                                int fg, int bg, int rop,
-                                unsigned int planemask,
-                                int n,
-                                DDXPointPtr ppt,
-                                int *pwidth,
-                                int fSorted,
-                                int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpans3MSBFirst(ScrnInfoPtr pScrn,
-                                 int fg, int bg, int rop,
-                                 unsigned int planemask,
-                                 int n,
-                                 DDXPointPtr ppt,
-                                 int *pwidth,
-                                 int fSorted,
-                                 int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpansMSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int n,
-                                         DDXPointPtr ppt,
-                                         int *pwidth,
-                                         int fSorted,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillColorExpandSpans3MSBFirstFixedBase(ScrnInfoPtr pScrn,
-                                          int fg, int bg, int rop,
-                                          unsigned int planemask,
-                                          int n,
-                                          DDXPointPtr ppt,
-                                          int *pwidth,
-                                          int fSorted,
-                                          int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandSpansLSBFirst(ScrnInfoPtr pScrn,
-                                        int fg, int bg, int rop,
-                                        unsigned int planemask,
-                                        int n,
-                                        DDXPointPtr ppt,
-                                        int *pwidth,
-                                        int fSorted,
-                                        int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandSpans3LSBFirst(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int n,
-                                         DDXPointPtr ppt,
-                                         int *pwidth,
-                                         int fSorted,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAPutImage(DrawablePtr pDraw,
-            GCPtr pGC,
-            int depth,
-            int x, int y, int w, int h, int leftPad, int format, char *pImage);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandSpansMSBFirst(ScrnInfoPtr pScrn,
-                                        int fg, int bg, int rop,
-                                        unsigned int planemask,
-                                        int n,
-                                        DDXPointPtr ppt,
-                                        int *pwidth,
-                                        int fSorted,
-                                        int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillScanlineColorExpandSpans3MSBFirst(ScrnInfoPtr pScrn,
-                                         int fg, int bg, int rop,
-                                         unsigned int planemask,
-                                         int n,
-                                         DDXPointPtr ppt,
-                                         int *pwidth,
-                                         int fSorted,
-                                         int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT CARD32 *(*XAAStippleScanlineFuncMSBFirstFixedBase[6]) (CARD32
-                                                                        *base,
-                                                                        CARD32
-                                                                        *src,
-                                                                        int
-                                                                        offset,
-                                                                        int
-                                                                        width,
-                                                                        int
-                                                                        dwords);
-
-extern _X_EXPORT CARD32 *(*XAAStippleScanlineFuncMSBFirst[6]) (CARD32 *base,
-                                                               CARD32 *src,
-                                                               int offset,
-                                                               int width,
-                                                               int dwords);
-
-extern _X_EXPORT CARD32 *(*XAAStippleScanlineFuncLSBFirstFixedBase[6]) (CARD32
-                                                                        *base,
-                                                                        CARD32
-                                                                        *src,
-                                                                        int
-                                                                        offset,
-                                                                        int
-                                                                        width,
-                                                                        int
-                                                                        dwords);
-
-extern _X_EXPORT CARD32 *(*XAAStippleScanlineFuncLSBFirst[6]) (CARD32 *base,
-                                                               CARD32 *src,
-                                                               int offset,
-                                                               int width,
-                                                               int dwords);
-
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFuncMSBFirstFixedBase(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFuncMSBFirst(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFuncLSBFirstFixedBase(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFuncLSBFirst(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFunc3MSBFirstFixedBase(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFunc3MSBFirst(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFunc3LSBFirstFixedBase(void);
-extern _X_EXPORT StippleScanlineProcPtr
-    *XAAGetStippleScanlineFunc3LSBFirst(void);
-
-extern _X_EXPORT int
-
-XAAPolyText8TEColorExpansion(DrawablePtr pDraw,
-                             GCPtr pGC, int x, int y, int count, char *chars);
-
-extern _X_EXPORT int
-
-XAAPolyText16TEColorExpansion(DrawablePtr pDraw,
-                              GCPtr pGC,
-                              int x, int y, int count, unsigned short *chars);
-
-extern _X_EXPORT void
-
-XAAImageText8TEColorExpansion(DrawablePtr pDraw,
-                              GCPtr pGC, int x, int y, int count, char *chars);
-
-extern _X_EXPORT void
-
-XAAImageText16TEColorExpansion(DrawablePtr pDraw,
-                               GCPtr pGC,
-                               int x, int y, int count, unsigned short *chars);
-
-extern _X_EXPORT void
-
-XAAImageGlyphBltTEColorExpansion(DrawablePtr pDrawable,
-                                 GCPtr pGC,
-                                 int xInit, int yInit,
-                                 unsigned int nglyph,
-                                 CharInfoPtr * ppci, pointer pglyphBase);
-
-extern _X_EXPORT void
-
-XAAPolyGlyphBltTEColorExpansion(DrawablePtr pDrawable,
-                                GCPtr pGC,
-                                int xInit, int yInit,
-                                unsigned int nglyph,
-                                CharInfoPtr * ppci, pointer pglyphBase);
-
-extern _X_EXPORT int
-
-XAAPolyText8NonTEColorExpansion(DrawablePtr pDraw,
-                                GCPtr pGC,
-                                int x, int y, int count, char *chars);
-
-extern _X_EXPORT int
-
-XAAPolyText16NonTEColorExpansion(DrawablePtr pDraw,
-                                 GCPtr pGC,
-                                 int x, int y,
-                                 int count, unsigned short *chars);
-
-extern _X_EXPORT void
-
-XAAImageText8NonTEColorExpansion(DrawablePtr pDraw,
-                                 GCPtr pGC,
-                                 int x, int y, int count, char *chars);
-
-extern _X_EXPORT void
-
-XAAImageText16NonTEColorExpansion(DrawablePtr pDraw,
-                                  GCPtr pGC,
-                                  int x, int y,
-                                  int count, unsigned short *chars);
-
-extern _X_EXPORT void
-
-XAAImageGlyphBltNonTEColorExpansion(DrawablePtr pDrawable,
-                                    GCPtr pGC,
-                                    int xInit, int yInit,
-                                    unsigned int nglyph,
-                                    CharInfoPtr * ppci, pointer pglyphBase);
-
-extern _X_EXPORT void
-
-XAAPolyGlyphBltNonTEColorExpansion(DrawablePtr pDrawable,
-                                   GCPtr pGC,
-                                   int xInit, int yInit,
-                                   unsigned int nglyph,
-                                   CharInfoPtr * ppci, pointer pglyphBase);
-
-extern _X_EXPORT void XAANonTEGlyphRenderer(ScrnInfoPtr pScrn,
-                                            int x, int y, int n,
-                                            NonTEGlyphPtr glyphs,
-                                            BoxPtr pbox,
-                                            int fg, int rop,
-                                            unsigned int planemask);
-
-extern _X_EXPORT void
-
-XAAFillSolidSpans(ScrnInfoPtr pScrn,
-                  int fg, int rop,
-                  unsigned int planemask,
-                  int n, DDXPointPtr ppt, int *pwidth, int fSorted);
-
-extern _X_EXPORT void
-
-XAAFillMono8x8PatternSpans(ScrnInfoPtr pScrn,
-                           int fg, int bg, int rop,
-                           unsigned int planemask,
-                           int n,
-                           DDXPointPtr ppt,
-                           int *pwidth, int fSorted,
-                           int patx, int paty, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillMono8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
-                                       int fg, int bg, int rop,
-                                       unsigned int planemask,
-                                       int n,
-                                       DDXPointPtr ppt,
-                                       int *pwidth, int fSorted,
-                                       int patx, int paty, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillColor8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
-                                        int rop,
-                                        unsigned int planemask,
-                                        int n,
-                                        DDXPointPtr ppt,
-                                        int *pwidth, int fSorted,
-                                        XAACacheInfoPtr,
-                                        int xorigin, int yorigin);
-
-extern _X_EXPORT void
-
-XAAFillColor8x8PatternSpans(ScrnInfoPtr pScrn,
-                            int rop,
-                            unsigned int planemask,
-                            int n,
-                            DDXPointPtr ppt,
-                            int *pwidth, int fSorted,
-                            XAACacheInfoPtr, int xorigin, int yorigin);
-
-extern _X_EXPORT void
-
-XAAFillCacheBltSpans(ScrnInfoPtr pScrn,
-                     int rop,
-                     unsigned int planemask,
-                     int n,
-                     DDXPointPtr points,
-                     int *widths,
-                     int fSorted, XAACacheInfoPtr pCache, int xorg, int yorg);
-
-extern _X_EXPORT void
-
-XAAFillCacheExpandSpans(ScrnInfoPtr pScrn,
-                        int fg, int bg, int rop,
-                        unsigned int planemask,
-                        int n,
-                        DDXPointPtr ppt,
-                        int *pwidth,
-                        int fSorted, int xorg, int yorg, PixmapPtr pPix);
-
-extern _X_EXPORT void
-
-XAAFillSpans(DrawablePtr pDrawable,
-             GC * pGC,
-             int nInit, DDXPointPtr pptInit, int *pwidth, int fSorted);
-
-extern _X_EXPORT void
- XAAInitPixmapCache(ScreenPtr pScreen, RegionPtr areas, pointer data);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapToCache(ScrnInfoPtr pScrn,
-                      int x, int y, int w, int h,
-                      unsigned char *src, int srcwidth, int fg, int bg);
-
-extern _X_EXPORT void
-
-XAAWriteBitmapToCacheLinear(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h,
-                            unsigned char *src, int srcwidth, int fg, int bg);
-
-extern _X_EXPORT void
-
-XAAWritePixmapToCache(ScrnInfoPtr pScrn,
-                      int x, int y, int w, int h,
-                      unsigned char *src, int srcwidth, int bpp, int depth);
-
-extern _X_EXPORT void
-
-XAAWritePixmapToCacheLinear(ScrnInfoPtr pScrn,
-                            int x, int y, int w, int h,
-                            unsigned char *src,
-                            int srcwidth, int bpp, int depth);
-
-extern _X_EXPORT void
- XAASolidHorVertLineAsRects(ScrnInfoPtr pScrn, int x, int y, int len, int dir);
-
-extern _X_EXPORT void
-
-XAASolidHorVertLineAsTwoPoint(ScrnInfoPtr pScrn,
-                              int x, int y, int len, int dir);
-
-extern _X_EXPORT void
-
-XAASolidHorVertLineAsBresenham(ScrnInfoPtr pScrn,
-                               int x, int y, int len, int dir);
-
-extern _X_EXPORT void
-
-XAAPolyRectangleThinSolid(DrawablePtr pDrawable,
-                          GCPtr pGC, int nRectsInit, xRectangle *pRectsInit);
-
-extern _X_EXPORT void
-
-XAAPolylinesWideSolid(DrawablePtr pDrawable,
-                      GCPtr pGC, int mode, int npt, DDXPointPtr pPts);
-
-extern _X_EXPORT void
-
-XAAFillPolygonSolid(DrawablePtr pDrawable,
-                    GCPtr pGC,
-                    int shape, int mode, int count, DDXPointPtr ptsIn);
-
-extern _X_EXPORT void
-
-XAAFillPolygonStippled(DrawablePtr pDrawable,
-                       GCPtr pGC,
-                       int shape, int mode, int count, DDXPointPtr ptsIn);
-
-extern _X_EXPORT void
-
-XAAFillPolygonTiled(DrawablePtr pDrawable,
-                    GCPtr pGC,
-                    int shape, int mode, int count, DDXPointPtr ptsIn);
-
-extern _X_EXPORT int
-
-XAAIsEasyPolygon(DDXPointPtr ptsIn,
-                 int count,
-                 BoxPtr extents,
-                 int origin,
-                 DDXPointPtr * topPoint, int *topY, int *bottomY, int shape);
-
-extern _X_EXPORT void
-
-XAAFillPolygonHelper(ScrnInfoPtr pScrn,
-                     DDXPointPtr ptsIn,
-                     int count,
-                     DDXPointPtr topPoint,
-                     int y,
-                     int maxy,
-                     int origin,
-                     RectFuncPtr RectFunc,
-                     TrapFuncPtr TrapFunc,
-                     int xorg, int yorg, XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
- XAAPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment * pSeg);
-
-extern _X_EXPORT void
-
-XAAPolyLines(DrawablePtr pDrawable,
-             GCPtr pGC, int mode, int npt, DDXPointPtr pptInit);
-
-extern _X_EXPORT void
-
-XAAPolySegmentDashed(DrawablePtr pDrawable,
-                     GCPtr pGC, int nseg, xSegment * pSeg);
-
-extern _X_EXPORT void
-
-XAAPolyLinesDashed(DrawablePtr pDrawable,
-                   GCPtr pGC, int mode, int npt, DDXPointPtr pptInit);
-
-extern _X_EXPORT void
- XAAWriteMono8x8PatternToCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
-
-XAAWriteColor8x8PatternToCache(ScrnInfoPtr pScrn,
-                               PixmapPtr pPix, XAACacheInfoPtr pCache);
-
-extern _X_EXPORT void
-
-XAARotateMonoPattern(int *pat0, int *pat1,
-                     int xoffset, int yoffset, Bool msbfirst);
-
-extern _X_EXPORT void XAAComputeDash(GCPtr pGC);
-
-extern _X_EXPORT void XAAMoveDWORDS_FixedBase(register CARD32 *dest,
-                                              register CARD32 *src,
-                                              register int dwords);
-
-extern _X_EXPORT void XAAMoveDWORDS_FixedSrc(register CARD32 *dest,
-                                             register CARD32 *src,
-                                             register int dwords);
-
-extern _X_EXPORT void XAAMoveDWORDS(register CARD32 *dest,
-                                    register CARD32 *src, register int dwords);
-
-extern _X_EXPORT int
-
-XAAGetRectClipBoxes(GCPtr pGC,
-                    BoxPtr pboxClippedBase,
-                    int nrectFill, xRectangle *prectInit);
-
-extern _X_EXPORT void
- XAASetupOverlay8_32Planar(ScreenPtr);
-
-extern _X_EXPORT void
- XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs);
-
-extern _X_EXPORT XAACacheInfoPtr XAACacheTile(ScrnInfoPtr Scrn, PixmapPtr pPix);
-
-extern _X_EXPORT XAACacheInfoPtr
-XAACacheMonoStipple(ScrnInfoPtr Scrn, PixmapPtr pPix);
-
-extern _X_EXPORT XAACacheInfoPtr
-XAACachePlanarMonoStipple(ScrnInfoPtr Scrn, PixmapPtr pPix);
-
-typedef XAACacheInfoPtr(*XAACachePlanarMonoStippleProc) (ScrnInfoPtr,
-                                                         PixmapPtr);
-extern _X_EXPORT XAACachePlanarMonoStippleProc
-XAAGetCachePlanarMonoStipple(void);
-
-extern _X_EXPORT XAACacheInfoPtr
-XAACacheStipple(ScrnInfoPtr Scrn, PixmapPtr pPix, int fg, int bg);
-
-extern _X_EXPORT XAACacheInfoPtr
-XAACacheMono8x8Pattern(ScrnInfoPtr Scrn, int pat0, int pat1);
-
-extern _X_EXPORT XAACacheInfoPtr
-XAACacheColor8x8Pattern(ScrnInfoPtr Scrn, PixmapPtr pPix, int fg, int bg);
-
-extern _X_EXPORT void
- XAATileCache(ScrnInfoPtr pScrn, XAACacheInfoPtr pCache, int w, int h);
-
-extern _X_EXPORT void XAAClosePixmapCache(ScreenPtr pScreen);
-void XAAInvalidatePixmapCache(ScreenPtr pScreen);
-
-extern _X_EXPORT Bool XAACheckStippleReducibility(PixmapPtr pPixmap);
-extern _X_EXPORT Bool XAACheckTileReducibility(PixmapPtr pPixmap,
-                                               Bool checkMono);
-
-extern _X_EXPORT int XAAStippledFillChooser(GCPtr pGC);
-extern _X_EXPORT int XAAOpaqueStippledFillChooser(GCPtr pGC);
-extern _X_EXPORT int XAATiledFillChooser(GCPtr pGC);
-
-extern _X_EXPORT void XAAMoveInOffscreenPixmaps(ScreenPtr pScreen);
-extern _X_EXPORT void XAAMoveOutOffscreenPixmaps(ScreenPtr pScreen);
-extern _X_EXPORT void XAARemoveAreaCallback(FBAreaPtr area);
-extern _X_EXPORT void XAAMoveOutOffscreenPixmap(PixmapPtr pPix);
-extern _X_EXPORT Bool XAAInitStateWrap(ScreenPtr pScreen,
-                                       XAAInfoRecPtr infoRec);
-
-extern _X_EXPORT void
-
-XAAComposite(CARD8 op,
-             PicturePtr pSrc,
-             PicturePtr pMask,
-             PicturePtr pDst,
-             INT16 xSrc,
-             INT16 ySrc,
-             INT16 xMask,
-             INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
-
-extern _X_EXPORT Bool
-
-XAADoComposite(CARD8 op,
-               PicturePtr pSrc,
-               PicturePtr pMask,
-               PicturePtr pDst,
-               INT16 xSrc,
-               INT16 ySrc,
-               INT16 xMask,
-               INT16 yMask,
-               INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
-
-extern _X_EXPORT void
-
-XAAGlyphs(CARD8 op,
-          PicturePtr pSrc,
-          PicturePtr pDst,
-          PictFormatPtr maskFormat,
-          INT16 xSrc,
-          INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
-
-extern _X_EXPORT Bool
-
-XAADoGlyphs(CARD8 op,
-            PicturePtr pSrc,
-            PicturePtr pDst,
-            PictFormatPtr maskFormat,
-            INT16 xSrc,
-            INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
-
-/* helpers */
-extern _X_EXPORT void
- XAA_888_plus_PICT_a8_to_8888(CARD32 color, CARD8 *alphaPtr,    /* in bytes */
-                              int alphaPitch, CARD32 *dstPtr, int dstPitch,     /* in dwords */
-                              int width, int height);
-
-extern _X_EXPORT Bool
-
-XAAGetRGBAFromPixel(CARD32 pixel,
-                    CARD16 *red,
-                    CARD16 *green, CARD16 *blue, CARD16 *alpha, CARD32 format);
-
-extern _X_EXPORT Bool
-
-XAAGetPixelFromRGBA(CARD32 *pixel,
-                    CARD16 red,
-                    CARD16 green, CARD16 blue, CARD16 alpha, CARD32 format);
-
-/* XXX should be static */
-extern _X_EXPORT GCOps XAAFallbackOps;
-extern _X_EXPORT GCOps *XAAGetFallbackOps(void);
-extern _X_EXPORT GCFuncs XAAGCFuncs;
-extern _X_EXPORT DevPrivateKey XAAGetScreenKey(void);
-extern _X_EXPORT DevPrivateKey XAAGetGCKey(void);
-extern _X_EXPORT DevPrivateKey XAAGetPixmapKey(void);
-
-extern _X_EXPORT unsigned int XAAShiftMasks[32];
-
-extern _X_EXPORT unsigned int byte_expand3[256], byte_reversed_expand3[256];
-
-extern _X_EXPORT CARD32 XAAReverseBitOrder(CARD32 data);
-
-#define GET_XAASCREENPTR_FROM_SCREEN(pScreen)\
-    dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey())
-
-#define GET_XAASCREENPTR_FROM_GC(pGC)\
-    dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAGetScreenKey())
-
-#define GET_XAASCREENPTR_FROM_DRAWABLE(pDraw)\
-    dixLookupPrivate(&(pDraw)->pScreen->devPrivates, XAAGetScreenKey())
-
-#define GET_XAAINFORECPTR_FROM_SCREEN(pScreen)\
-((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->AccelInfoRec
-
-#define GET_XAAINFORECPTR_FROM_GC(pGC)\
-((XAAScreenPtr)dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec
-
-#define GET_XAAINFORECPTR_FROM_DRAWABLE(pDraw)\
-((XAAScreenPtr)dixLookupPrivate(&(pDraw)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec
-
-#define GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn)\
-((XAAScreenPtr)dixLookupPrivate(&(pScrn)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec
-
-#define XAA_GET_PIXMAP_PRIVATE(pix)\
-    (XAAPixmapPtr)dixLookupPrivate(&(pix)->devPrivates, XAAGetPixmapKey())
-
-#define CHECK_RGB_EQUAL(c) (!((((c) >> 8) ^ (c)) & 0xffff))
-
-#define CHECK_FG(pGC, flags) \
-	(!(flags & RGB_EQUAL) || CHECK_RGB_EQUAL(pGC->fgPixel))
-
-#define CHECK_BG(pGC, flags) \
-	(!(flags & RGB_EQUAL) || CHECK_RGB_EQUAL(pGC->bgPixel))
-
-#define CHECK_ROP(pGC, flags) \
-	(!(flags & GXCOPY_ONLY) || (pGC->alu == GXcopy))
-
-#define CHECK_ROPSRC(pGC, flags) \
-	(!(flags & ROP_NEEDS_SOURCE) || ((pGC->alu != GXclear) && \
-	(pGC->alu != GXnoop) && (pGC->alu != GXinvert) && \
-	(pGC->alu != GXset)))
-
-#define CHECK_PLANEMASK(pGC, flags) \
-	(!(flags & NO_PLANEMASK) || \
-	((pGC->planemask & infoRec->FullPlanemasks[pGC->depth - 1]) == \
-          infoRec->FullPlanemasks[pGC->depth - 1]))
-
-#define CHECK_COLORS(pGC, flags) \
-	(!(flags & RGB_EQUAL) || \
-	(CHECK_RGB_EQUAL(pGC->fgPixel) && CHECK_RGB_EQUAL(pGC->bgPixel)))
-
-#define CHECK_NO_GXCOPY(pGC, flags) \
-	((pGC->alu != GXcopy) || !(flags & NO_GXCOPY) || \
-	((pGC->planemask & infoRec->FullPlanemask) != infoRec->FullPlanemask))
-
-#define IS_OFFSCREEN_PIXMAP(pPix)\
-        ((XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pPix)))->offscreenArea)
-
-#define PIXMAP_IS_SHARED(pPix)\
-        ((XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pPix)))->flags & SHARED_PIXMAP)
-
-#define OFFSCREEN_PIXMAP_LOCKED(pPix)\
-        ((XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pPix)))->flags & LOCKED_PIXMAP)
-
-#define XAA_DEPTH_BUG(pGC) \
-        ((pGC->depth == 32) && (pGC->bgPixel == 0xffffffff))
-
-#define DELIST_OFFSCREEN_PIXMAP(pPix) { \
-	PixmapLinkPtr _pLink, _prev; \
-	_pLink = infoRec->OffscreenPixmaps; \
-	_prev = NULL; \
-	while(_pLink) { \
-	    if(_pLink->pPix == pPix) { \
-		if(_prev) _prev->next = _pLink->next; \
-		else infoRec->OffscreenPixmaps = _pLink->next; \
-		free(_pLink); \
-		break; \
-	    } \
-	    _prev = _pLink; \
-	    _pLink = _pLink->next; \
-        }}
-
-#define SWAP_BITS_IN_BYTES(v) \
- (((0x01010101 & (v)) << 7) | ((0x02020202 & (v)) << 5) | \
-  ((0x04040404 & (v)) << 3) | ((0x08080808 & (v)) << 1) | \
-  ((0x10101010 & (v)) >> 1) | ((0x20202020 & (v)) >> 3) | \
-  ((0x40404040 & (v)) >> 5) | ((0x80808080 & (v)) >> 7))
-
-/*
- * Moved XAAPixmapCachePrivate here from xaaPCache.c, since driver
- * replacements for CacheMonoStipple need access to it
- */
-
-typedef struct {
-    int Num512x512;
-    int Current512;
-    XAACacheInfoPtr Info512;
-    int Num256x256;
-    int Current256;
-    XAACacheInfoPtr Info256;
-    int Num128x128;
-    int Current128;
-    XAACacheInfoPtr Info128;
-    int NumMono;
-    int CurrentMono;
-    XAACacheInfoPtr InfoMono;
-    int NumColor;
-    int CurrentColor;
-    XAACacheInfoPtr InfoColor;
-    int NumPartial;
-    int CurrentPartial;
-    XAACacheInfoPtr InfoPartial;
-    DDXPointRec MonoOffsets[64];
-    DDXPointRec ColorOffsets[64];
-} XAAPixmapCachePrivate, *XAAPixmapCachePrivatePtr;
-
-#endif                          /* _XAALOCAL_H */
diff --git a/xorg-server/hw/xfree86/xaa/xaawrap.h b/xorg-server/hw/xfree86/xaa/xaawrap.h
deleted file mode 100644
index 2d2d7881a..000000000
--- a/xorg-server/hw/xfree86/xaa/xaawrap.h
+++ /dev/null
@@ -1,75 +0,0 @@
-
-#define XAA_SCREEN_PROLOGUE(pScreen, field)\
-  ((pScreen)->field = \
-   ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)
-
-#define XAA_SCREEN_EPILOGUE(pScreen, field, wrapper)\
-    ((pScreen)->field = wrapper)
-
-#define XAA_GC_FUNC_PROLOGUE(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    (pGC)->funcs = pGCPriv->wrapFuncs;\
-    if(pGCPriv->flags)\
-	(pGC)->ops = pGCPriv->wrapOps
-
-#define XAA_GC_FUNC_EPILOGUE(pGC)\
-    pGCPriv->wrapFuncs = (pGC)->funcs;\
-    (pGC)->funcs = &XAAGCFuncs;\
-    if(pGCPriv->flags) {\
-	pGCPriv->wrapOps = (pGC)->ops;\
-	(pGC)->ops = (pGCPriv->flags & OPS_ARE_ACCEL) ? pGCPriv->XAAOps :\
-				&XAAPixmapOps;\
-    }
-
-#define XAA_GC_OP_PROLOGUE(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    GCFuncs *oldFuncs = pGC->funcs;\
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps
-
-#define XAA_GC_OP_PROLOGUE_WITH_RETURN(pGC)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    GCFuncs *oldFuncs = pGC->funcs;\
-    if(!RegionNumRects(pGC->pCompositeClip)) return; \
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps
-
-#define XAA_GC_OP_EPILOGUE(pGC)\
-    pGCPriv->wrapOps = pGC->ops;\
-    pGC->funcs = oldFuncs;\
-    pGC->ops   = pGCPriv->XAAOps
-
-#define XAA_PIXMAP_OP_PROLOGUE(pGC, pDraw)\
-    XAAGCPtr pGCPriv = (XAAGCPtr)dixLookupPrivate(&(pGC)->devPrivates, XAAGetGCKey()); \
-    XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE((PixmapPtr)(pDraw));\
-    GCFuncs *oldFuncs = pGC->funcs;\
-    pGC->funcs = pGCPriv->wrapFuncs;\
-    pGC->ops = pGCPriv->wrapOps; \
-    SYNC_CHECK(pGC)
-
-#define XAA_PIXMAP_OP_EPILOGUE(pGC)\
-    pGCPriv->wrapOps = pGC->ops;\
-    pGC->funcs = oldFuncs;\
-    pGC->ops   = &XAAPixmapOps;\
-    pixPriv->flags |= DIRTY
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#define XAA_RENDER_PROLOGUE(pScreen,field)\
-    (GetPictureScreen(pScreen)->field = \
-     ((XAAScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, XAAGetScreenKey()))->field)
-
-#define XAA_RENDER_EPILOGUE(pScreen, field, wrapper)\
-    (GetPictureScreen(pScreen)->field = wrapper)
-
-/* This also works fine for drawables */
-
-#define SYNC_CHECK(pGC) {\
-     XAAInfoRecPtr infoRec =\
-((XAAScreenPtr)dixLookupPrivate(&(pGC)->pScreen->devPrivates, XAAGetScreenKey()))->AccelInfoRec;	\
-    if(infoRec->NeedToSync) {\
-	(*infoRec->Sync)(infoRec->pScrn);\
-	infoRec->NeedToSync = FALSE;\
-    }}