R5xx Accel: split r5xx2DInfo into XAA and EXA specific structs.

* replace rhdPtr->TwoDInfo with rhdPtr->TwoDPrivate.
* various cleanups and even a fix.

7 files changed, 395 insertions, 388 deletions

diff --git a/src/r5xx_accel.c b/src/r5xx_accel.c
index d8def8a..b6150c6 100644
--- a/src/r5xx_accel.c
+++ b/src/r5xx_accel.c
@@ -141,30 +141,33 @@ R5xx2DFlush(int scrnIndex)
 static Bool
 R5xx2DIdleLocal(int scrnIndex)
 {
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
     int i;
 
     /* wait for fifo to clear */
     for (i = 0; i < R5XX_LOOP_COUNT; i++)
-	if (0x40 == (_RHDRegRead(scrnIndex, R5XX_RBBM_STATUS) & R5XX_RBBM_FIFOCNT_MASK))
+	if (0x40 == (RHDRegRead(pScrn, R5XX_RBBM_STATUS) & R5XX_RBBM_FIFOCNT_MASK))
 	    break;
 
     if (i == R5XX_LOOP_COUNT) {
 	xf86DrvMsg(scrnIndex, X_ERROR, "%s: FIFO Timeout 0x%08X.\n", __func__,
-		   (unsigned int) _RHDRegRead(scrnIndex, R5XX_RBBM_STATUS));
+		   (unsigned int) RHDRegRead(pScrn, R5XX_RBBM_STATUS));
 	return FALSE;
     }
 
     /* wait for engine to go idle */
-    for (i = 0; i < R5XX_LOOP_COUNT; i++) {
-	if (!(_RHDRegRead(scrnIndex, R5XX_RBBM_STATUS) & R5XX_RBBM_ACTIVE)) {
-	    R5xx2DFlush(scrnIndex);
-	    return TRUE;
-	}
+    for (i = 0; i < R5XX_LOOP_COUNT; i++)
+	if (!(RHDRegRead(pScrn, R5XX_RBBM_STATUS) & R5XX_RBBM_ACTIVE))
+	    break;
+
+    if (i == R5XX_LOOP_COUNT) {
+	xf86DrvMsg(scrnIndex, X_ERROR, "%s: Idle Timeout 0x%08X.\n", __func__,
+		   (unsigned int) RHDRegRead(pScrn, R5XX_RBBM_STATUS));
+	return FALSE;
     }
 
-    xf86DrvMsg(scrnIndex, X_ERROR, "%s: Idle Timeout 0x%08X.\n", __func__,
-	       (unsigned int) _RHDRegRead(scrnIndex, R5XX_RBBM_STATUS));
-    return FALSE;
+    R5xx2DFlush(scrnIndex);
+    return TRUE;
 }
 
 /*
@@ -204,10 +207,9 @@ R5xx2DReset(ScrnInfoPtr pScrn)
      * unexpected behaviour on some machines.  Here we use
      * R5XX_HOST_PATH_CNTL to reset it. */
     save = RHDRegRead(rhdPtr, R5XX_HOST_PATH_CNTL);
-
-    tmp = RHDRegRead(rhdPtr, R5XX_RBBM_SOFT_RESET);
-    tmp |= R5XX_SOFT_RESET_CP | R5XX_SOFT_RESET_HI | R5XX_SOFT_RESET_E2;
-    RHDRegWrite(rhdPtr, R5XX_RBBM_SOFT_RESET, tmp);
+    RHDRegMask(rhdPtr, R5XX_RBBM_SOFT_RESET,
+	       R5XX_SOFT_RESET_CP | R5XX_SOFT_RESET_HI | R5XX_SOFT_RESET_E2,
+	       R5XX_SOFT_RESET_CP | R5XX_SOFT_RESET_HI | R5XX_SOFT_RESET_E2);
 
     RHDRegRead(rhdPtr, R5XX_RBBM_SOFT_RESET);
     RHDRegWrite(rhdPtr, R5XX_RBBM_SOFT_RESET, 0);
@@ -224,11 +226,35 @@ R5xx2DReset(ScrnInfoPtr pScrn)
 /*
  *
  */
+CARD8
+R5xx2DDatatypeGet(ScrnInfoPtr pScrn)
+{
+    switch (pScrn->depth) {
+    case 8:
+	return R5XX_DATATYPE_CI8;
+    case 15:
+	return R5XX_DATATYPE_ARGB1555;
+    case 16:
+	return R5XX_DATATYPE_RGB565;
+    case 24:
+    case 32:
+	return R5XX_DATATYPE_ARGB8888;
+    default:
+	/* should never happen, as we only support the above bpps */
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Unhandled pixel depth: %d.\n",
+		   __func__, pScrn->depth);
+	return R5XX_DATATYPE_ARGB8888;
+    }
+}
+
+/*
+ *
+ */
 void
 R5xx2DSetup(ScrnInfoPtr pScrn)
 {
     RHDPtr rhdPtr = RHDPTR(pScrn);
-    struct R5xx2DInfo *TwoDInfo = rhdPtr->TwoDInfo;
+    CARD32 tmp;
 
     RHDFUNC(rhdPtr);
 
@@ -236,25 +262,44 @@ R5xx2DSetup(ScrnInfoPtr pScrn)
      * set them appropriately before any accel ops, but let's avoid
      * random bogus DMA in case we inadvertently trigger the engine
      * in the wrong place (happened). */
+    tmp = (((pScrn->displayWidth * (pScrn->bitsPerPixel / 8)) / 64) << 22) |
+	((rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart) >> 10);
+
     R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 2);
-    RHDRegWrite(rhdPtr, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
-    RHDRegWrite(rhdPtr, R5XX_SRC_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(rhdPtr, R5XX_DST_PITCH_OFFSET, tmp);
+    RHDRegWrite(rhdPtr, R5XX_SRC_PITCH_OFFSET, tmp);
 
-    R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 1);
+    R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 2);
 #if X_BYTE_ORDER == X_BIG_ENDIAN
     RHDRegMask(rhdPtr, R5XX_DP_DATATYPE,
 	       R5XX_HOST_BIG_ENDIAN_EN, R5XX_HOST_BIG_ENDIAN_EN);
+
+    switch (pScrn->bitsPerPixel) {
+    case 8:
+	RHDRegWrite(rhdPtr, R5XX_SURFACE_CNTL, 0);
+	break;
+    case 16: /* depths 15 and 16 */
+	RHDRegWrite(rhdPtr, R5XX_SURFACE_CNTL,
+		    R5XX_NONSURF_AP0_SWP_16BPP | R5XX_NONSURF_AP1_SWP_16BPP);
+	break;
+    case 32: /* depth 24 */
+	RHDRegWrite(rhdPtr, R5XX_SURFACE_CNTL,
+		    R5XX_NONSURF_AP0_SWP_32BPP | R5XX_NONSURF_AP1_SWP_32BPP);
+	break;
+    }
 #else
     RHDRegMask(rhdPtr, R5XX_DP_DATATYPE, 0, R5XX_HOST_BIG_ENDIAN_EN);
+    RHDRegWrite(rhdPtr, R5XX_SURFACE_CNTL, 0);
 #endif
 
-    RHDRegWrite(rhdPtr, R5XX_SURFACE_CNTL, TwoDInfo->surface_cntl);
-
     R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 1);
     RHDRegWrite(rhdPtr, R5XX_DEFAULT_SC_BOTTOM_RIGHT,
 		R5XX_DEFAULT_SC_RIGHT_MAX | R5XX_DEFAULT_SC_BOTTOM_MAX);
+
     R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 1);
-    RHDRegWrite(rhdPtr, R5XX_DP_GUI_MASTER_CNTL, TwoDInfo->control |
+    RHDRegWrite(rhdPtr, R5XX_DP_GUI_MASTER_CNTL,
+		(R5xx2DDatatypeGet(pScrn) << R5XX_GMC_DST_DATATYPE_SHIFT) |
+		R5XX_GMC_CLR_CMP_CNTL_DIS | R5XX_GMC_DST_PITCH_OFFSET_CNTL |
 		R5XX_GMC_BRUSH_SOLID_COLOR | R5XX_GMC_SRC_DATATYPE_COLOR);
 
     R5xxFIFOWaitLocal(rhdPtr->scrnIndex, 5);
@@ -268,76 +313,15 @@ R5xx2DSetup(ScrnInfoPtr pScrn)
 }
 
 /*
- * Not called from RHDPreInit, but this sets up things which can only
- * change through PreInit.
+ *
  */
 static void
-R5xx2DPreInit(ScrnInfoPtr pScrn)
+R5xx2DResetFull(ScrnInfoPtr pScrn)
 {
-    RHDPtr rhdPtr = RHDPTR(pScrn);
-    CARD8 datatype, Bytes;
-    struct R5xx2DInfo *TwoDInfo;
-
-    RHDFUNC(rhdPtr);
-
-    TwoDInfo = xnfcalloc(1, sizeof(struct R5xx2DInfo));
-    TwoDInfo->scrnIndex = pScrn->scrnIndex;
-    rhdPtr->TwoDInfo = TwoDInfo;
+    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s!!!!!\n", __func__);
 
-    switch (pScrn->depth) {
-    case 8:
-	Bytes = 1;
-	datatype = R5XX_DATATYPE_CI8;
-	break;
-    case 15:
-	Bytes = 2;
-	datatype = R5XX_DATATYPE_ARGB1555;
-	break;
-    case 16:
-	Bytes = 2;
-	datatype = R5XX_DATATYPE_RGB565;
-	break;
-    case 24:
-    case 32:
-	Bytes = 4;
-	datatype = R5XX_DATATYPE_ARGB8888;
-	break;
-    default:
-	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Unhandled pixel depth: %d.\n",
-		   __func__, pScrn->depth);
-	Bytes = 4;
-	datatype = R5XX_DATATYPE_ARGB8888;
-
-    }
-    TwoDInfo->control = (datatype << R5XX_GMC_DST_DATATYPE_SHIFT) |
-	R5XX_GMC_CLR_CMP_CNTL_DIS | R5XX_GMC_DST_PITCH_OFFSET_CNTL;
-
-#if X_BYTE_ORDER == X_BIG_ENDIAN
-    switch (pScrn->depth) {
-    case 8:
-	TwoDInfo->surface_cntl = 0;
-	break;
-    case 15:
-    case 16:
-	TwoDInfo->surface_cntl =
-	    R5XX_NONSURF_AP0_SWP_16BPP | R5XX_NONSURF_AP1_SWP_16BPP;
-	break;
-    case 24:
-    case 32:
-	TwoDInfo->surface_cntl =
-	    R5XX_NONSURF_AP0_SWP_32BPP | R5XX_NONSURF_AP1_SWP_32BPP;
-	break;
-    }
-#else
-    TwoDInfo->surface_cntl = 0;
-#endif
-
-    TwoDInfo->dst_pitch_offset = (((pScrn->displayWidth * Bytes) / 64) << 22) |
-	((rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart) >> 10);
-
-    /* for ScanlineScreenToScreenColorExpand */
-    TwoDInfo->Buffer = xnfcalloc(1, ((pScrn->virtualX + 31) / 32 * 4) +
-				 (pScrn->virtualX * Bytes));
+    R5xx2DReset(pScrn);
+    R5xx2DSetup(pScrn);
 }
 
 /*
@@ -346,10 +330,8 @@ R5xx2DPreInit(ScrnInfoPtr pScrn)
 void
 R5xxFIFOWait(int scrnIndex, CARD32 required)
 {
-    if (!R5xxFIFOWaitLocal(scrnIndex, required)) {
-	R5xx2DReset(xf86Screens[scrnIndex]);
-	R5xx2DSetup(xf86Screens[scrnIndex]);
-    }
+    if (!R5xxFIFOWaitLocal(scrnIndex, required))
+	R5xx2DResetFull(xf86Screens[scrnIndex]);
 }
 
 /*
@@ -358,27 +340,21 @@ R5xxFIFOWait(int scrnIndex, CARD32 required)
 void
 R5xx2DIdle(ScrnInfoPtr pScrn)
 {
-    if (!R5xx2DIdleLocal(pScrn->scrnIndex)) {
-	R5xx2DReset(pScrn);
-	R5xx2DSetup(pScrn);
-    }
+    if (!R5xx2DIdleLocal(pScrn->scrnIndex))
+	R5xx2DResetFull(pScrn);
 }
 
 /*
  *
  */
 void
-R5xx2DInit(ScrnInfoPtr pScrn)
+R5xx2DStart(ScrnInfoPtr pScrn)
 {
-    RHDPtr rhdPtr = RHDPTR(pScrn);
-
-    R5xx2DPreInit(pScrn);
-
-    RHDRegMask(rhdPtr, R5XX_GB_TILE_CONFIG, 0, R5XX_ENABLE_TILING);
-    RHDRegWrite(rhdPtr, R5XX_WAIT_UNTIL,
+    RHDRegMask(pScrn, R5XX_GB_TILE_CONFIG, 0, R5XX_ENABLE_TILING);
+    RHDRegWrite(pScrn, R5XX_WAIT_UNTIL,
 		R5XX_WAIT_2D_IDLECLEAN | R5XX_WAIT_3D_IDLECLEAN);
-    RHDRegMask(rhdPtr, R5XX_DST_PIPE_CONFIG, R5XX_PIPE_AUTO_CONFIG, R5XX_PIPE_AUTO_CONFIG);
-    RHDRegMask(rhdPtr, R5XX_RB2D_DSTCACHE_MODE,
+    RHDRegMask(pScrn, R5XX_DST_PIPE_CONFIG, R5XX_PIPE_AUTO_CONFIG, R5XX_PIPE_AUTO_CONFIG);
+    RHDRegMask(pScrn, R5XX_RB2D_DSTCACHE_MODE,
 	       R5XX_RB2D_DC_AUTOFLUSH_ENABLE | R5XX_RB2D_DC_DISABLE_IGNORE_PE,
 	       R5XX_RB2D_DC_AUTOFLUSH_ENABLE | R5XX_RB2D_DC_DISABLE_IGNORE_PE);
 
@@ -387,24 +363,6 @@ R5xx2DInit(ScrnInfoPtr pScrn)
 }
 
 /*
- *
- */
-void
-R5xx2DDestroy(ScrnInfoPtr pScrn)
-{
-    RHDPtr rhdPtr = RHDPTR(pScrn);
-    struct R5xx2DInfo *TwoDInfo = rhdPtr->TwoDInfo;
-
-    if (!TwoDInfo)
-	return;
-
-    if (TwoDInfo->Buffer)
-	xfree(TwoDInfo->Buffer);
-    xfree(TwoDInfo);
-    rhdPtr->TwoDInfo = NULL;
-}
-
-/*
  * Impose some acceleration limitations.
  */
 Bool
diff --git a/src/r5xx_accel.h b/src/r5xx_accel.h
index 5dc54d7..bba968d 100644
--- a/src/r5xx_accel.h
+++ b/src/r5xx_accel.h
@@ -37,42 +37,18 @@ struct R5xxRop {
     CARD32 pattern;
 };
 
-struct R5xx2DInfo {
-    int scrnIndex;
-
-    CARD32 dst_pitch_offset; /* Base value for R5XX_DST_PITCH_OFFSET */
-    CARD32 control; /* Base value for R5XX_DP_GUI_MASTER_CNTL */
-    CARD32 control_saved;
-    CARD32 surface_cntl;
-
-    int xdir;
-    int ydir;
-    int trans_color;
-    int scanline_bpp;
-    int scanline_h;
-    int scanline_words;
-
-    CARD8 *Buffer;
-
-#ifdef USE_EXA
-    int exaSyncMarker;
-    int exaMarkerSynced;
-#if X_BYTE_ORDER == X_BIG_ENDIAN
-    unsigned long swapper_surfaces[3];
-#endif /* X_BYTE_ORDER */
-#endif /* USE_EXA */
-};
-
 void R5xxFIFOWait(int scrnIndex, CARD32 required);
 void R5xx2DIdle(ScrnInfoPtr pScrn);
 void R5xx2DSetup(ScrnInfoPtr pScrn); /* to be called after VT switch and such */
-void R5xx2DInit(ScrnInfoPtr pScrn);
-void R5xx2DDestroy(ScrnInfoPtr pScrn);
+void R5xx2DStart(ScrnInfoPtr pScrn);
 
 Bool R5xx2DFBValid(RHDPtr rhdPtr, CARD16 Width, CARD16 Height, int bpp,
 		   CARD32 Offset, CARD32 Size, CARD32 Pitch);
 
-/* XAA specific -- #ifdef this? */
+/* Helper from r5xx_accel.c */
+CARD8 R5xx2DDatatypeGet(ScrnInfoPtr pScrn);
+
+/* XAA specific */
 Bool R5xxXAAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen);
 void R5xxXAADestroy(ScrnInfoPtr pScrn);
 
diff --git a/src/r5xx_exa.c b/src/r5xx_exa.c
index 7b8e058..d7ce881 100644
--- a/src/r5xx_exa.c
+++ b/src/r5xx_exa.c
@@ -36,7 +36,6 @@
 #endif
 
 #include "xf86.h"
-#include "exa.h"
 
 #if HAVE_XF86_ANSIC_H
 # include "xf86_ansic.h"
@@ -48,19 +47,56 @@
 #include "r5xx_accel.h"
 #include "r5xx_regs.h"
 
+#include "exa.h"
+
 extern struct R5xxRop R5xxRops[];
 
+struct R5xxExaPrivate {
+    int scrnIndex;
+
+    int xdir;
+    int ydir;
+
+    int exaSyncMarker;
+    int exaMarkerSynced;
+#if X_BYTE_ORDER == X_BIG_ENDIAN
+    unsigned long swapper_surfaces[3];
+#endif /* X_BYTE_ORDER */
+};
+
+/*
+ * Helpers.
+ */
+inline CARD8
+R5xxEXADatatypeGet(int bitsPerPixel)
+{
+    switch (bitsPerPixel) {
+    case 8:
+	return R5XX_DATATYPE_CI8;
+    case 16:
+	return R5XX_DATATYPE_RGB565;
+    case 32:
+	return R5XX_DATATYPE_ARGB8888;
+    default:
+	return 0;
+    }
+}
+
+#define R5XX_EXA_PITCH_CHECK(pitch) (((pitch) >= 0x4000) || ((pitch) & 0x003F))
+#define R5XX_EXA_OFFSET_CHECK(offset) ((offset) & 0xFFF)
+#define RHDPTRE(p) (RHDPTR(xf86Screens[(p)->myNum]))
+
 /*
  *
  */
 static int
 R5xxEXAMarkSync(ScreenPtr pScreen)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(xf86Screens[pScreen->myNum])->TwoDInfo;
+    struct R5xxExaPrivate *ExaPrivate = RHDPTR(xf86Screens[pScreen->myNum])->TwoDPrivate;
 
-    TwoDInfo->exaSyncMarker++;
+    ExaPrivate->exaSyncMarker++;
 
-    return TwoDInfo->exaSyncMarker;
+    return ExaPrivate->exaSyncMarker;
 }
 
 /*
@@ -70,11 +106,11 @@ static void
 R5xxEXASync(ScreenPtr pScreen, int marker)
 {
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxExaPrivate *ExaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
-    if (TwoDInfo->exaMarkerSynced != marker) {
+    if (ExaPrivate->exaMarkerSynced != marker) {
 	R5xx2DIdle(pScrn);
-	TwoDInfo->exaMarkerSynced = marker;
+	ExaPrivate->exaMarkerSynced = marker;
     }
 }
 
@@ -84,50 +120,41 @@ R5xxEXASync(ScreenPtr pScreen, int marker)
 static Bool
 R5xxEXAPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
+    RHDPtr rhdPtr = RHDPTRE(pPix->drawable.pScreen);
     CARD32 datatype, pitch, offset;
 
-    switch (pPix->drawable.bitsPerPixel) {
-    case 8:
-	datatype = R5XX_DATATYPE_CI8;
-	break;
-    case 16:
-	datatype = R5XX_DATATYPE_RGB565;
-	break;
-    case 32:
-	datatype = R5XX_DATATYPE_ARGB8888;
-	break;
-    default:
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Unsupported bitdepth %d\n",
+    datatype = R5xxEXADatatypeGet(pPix->drawable.bitsPerPixel);
+    if (!datatype) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Unsupported bitdepth %d\n",
 		   __func__, pPix->drawable.bitsPerPixel);
 	return FALSE;
     }
 
     pitch = exaGetPixmapPitch(pPix);
-    if ((pitch >= 0x4000) || (pitch & 0x003F)) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid pitch: %d\n",
+    if (R5XX_EXA_PITCH_CHECK(pitch)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid pitch: %d\n",
 		   __func__, (unsigned int) pitch);
 	return FALSE;
     }
 
     offset = exaGetPixmapOffset(pPix);
-    if (offset & 0x0FFF) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid offset: %d\n",
+    if (R5XX_EXA_OFFSET_CHECK(offset)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid offset: %d\n",
 		   __func__, (unsigned int) offset);
 	return FALSE;
     }
-    offset += RHDPTR(pScrn)->FbIntAddress + RHDPTR(pScrn)->FbScanoutStart;
+    offset += rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart;
 
-    R5xxFIFOWait(pScrn->scrnIndex, 5);
-    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, R5XX_GMC_DST_PITCH_OFFSET_CNTL |
+    R5xxFIFOWait(rhdPtr->scrnIndex, 5);
+    RHDRegWrite(rhdPtr, R5XX_DP_GUI_MASTER_CNTL, R5XX_GMC_DST_PITCH_OFFSET_CNTL |
 		R5XX_GMC_BRUSH_SOLID_COLOR | (datatype << 8) |
 		R5XX_GMC_SRC_DATATYPE_COLOR | R5xxRops[alu].pattern |
 		R5XX_GMC_CLR_CMP_CNTL_DIS);
-    RHDRegWrite(pScrn, R5XX_DP_BRUSH_FRGD_CLR, fg);
-    RHDRegWrite(pScrn, R5XX_DP_WRITE_MASK, pm);
-    RHDRegWrite(pScrn, R5XX_DP_CNTL,
+    RHDRegWrite(rhdPtr, R5XX_DP_BRUSH_FRGD_CLR, fg);
+    RHDRegWrite(rhdPtr, R5XX_DP_WRITE_MASK, pm);
+    RHDRegWrite(rhdPtr, R5XX_DP_CNTL,
 		R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, (pitch << 16) | (offset >> 10));
+    RHDRegWrite(rhdPtr, R5XX_DST_PITCH_OFFSET, (pitch << 16) | (offset >> 10));
 
     return TRUE;
 }
@@ -138,11 +165,11 @@ R5xxEXAPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
 static void
 R5xxEXASolid(PixmapPtr pPix, int x1, int y1, int x2, int y2)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
+    RHDPtr rhdPtr = RHDPTRE(pPix->drawable.pScreen);
 
-    R5xxFIFOWait(pScrn->scrnIndex, 2);
-    RHDRegWrite(pScrn, R5XX_DST_Y_X, (y1 << 16) | x1);
-    RHDRegWrite(pScrn, R5XX_DST_HEIGHT_WIDTH, ((y2 - y1) << 16) | (x2 - x1));
+    R5xxFIFOWait(rhdPtr->scrnIndex, 2);
+    RHDRegWrite(rhdPtr, R5XX_DST_Y_X, (y1 << 16) | x1);
+    RHDRegWrite(rhdPtr, R5XX_DST_HEIGHT_WIDTH, ((y2 - y1) << 16) | (x2 - x1));
 }
 
 /*
@@ -161,72 +188,62 @@ static Bool
 R5xxEXAPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int xdir, int ydir, int rop,
 		   Pixel planemask)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
-    RHDPtr rhdPtr = RHDPTR(pScrn);
-    struct R5xx2DInfo *TwoDInfo = rhdPtr->TwoDInfo;
+    RHDPtr rhdPtr = RHDPTRE(pDst->drawable.pScreen);
+    struct R5xxExaPrivate *ExaPrivate = rhdPtr->TwoDPrivate;
     CARD32 datatype, srcpitch, srcoffset, dstpitch, dstoffset;
 
-    TwoDInfo->xdir = xdir;
-    TwoDInfo->ydir = ydir;
+    ExaPrivate->xdir = xdir;
+    ExaPrivate->ydir = ydir;
 
-    switch (pDst->drawable.bitsPerPixel) {
-    case 8:
-	datatype = R5XX_DATATYPE_CI8;
-	break;
-    case 16:
-	datatype = R5XX_DATATYPE_RGB565;
-	break;
-    case 32:
-	datatype = R5XX_DATATYPE_ARGB8888;
-	break;
-    default:
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Unsupported bitdepth %d\n",
+    datatype = R5xxEXADatatypeGet(pDst->drawable.bitsPerPixel);
+    if (!datatype) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Unsupported bitdepth %d\n",
 		   __func__, pDst->drawable.bitsPerPixel);
 	return FALSE;
     }
 
     srcpitch = exaGetPixmapPitch(pSrc);
-    if ((srcpitch >= 0x4000) || (srcpitch & 0x003F)) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid source pitch: %d\n",
+    if (R5XX_EXA_PITCH_CHECK(srcpitch)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid source pitch: %d\n",
 		   __func__, (unsigned int) srcpitch);
 	return FALSE;
     }
 
     srcoffset = exaGetPixmapOffset(pSrc);
-    if (srcoffset & 0x0FFF) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid source offset: %d\n",
+    if (R5XX_EXA_OFFSET_CHECK(srcoffset)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid source offset: %d\n",
 		   __func__, (unsigned int) srcoffset);
 	return FALSE;
     }
     srcoffset += rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart;
 
     dstpitch = exaGetPixmapPitch(pDst);
-    if ((dstpitch >= 0x4000) || (dstpitch & 0x003F)) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid destination pitch: %d\n",
+    if (R5XX_EXA_PITCH_CHECK(dstpitch)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid destination pitch: %d\n",
 		   __func__, (unsigned int) dstpitch);
 	return FALSE;
     }
 
     dstoffset = exaGetPixmapOffset(pDst);
-    if (dstoffset & 0x0FFF) {
-	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: Invalid destination offset: %d\n",
+    if (R5XX_EXA_OFFSET_CHECK(dstoffset)) {
+	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Invalid destination offset: %d\n",
 		   __func__, (unsigned int) dstoffset);
 	return FALSE;
     }
     dstoffset += rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart;
 
-    R5xxFIFOWait(pScrn->scrnIndex, 5);
-    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL,
+    R5xxFIFOWait(rhdPtr->scrnIndex, 5);
+    RHDRegWrite(rhdPtr, R5XX_DP_GUI_MASTER_CNTL,
 		R5XX_GMC_DST_PITCH_OFFSET_CNTL | R5XX_GMC_SRC_PITCH_OFFSET_CNTL |
 		R5XX_GMC_BRUSH_NONE | (datatype << 8) |
 		R5XX_GMC_SRC_DATATYPE_COLOR | R5xxRops[rop].rop |
 		R5XX_DP_SRC_SOURCE_MEMORY | R5XX_GMC_CLR_CMP_CNTL_DIS);
-    RHDRegWrite(pScrn, R5XX_DP_WRITE_MASK, planemask);
-    RHDRegWrite(pScrn, R5XX_DP_CNTL,
+    RHDRegWrite(rhdPtr, R5XX_DP_WRITE_MASK, planemask);
+    RHDRegWrite(rhdPtr, R5XX_DP_CNTL,
 		((xdir >= 0 ? R5XX_DST_X_LEFT_TO_RIGHT : 0) |
 		 (ydir >= 0 ? R5XX_DST_Y_TOP_TO_BOTTOM : 0)));
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, (dstpitch << 16) | (dstoffset >> 10));
-    RHDRegWrite(pScrn, R5XX_SRC_PITCH_OFFSET, (srcpitch << 16) | (srcoffset >> 10));
+    RHDRegWrite(rhdPtr, R5XX_DST_PITCH_OFFSET, (dstpitch << 16) | (dstoffset >> 10));
+    RHDRegWrite(rhdPtr, R5XX_SRC_PITCH_OFFSET, (srcpitch << 16) | (srcoffset >> 10));
 
     return TRUE;
 }
@@ -237,23 +254,23 @@ R5xxEXAPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int xdir, int ydir, int rop,
 void
 R5xxEXACopy(PixmapPtr pDst, int srcX, int srcY, int dstX, int dstY, int w, int h)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    RHDPtr rhdPtr = RHDPTRE(pDst->drawable.pScreen);
+    struct R5xxExaPrivate *ExaPrivate = rhdPtr->TwoDPrivate;
 
-    if (TwoDInfo->xdir < 0) {
+    if (ExaPrivate->xdir < 0) {
 	srcX += w - 1;
 	dstX += w - 1;
     }
-    if (TwoDInfo->ydir < 0) {
+    if (ExaPrivate->ydir < 0) {
 	srcY += h - 1;
 	dstY += h - 1;
     }
 
-    R5xxFIFOWait(pScrn->scrnIndex, 3);
+    R5xxFIFOWait(rhdPtr->scrnIndex, 3);
 
-    RHDRegWrite(pScrn, R5XX_SRC_Y_X, (srcY << 16) | srcX);
-    RHDRegWrite(pScrn, R5XX_DST_Y_X, (dstY << 16) | dstX);
-    RHDRegWrite(pScrn, R5XX_DST_HEIGHT_WIDTH, (h  << 16) | w);
+    RHDRegWrite(rhdPtr, R5XX_SRC_Y_X, (srcY << 16) | srcX);
+    RHDRegWrite(rhdPtr, R5XX_DST_Y_X, (dstY << 16) | dstX);
+    RHDRegWrite(rhdPtr, R5XX_DST_HEIGHT_WIDTH, (h  << 16) | w);
 }
 
 /*
@@ -272,7 +289,7 @@ static Bool
 R5xxEXAUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h,
 		      char *src, int src_pitch)
 {
-    RHDPtr rhdPtr = RHDPTR(xf86Screens[pDst->drawable.pScreen->myNum]);
+    RHDPtr rhdPtr = RHDPTRE(pDst->drawable.pScreen);
     CARD8 *dst = ((CARD8 *) rhdPtr->FbBase) +
 	rhdPtr->FbScanoutStart + exaGetPixmapOffset(pDst);
     int dst_pitch = exaGetPixmapPitch(pDst);
@@ -302,7 +319,7 @@ static Bool
 R5xxEXADownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h,
 			  char *dst, int dst_pitch)
 {
-    RHDPtr rhdPtr = RHDPTR(xf86Screens[pSrc->drawable.pScreen->myNum]);
+    RHDPtr rhdPtr = RHDPTRE(pSrc->drawable.pScreen);
     CARD8 *src = ((CARD8 *) rhdPtr->FbBase) +
 	rhdPtr->FbScanoutStart + exaGetPixmapOffset(pSrc);
     int	src_pitch = exaGetPixmapPitch(pSrc);
@@ -332,7 +349,7 @@ static Bool
 R5xxEXAPrepareAccess(PixmapPtr pPix, int index)
 {
     ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxExaPrivate *ExaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     CARD32 offset = exaGetPixmapOffset(pPix);
     int soff;
     CARD32 size, flags;
@@ -368,7 +385,7 @@ R5xxEXAPrepareAccess(PixmapPtr pPix, int index)
     RHDRegWrite(pScrn, R5XX_SURFACE0_INFO + soff, flags);
     RHDRegWrite(pScrn, R5XX_SURFACE0_LOWER_BOUND + soff, offset);
     RHDRegWrite(pScrn, R5XX_SURFACE0_UPPER_BOUND + soff, offset + size - 1);
-    TwoDInfo->swapper_surfaces[index] = offset;
+    ExaPrivate->swapper_surfaces[index] = offset;
     return TRUE;
 }
 
@@ -378,8 +395,8 @@ R5xxEXAPrepareAccess(PixmapPtr pPix, int index)
 static void
 R5xxEXAFinishAccess(PixmapPtr pPix, int index)
 {
-    ScrnInfoPtr pScrn = xf86Screens[pPix->drawable.pScreen->myNum];
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    RHDPtr rhdPtr = RHDPTRE(pPix->drawable.pScreen);
+    struct R5xxExaPrivate *ExaPrivate = rhdPtr->TwoDPrivate;
     CARD32 offset = exaGetPixmapOffset(pPix);
     int soff;
 
@@ -387,14 +404,14 @@ R5xxEXAFinishAccess(PixmapPtr pPix, int index)
     if (offset == 0)
         return;
 
-    if (TwoDInfo->swapper_surfaces[index] == 0)
+    if (ExaPrivate->swapper_surfaces[index] == 0)
         return;
 
     soff = (index + 1) * 0x10;
-    RHDRegWrite(pScrn, R5XX_SURFACE0_INFO + soff, 0);
-    RHDRegWrite(pScrn, R5XX_SURFACE0_LOWER_BOUND + soff, 0);
-    RHDRegWrite(pScrn, R5XX_SURFACE0_UPPER_BOUND + soff, 0);
-    TwoDInfo->swapper_surfaces[index] = 0;
+    RHDRegWrite(rhdPtr, R5XX_SURFACE0_INFO + soff, 0);
+    RHDRegWrite(rhdPtr, R5XX_SURFACE0_LOWER_BOUND + soff, 0);
+    RHDRegWrite(rhdPtr, R5XX_SURFACE0_UPPER_BOUND + soff, 0);
+    ExaPrivate->swapper_surfaces[index] = 0;
 }
 
 #endif /* X_BYTE_ORDER == X_BIG_ENDIAN */
@@ -407,11 +424,10 @@ R5xxEXAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
 {
     RHDPtr rhdPtr = RHDPTR(pScrn);
     ExaDriverRec *EXAInfo;
+    struct R5xxExaPrivate *ExaPrivate;
 
     RHDFUNC(pScrn);
 
-    R5xx2DInit(pScrn);
-
     EXAInfo = exaDriverAlloc();
     if (EXAInfo == NULL)
 	return FALSE;
@@ -457,10 +473,19 @@ R5xxEXAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
 	xfree(EXAInfo);
 	return FALSE;
     }
-    exaMarkSync(pScreen);
 
     RHDPTR(pScrn)->EXAInfo = EXAInfo;
 
+    ExaPrivate = xnfcalloc(1, sizeof(struct R5xxExaPrivate));
+    ExaPrivate->scrnIndex = pScrn->scrnIndex;
+
+    rhdPtr->TwoDPrivate = ExaPrivate;
+
+    exaMarkSync(pScreen);
+
+    /* start the engine already */
+    R5xx2DStart(pScrn);
+
     return TRUE;
 }
 
@@ -481,11 +506,13 @@ R5xxEXADestroy(ScrnInfoPtr pScrn)
 {
     RHDPtr rhdPtr = RHDPTR(pScrn);
 
-    if (!rhdPtr->EXAInfo)
-	return;
-
-    xfree(rhdPtr->EXAInfo);
-    rhdPtr->EXAInfo = NULL;
+    if (rhdPtr->EXAInfo) {
+	xfree(rhdPtr->EXAInfo);
+	rhdPtr->EXAInfo = NULL;
+    }
 
-    R5xx2DDestroy(pScrn);
+    if (rhdPtr->TwoDPrivate) {
+	xfree(rhdPtr->TwoDPrivate);
+	rhdPtr->TwoDPrivate = NULL;
+    }
 }
diff --git a/src/r5xx_xaa.c b/src/r5xx_xaa.c
index a4a17dc..907d8aa 100644
--- a/src/r5xx_xaa.c
+++ b/src/r5xx_xaa.c
@@ -78,6 +78,34 @@
 
 extern struct R5xxRop R5xxRops[];
 
+struct R5xxXaaPrivate {
+    int scrnIndex;
+
+    CARD32 dst_pitch_offset; /* Base value for R5XX_DST_PITCH_OFFSET */
+    CARD32 control; /* Base value for R5XX_DP_GUI_MASTER_CNTL */
+    CARD32 control_saved;
+
+    int xdir;
+    int ydir;
+
+    int trans_color;
+
+    int scanline_x;
+    int scanline_y;
+    int scanline_w;
+    CARD32 scanline_h; /* R5xx */
+    CARD32 scanline_words; /* R5xx */
+    int scanline_bpp; /* Only used for ImageWrite -- R5xx */
+    int scanline_fg;
+    int scanline_bg;
+    int scanline_hpass;
+    int scanline_x1clip;
+    int scanline_x2clip;
+
+    CARD8 *Buffer;
+    CARD8 *BufferHook[1];
+};
+
 /* Set up for transparency
  *
  * Mmmm, Seems as though the transparency compare is opposite to r128.
@@ -101,7 +129,7 @@ R5xxXAASetTransparency(ScrnInfoPtr pScrn, int trans_color)
 static void
 R5xxXAASetClippingRectangle(ScrnInfoPtr pScrn, int xa, int ya, int xb, int yb)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     unsigned long tmp1, tmp2;
 
     if (xa < 0) {
@@ -133,13 +161,13 @@ R5xxXAASetClippingRectangle(ScrnInfoPtr pScrn, int xa, int ya, int xb, int yb)
 
     R5xxFIFOWait(pScrn->scrnIndex, 3);
 
-    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, TwoDInfo->control_saved |
+    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, XaaPrivate->control_saved |
 		  R5XX_GMC_DST_CLIPPING);
     RHDRegWrite(pScrn, R5XX_SC_TOP_LEFT, tmp1);
     RHDRegWrite(pScrn, R5XX_SC_BOTTOM_RIGHT, tmp2);
 
-    if (TwoDInfo->trans_color != -1)
-	R5xxXAASetTransparency(pScrn, TwoDInfo->trans_color);
+    if (XaaPrivate->trans_color != -1)
+	R5xxXAASetTransparency(pScrn, XaaPrivate->trans_color);
 }
 
 /*
@@ -148,16 +176,16 @@ R5xxXAASetClippingRectangle(ScrnInfoPtr pScrn, int xa, int ya, int xb, int yb)
 static void
 R5xxXAADisableClipping(ScrnInfoPtr pScrn)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
     R5xxFIFOWait(pScrn->scrnIndex, 3);
 
-    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, TwoDInfo->control_saved);
+    RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, XaaPrivate->control_saved);
     RHDRegWrite(pScrn, R5XX_SC_TOP_LEFT, 0);
     RHDRegWrite(pScrn, R5XX_SC_BOTTOM_RIGHT,
 		  R5XX_DEFAULT_SC_RIGHT_MAX | R5XX_DEFAULT_SC_BOTTOM_MAX);
-    if (TwoDInfo->trans_color != -1)
-	R5xxXAASetTransparency(pScrn, TwoDInfo->trans_color);
+    if (XaaPrivate->trans_color != -1)
+	R5xxXAASetTransparency(pScrn, XaaPrivate->trans_color);
 }
 
 /*
@@ -167,14 +195,14 @@ static void
 R5xxXAASetupForSolidFill(ScrnInfoPtr pScrn,
 			 int color, int rop, unsigned int planemask)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     CARD32 control;
 
-    control = TwoDInfo->control | R5xxRops[rop].pattern;
+    control = XaaPrivate->control | R5xxRops[rop].pattern;
     control |= R5XX_GMC_BRUSH_SOLID_COLOR | R5XX_GMC_SRC_DATATYPE_COLOR;
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
     R5xxFIFOWait(pScrn->scrnIndex, 4);
 
@@ -191,11 +219,11 @@ R5xxXAASetupForSolidFill(ScrnInfoPtr pScrn,
 static void
 R5xxXAASubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
     R5xxFIFOWait(pScrn->scrnIndex, 3);
 
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (y << 16) | x);
     RHDRegWrite(pScrn, R5XX_DST_WIDTH_HEIGHT, (w << 16) | h);
 }
@@ -207,14 +235,14 @@ static void
 R5xxXAASetupForSolidLine(ScrnInfoPtr pScrn,
 			 int color, int rop, unsigned int planemask)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
-    CARD32 control = TwoDInfo->control;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
+    CARD32 control = XaaPrivate->control;
 
     control |= R5XX_GMC_BRUSH_SOLID_COLOR |
 	R5XX_GMC_SRC_DATATYPE_COLOR | R5xxRops[rop].pattern;
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
     R5xxFIFOWait(pScrn->scrnIndex, 4);
 
@@ -231,7 +259,7 @@ static void
 R5xxXAASubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
 				  int x, int y, int len, int dir)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     int w = 1, h = 1;
 
     if (dir == DEGREES_0)
@@ -243,7 +271,7 @@ R5xxXAASubsequentSolidHorVertLine(ScrnInfoPtr pScrn,
 
     RHDRegWrite(pScrn, R5XX_DP_CNTL,
 		R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM);
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (y << 16) | x);
     RHDRegWrite(pScrn, R5XX_DST_WIDTH_HEIGHT, (w << 16) | h);
 }
@@ -259,14 +287,14 @@ static void
 R5xxXAASubsequentSolidTwoPointLine(ScrnInfoPtr pScrn, int xa, int ya,
 				   int xb, int yb, int flags)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
     if (!(flags & OMIT_LAST))
 	R5xxXAASubsequentSolidHorVertLine(pScrn, xb, yb, 1, DEGREES_0);
 
     R5xxFIFOWait(pScrn->scrnIndex, 3);
 
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_DST_LINE_START, (ya << 16) | xa);
     RHDRegWrite(pScrn, R5XX_DST_LINE_END, (yb << 16) | xb);
 }
@@ -278,19 +306,19 @@ static void
 R5xxXAASetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir, int rop,
 				  unsigned int planemask, int trans_color)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     CARD32 control;
 
-    TwoDInfo->xdir = xdir;
-    TwoDInfo->ydir = ydir;
+    XaaPrivate->xdir = xdir;
+    XaaPrivate->ydir = ydir;
 
-    control = TwoDInfo->control;
+    control = XaaPrivate->control;
     control |= R5XX_GMC_BRUSH_NONE | R5XX_GMC_SRC_DATATYPE_COLOR |
 	R5xxRops[rop].rop | R5XX_DP_SRC_SOURCE_MEMORY |
 	R5XX_GMC_SRC_PITCH_OFFSET_CNTL;
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
     R5xxFIFOWait(pScrn->scrnIndex, 3);
 
@@ -300,7 +328,7 @@ R5xxXAASetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir, int rop
 		((xdir >= 0 ? R5XX_DST_X_LEFT_TO_RIGHT : 0) |
 		 (ydir >= 0 ? R5XX_DST_Y_TOP_TO_BOTTOM : 0)));
 
-    TwoDInfo->trans_color = trans_color;
+    XaaPrivate->trans_color = trans_color;
     if (trans_color != -1)
 	R5xxXAASetTransparency(pScrn, trans_color);
 }
@@ -312,22 +340,22 @@ static void
 R5xxXAASubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int xa, int ya,
 				    int xb, int yb, int w, int h)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
-    if (TwoDInfo->xdir < 0) {
+    if (XaaPrivate->xdir < 0) {
 	xa += w - 1;
 	xb += w - 1;
     }
 
-    if (TwoDInfo->ydir < 0) {
+    if (XaaPrivate->ydir < 0) {
 	ya += h - 1;
 	yb += h - 1;
     }
 
     R5xxFIFOWait(pScrn->scrnIndex, 5);
 
-    RHDRegWrite(pScrn, R5XX_SRC_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_SRC_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_SRC_Y_X, (ya << 16) | xa);
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (yb << 16) | xb);
     RHDRegWrite(pScrn, R5XX_DST_HEIGHT_WIDTH, (h << 16) | w);
@@ -344,7 +372,7 @@ static void
 R5xxXAASetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patternx, int patterny,
 				  int fg, int bg, int rop, unsigned int planemask)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     CARD32 control;
 
 #if X_BYTE_ORDER == X_BIG_ENDIAN
@@ -356,7 +384,7 @@ R5xxXAASetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patternx, int patterny,
     patterny = CARD32SWAP(patterny);
 #endif
 
-    control = TwoDInfo->control | R5xxRops[rop].pattern;
+    control = XaaPrivate->control | R5xxRops[rop].pattern;
     if (bg != -1)
 	control |= R5XX_GMC_BRUSH_8X8_MONO_FG_BG;
     else
@@ -366,12 +394,12 @@ R5xxXAASetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patternx, int patterny,
 #endif
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
     if (bg != -1)
-	R5xxFIFOWait(pScrn->scrnIndex, 5);
-    else
 	R5xxFIFOWait(pScrn->scrnIndex, 6);
+    else
+	R5xxFIFOWait(pScrn->scrnIndex, 5);
 
     RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, control);
     RHDRegWrite(pScrn, R5XX_DP_WRITE_MASK, planemask);
@@ -391,11 +419,11 @@ R5xxXAASubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
 					int patternx, int patterny,
 					int x, int y, int w, int h)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
     R5xxFIFOWait(pScrn->scrnIndex, 4);
 
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_BRUSH_Y_X, (patterny << 8) | patternx);
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (y << 16) | x);
     RHDRegWrite(pScrn, R5XX_DST_HEIGHT_WIDTH, (h << 16) | w);
@@ -405,15 +433,16 @@ R5xxXAASubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
  * Because of how the scratch buffer is initialized, this is really a
  * mainstore-to-screen color expansion.  Transparency is supported when
  * `bg == -1'.
+ * We always need to provide the bg here, otherwise the engine locks.
  */
 static void
 R5xxXAASetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int fg, int bg,
 						  int rop, unsigned int planemask)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
-    CARD32 control = TwoDInfo->control;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
+    CARD32 control = XaaPrivate->control;
 
-    TwoDInfo->scanline_bpp = 0;
+    XaaPrivate->scanline_bpp = 0;
 
     control |= R5XX_GMC_DST_CLIPPING | R5XX_GMC_BRUSH_NONE |
 	R5xxRops[rop].rop | R5XX_DP_SRC_SOURCE_HOST_DATA;
@@ -430,27 +459,19 @@ R5xxXAASetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int fg, int
 #endif
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
 #if X_BYTE_ORDER == X_LITTLE_ENDIAN
-    if (bg != -1)
-	R5xxFIFOWait(pScrn->scrnIndex, 4);
-    else
-	R5xxFIFOWait(pScrn->scrnIndex, 3);
+    R5xxFIFOWait(pScrn->scrnIndex, 4);
 #else
-    if (bg != -1)
-	R5xxFIFOWait(pScrn->scrnIndex, 5);
-    else
-	R5xxFIFOWait(pScrn->scrnIndex, 4);
+    R5xxFIFOWait(pScrn->scrnIndex, 5);
 
     RHDRegWrite(pScrn, R5XX_RBBM_GUICNTL, R5XX_HOST_DATA_SWAP_NONE);
 #endif
     RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, control);
     RHDRegWrite(pScrn, R5XX_DP_WRITE_MASK, planemask);
     RHDRegWrite(pScrn, R5XX_DP_SRC_FRGD_CLR, fg);
-
-    if (bg != -1)
-	RHDRegWrite(pScrn, R5XX_DP_SRC_BKGD_CLR, bg);
+    RHDRegWrite(pScrn, R5XX_DP_SRC_BKGD_CLR, bg);
 }
 
 /* Subsequent XAA indirect CPU-to-screen color expansion.  This is only
@@ -460,14 +481,14 @@ static void
 R5xxXAASubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int x, int y,
 						    int w, int h, int skipleft)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
 
-    TwoDInfo->scanline_h = h;
-    TwoDInfo->scanline_words = (w + 31) >> 5;
+    XaaPrivate->scanline_h = h;
+    XaaPrivate->scanline_words = (w + 31) >> 5;
 
     R5xxFIFOWait(pScrn->scrnIndex, 5);
 
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_SC_TOP_LEFT, (y << 16) | ((x + skipleft) & 0xffff));
     RHDRegWrite(pScrn, R5XX_SC_BOTTOM_RIGHT, ((y + h) << 16) | ((x + w) & 0xffff));
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (y << 16) | (x & 0xffff));
@@ -481,41 +502,38 @@ R5xxXAASubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn, int x, in
 static void
 R5xxXAASubsequentScanline(ScrnInfoPtr pScrn, int bufno)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
-    CARD32 *p = (CARD32 *) TwoDInfo->Buffer;
-    int i, left = TwoDInfo->scanline_words;
-
-    TwoDInfo->scanline_h--;
-
-    while (left) {
-	write_mem_barrier();
-	if (TwoDInfo->scanline_h == 0) {
-	    /* Last scanline - finish write to DATA_LAST */
-	    if (left <= 9) {
-		R5xxFIFOWait(pScrn->scrnIndex, left);
-		for (i = 4 * (9 - left); i < 36; i += 4)
-		    RHDRegWrite(pScrn, R5XX_HOST_DATA0 + i, *p++);
-		left = 0;
-	    } else {
-		R5xxFIFOWait(pScrn->scrnIndex, 8);
-		for (i = 0; i < 32; i += 4)
-		    RHDRegWrite(pScrn, R5XX_HOST_DATA0 + i, *p++);
-		left -= 8;
-	    }
-	} else {
-	    if (left <= 8) {
-		R5xxFIFOWait(pScrn->scrnIndex, left);
-		for (i = 8 - left; i < 8; i++)
-		    RHDRegWrite(pScrn, R5XX_HOST_DATA0 + 4 * i, *p++);
-		left = 0;
-	    } else {
-		R5xxFIFOWait(pScrn->scrnIndex, 8);
-		for (i = 0; i < 8; i++)
-		    RHDRegWrite(pScrn, R5XX_HOST_DATA0 + 4 * i, *p++);
-		left -= 8;
-	    }
-	}
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
+    CARD32 *p = (CARD32 *) XaaPrivate->BufferHook[bufno];
+    int i, remainder, left = XaaPrivate->scanline_words;
+    CARD16 Reg;
+
+    XaaPrivate->scanline_h--;
+
+    if (XaaPrivate->scanline_h)
+	remainder = 8;
+    else
+	remainder = 9;
+
+    while (left > remainder) {
+	Reg = R5XX_HOST_DATA0;
+
+	R5xxFIFOWait(pScrn->scrnIndex, 8);
+	for (i = 0; i < 8; i++, Reg += 4)
+	    RHDRegWrite(pScrn, Reg, *p++);
+
+	left -= 8;
     }
+
+    if (XaaPrivate->scanline_h)
+	Reg = R5XX_HOST_DATA7;
+    else
+	Reg = R5XX_HOST_DATA_LAST; /* Last scanline - finish write to DATA_LAST */
+
+    Reg -= 4 * (left - 1);
+
+    R5xxFIFOWait(pScrn->scrnIndex, left);
+    for (i = 0; i < left; i++, Reg += 4)
+        RHDRegWrite(pScrn, Reg, *p++);
 }
 
 /*
@@ -525,20 +543,17 @@ static void
 R5xxXAASetupForScanlineImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
 				  int trans_color, int bpp, int depth)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
-    CARD32 control = TwoDInfo->control;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
+    CARD32 control = XaaPrivate->control;
 
-    ErrorF("%s(rop = %d, planemask = 0x%08X, trans_color = %d, bpp = %d, depth = %d)\n",
-	   __func__, rop, planemask, trans_color, bpp, depth);
-
-    TwoDInfo->scanline_bpp = bpp;
+    XaaPrivate->scanline_bpp = bpp;
 
     control |= R5XX_GMC_DST_CLIPPING | R5XX_GMC_BRUSH_NONE |
 	R5XX_GMC_SRC_DATATYPE_COLOR | R5xxRops[rop].rop |
 	R5XX_GMC_BYTE_MSB_TO_LSB | R5XX_DP_SRC_SOURCE_HOST_DATA;
 
     /* Save for later clipping */
-    TwoDInfo->control_saved = control;
+    XaaPrivate->control_saved = control;
 
 #if X_BYTE_ORDER == X_LITTLE_ENDIAN
     R5xxFIFOWait(pScrn->scrnIndex, 2);
@@ -555,7 +570,7 @@ R5xxXAASetupForScanlineImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int plane
     RHDRegWrite(pScrn, R5XX_DP_GUI_MASTER_CNTL, control);
     RHDRegWrite(pScrn, R5XX_DP_WRITE_MASK, planemask);
 
-    TwoDInfo->trans_color = trans_color;
+    XaaPrivate->trans_color = trans_color;
     if (trans_color != -1)
 	R5xxXAASetTransparency(pScrn, trans_color);
 }
@@ -567,22 +582,19 @@ static void
 R5xxXAASubsequentScanlineImageWriteRect(ScrnInfoPtr pScrn, int x, int y,
 					int w, int h, int skipleft)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
     int shift = 0; /* 32bpp */
 
-    ErrorF("%s(x = %d, y = %d, w = %d, h = %d, skipleft = %d)\n",
-	   __func__, x, y, w, h, skipleft);
-
     if (pScrn->bitsPerPixel == 8)
 	shift = 3;
     else if (pScrn->bitsPerPixel == 16)
 	shift = 1;
 
-    TwoDInfo->scanline_h = h;
-    TwoDInfo->scanline_words  = (w * TwoDInfo->scanline_bpp + 31) >> 5;
+    XaaPrivate->scanline_h = h;
+    XaaPrivate->scanline_words  = (w * XaaPrivate->scanline_bpp + 31) >> 5;
 
     R5xxFIFOWait(pScrn->scrnIndex, 5);
-    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, TwoDInfo->dst_pitch_offset);
+    RHDRegWrite(pScrn, R5XX_DST_PITCH_OFFSET, XaaPrivate->dst_pitch_offset);
     RHDRegWrite(pScrn, R5XX_SC_TOP_LEFT, (y << 16) | ((x + skipleft) & 0xffff));
     RHDRegWrite(pScrn, R5XX_SC_BOTTOM_RIGHT, ((y + h) << 16) | ((x + w) & 0xffff));
     RHDRegWrite(pScrn, R5XX_DST_Y_X, (y << 16) | (x & 0xffff));
@@ -596,7 +608,9 @@ R5xxXAASubsequentScanlineImageWriteRect(ScrnInfoPtr pScrn, int x, int y,
 static void
 R5xxXAAFunctionsInit(ScrnInfoPtr pScrn, ScreenPtr pScreen, XAAInfoRecPtr XAAInfo)
 {
-    struct R5xx2DInfo *TwoDInfo = RHDPTR(pScrn)->TwoDInfo;
+    struct R5xxXaaPrivate *XaaPrivate = RHDPTR(pScrn)->TwoDPrivate;
+
+    RHDFUNC(pScrn);
 
     XAAInfo->Flags = PIXMAP_CACHE | OFFSCREEN_PIXMAPS | LINEAR_FRAMEBUFFER;
 
@@ -637,19 +651,6 @@ R5xxXAAFunctionsInit(ScrnInfoPtr pScrn, ScreenPtr pScreen, XAAInfoRecPtr XAAInfo
     XAAInfo->SubsequentSolidHorVertLine = R5xxXAASubsequentSolidHorVertLine;
     XAAInfo->SubsequentSolidTwoPointLine = R5xxXAASubsequentSolidTwoPointLine;
 
-#if 0 /* Disabled on RV200 and newer because it does not pass XTest */
-    XAAInfo->SetupForDashedLine = R5xxXAASetupForDashedLine;
-    XAAInfo->SubsequentDashedTwoPointLine = R5xxXAASubsequentDashedTwoPointLine;
-    XAAInfo->DashPatternMaxLength = 32;
-    /* ROP3 doesn't seem to work properly for dashedline with GXinvert */
-    XAAInfo->DashedLineFlags = LINE_PATTERN_LSBFIRST_LSBJUSTIFIED |
-	LINE_PATTERN_POWER_OF_2_ONLY | LINE_LIMIT_COORDS | ROP_NEEDS_SOURCE;
-    XAAInfo->DashedLineLimits.x1 = 0;
-    XAAInfo->DashedLineLimits.y1 = 0;
-    XAAInfo->DashedLineLimits.x2 = pScrn->virtualX - 1;
-    XAAInfo->DashedLineLimits.y2 = pScrn->virtualY - 1;
-#endif
-
     /* Screen-to-screen Copy */
     XAAInfo->ScreenToScreenCopyFlags = 0;
     XAAInfo->SetupForScreenToScreenCopy = R5xxXAASetupForScreenToScreenCopy;
@@ -666,6 +667,11 @@ R5xxXAAFunctionsInit(ScrnInfoPtr pScrn, ScreenPtr pScreen, XAAInfoRecPtr XAAInfo
     XAAInfo->SetupForMono8x8PatternFill = R5xxXAASetupForMono8x8PatternFill;
     XAAInfo->SubsequentMono8x8PatternFillRect = R5xxXAASubsequentMono8x8PatternFillRect;
 
+    if (!XaaPrivate->Buffer)
+	XaaPrivate->Buffer = xnfcalloc(1, ((pScrn->virtualX + 31) / 32 * 4) +
+				       (pScrn->virtualX * (pScrn->bitsPerPixel / 8)));
+    XaaPrivate->BufferHook[0] = XaaPrivate->Buffer;
+
     /* Indirect CPU-To-Screen Color Expand
      *
      * R5XX gets upset, when using HOST provided data without a source rop.
@@ -674,7 +680,7 @@ R5xxXAAFunctionsInit(ScrnInfoPtr pScrn, ScreenPtr pScreen, XAAInfoRecPtr XAAInfo
     XAAInfo->ScanlineCPUToScreenColorExpandFillFlags =
 	LEFT_EDGE_CLIPPING | ROP_NEEDS_SOURCE | LEFT_EDGE_CLIPPING_NEGATIVE_X;
     XAAInfo->NumScanlineColorExpandBuffers = 1;
-    XAAInfo->ScanlineColorExpandBuffers = (CARD8 **) &TwoDInfo->Buffer;
+    XAAInfo->ScanlineColorExpandBuffers = XaaPrivate->BufferHook;
     XAAInfo->SetupForScanlineCPUToScreenColorExpandFill = R5xxXAASetupForScanlineCPUToScreenColorExpandFill;
     XAAInfo->SubsequentScanlineCPUToScreenColorExpandFill = R5xxXAASubsequentScanlineCPUToScreenColorExpandFill;
     XAAInfo->SubsequentColorExpandScanline = R5xxXAASubsequentScanline;
@@ -689,7 +695,7 @@ R5xxXAAFunctionsInit(ScrnInfoPtr pScrn, ScreenPtr pScreen, XAAInfoRecPtr XAAInfo
 	ROP_NEEDS_SOURCE |
 	SCANLINE_PAD_DWORD | LEFT_EDGE_CLIPPING | LEFT_EDGE_CLIPPING_NEGATIVE_X;
     XAAInfo->NumScanlineImageWriteBuffers = 1;
-    XAAInfo->ScanlineImageWriteBuffers = (CARD8 **) &TwoDInfo->Buffer;
+    XAAInfo->ScanlineImageWriteBuffers = XaaPrivate->BufferHook;
     XAAInfo->SetupForScanlineImageWrite = R5xxXAASetupForScanlineImageWrite;
     XAAInfo->SubsequentScanlineImageWriteRect = R5xxXAASubsequentScanlineImageWriteRect;
     XAAInfo->SubsequentImageWriteScanline = R5xxXAASubsequentScanline;
@@ -733,22 +739,62 @@ R5xxXAAFBInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
 /*
  *
  */
+static void
+R5xxXaaPrivateInit(ScrnInfoPtr pScrn)
+{
+    RHDPtr rhdPtr = RHDPTR(pScrn);
+    struct R5xxXaaPrivate *XaaPrivate = xnfcalloc(1, sizeof(struct R5xxXaaPrivate));
+
+    XaaPrivate->scrnIndex = pScrn->scrnIndex;
+
+    XaaPrivate->control = (R5xx2DDatatypeGet(pScrn) << R5XX_GMC_DST_DATATYPE_SHIFT) |
+	R5XX_GMC_CLR_CMP_CNTL_DIS | R5XX_GMC_DST_PITCH_OFFSET_CNTL;
+
+    XaaPrivate->dst_pitch_offset =
+	(((pScrn->displayWidth * (pScrn->bitsPerPixel / 8)) / 64) << 22) |
+	((rhdPtr->FbIntAddress + rhdPtr->FbScanoutStart) >> 10);
+
+    rhdPtr->TwoDPrivate = XaaPrivate;
+}
+
+/*
+ *
+ */
+static void
+R5xxXaaPrivateDestroy(ScrnInfoPtr pScrn)
+{
+    RHDPtr rhdPtr = RHDPTR(pScrn);
+    struct R5xxXaaPrivate *XaaPrivate = rhdPtr->TwoDPrivate;
+
+    if (!XaaPrivate)
+	return;
+
+    if (XaaPrivate->Buffer)
+	xfree(XaaPrivate->Buffer);
+
+    xfree(XaaPrivate);
+    rhdPtr->TwoDPrivate = NULL;
+}
+
+/*
+ *
+ */
 Bool
 R5xxXAAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
 {
     RHDPtr rhdPtr = RHDPTR(pScrn);
     XAAInfoRecPtr XAAInfo;
 
-    R5xx2DInit(pScrn);
-
     XAAInfo = XAACreateInfoRec();
     if (!XAAInfo) {
 	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 		   "%s: XAACreateInfoRec failed.\n", __func__);
-	R5xx2DDestroy(pScrn);
 	return FALSE;
     }
 
+    /* need to do this before FunctionsInit */
+    R5xxXaaPrivateInit(pScrn);
+
     R5xxXAAFunctionsInit(pScrn, pScreen, XAAInfo);
 
     R5xxXAAFBInit(pScrn, pScreen);
@@ -757,11 +803,14 @@ R5xxXAAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
 	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "%s: XAAInit failed.\n",
 		   __func__);
 	XAADestroyInfoRec(XAAInfo);
-	R5xx2DDestroy(pScrn);
+	R5xxXaaPrivateDestroy(pScrn);
 	return FALSE;
     }
+
     rhdPtr->XAAInfo = XAAInfo;
 
+    R5xx2DStart(pScrn);
+
     return TRUE;
 }
 
@@ -773,11 +822,10 @@ R5xxXAADestroy(ScrnInfoPtr pScrn)
 {
     RHDPtr rhdPtr = RHDPTR(pScrn);
 
-    if (!rhdPtr->XAAInfo)
-	return;
-
-    XAADestroyInfoRec(rhdPtr->XAAInfo);
-    rhdPtr->XAAInfo = NULL;
+    if (rhdPtr->XAAInfo) {
+	XAADestroyInfoRec(rhdPtr->XAAInfo);
+	rhdPtr->XAAInfo = NULL;
+    }
 
-    R5xx2DDestroy(pScrn);
+    R5xxXaaPrivateDestroy(pScrn);
 }
diff --git a/src/rhd.h b/src/rhd.h
index 1a71eef..976d6d6 100644
--- a/src/rhd.h
+++ b/src/rhd.h
@@ -290,7 +290,7 @@ typedef struct RHDRec {
 #ifdef USE_EXA
     struct _ExaDriver  *EXAInfo;
 #endif
-    void               *TwoDInfo;
+    void               *TwoDPrivate;
 
     /* RandR compatibility layer */
     struct rhdRandr    *randr;
diff --git a/src/rhd_dri.c b/src/rhd_dri.c
index 7c6b583..62aed74 100644
--- a/src/rhd_dri.c
+++ b/src/rhd_dri.c
@@ -814,7 +814,7 @@ static int RHDDRIKernelInit(RHDPtr rhdPtr, ScreenPtr pScreen)
     /* DRM_RADEON_CP_INIT does an engine reset, which resets some engine
      * registers back to their default values, so we need to restore
      * those engine register here. */
-//    RADEONEngineRestore(pScrn);
+//    R5xx2DSetup(pScrn);
 
     return TRUE;
 }
@@ -1501,7 +1501,7 @@ Bool RHDDRIFinishScreenInit(ScreenPtr pScreen)
     if (rhdPtr->ChipSet < RHD_R600 &&
 	(rhdPtr->AccelMethod == RHD_ACCEL_NONE ||
 	 rhdPtr->AccelMethod == RHD_ACCEL_SHADOWFB))
-	R5xx2DInit(pScrn);
+	R5xx2DStart(pScrn);
 
     return TRUE;
 }
@@ -1543,7 +1543,7 @@ void RHDDRIEnterVT(ScreenPtr pScreen)
     if (rhdPtr->ChipSet < RHD_R600 &&
 	(rhdPtr->AccelMethod == RHD_ACCEL_NONE ||
 	 rhdPtr->AccelMethod == RHD_ACCEL_SHADOWFB))
-	R5xx2DInit(pScrn);
+	R5xx2DStart(pScrn);
 
     DRIUnlock(pScrn->pScreen);
 }
diff --git a/src/rhd_driver.c b/src/rhd_driver.c
index 2e06be8..7bcef2e 100644
--- a/src/rhd_driver.c
+++ b/src/rhd_driver.c
@@ -1036,7 +1036,7 @@ RHDScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 #ifdef USE_EXA
     else if (rhdPtr->AccelMethod == RHD_ACCEL_EXA) {
  	if (rhdPtr->ChipSet < RHD_R600)
- 	    R5xxEXAInit(pScrn, pScreen);
+	    R5xxEXAInit(pScrn, pScreen);
     }
 #endif /* USE_EXA */
 
@@ -1117,7 +1117,7 @@ RHDAllIdle(ScrnInfoPtr pScrn)
     }
 
     /* TODO: Invalidate the cached acceleration registers */
-    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDInfo)
+    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDPrivate)
 	R5xx2DIdle(pScrn);
 
     if (!RHDMCIdle(rhdPtr, 1000))
@@ -1159,8 +1159,6 @@ RHDCloseScreen(int scrnIndex, ScreenPtr pScreen)
 		R5xxXAADestroy(pScrn);
 	}
 
-    /* nothing for XAA: handled in FreeRec */
-
     rhdUnmapFB(rhdPtr);
     rhdUnmapMMIO(rhdPtr);
 
@@ -1187,7 +1185,7 @@ RHDEnterVT(int scrnIndex, int flags)
 
     rhdSave(rhdPtr);
 
-    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDInfo)
+    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDPrivate)
 	R5xx2DIdle(pScrn);
 
     if (rhdPtr->randr)
@@ -1202,7 +1200,7 @@ RHDEnterVT(int scrnIndex, int flags)
     /* rhdShowCursor() done by AdjustFrame */
     RHDAdjustFrame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 
-    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDInfo)
+    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDPrivate)
 	R5xx2DSetup(pScrn);
 
 #ifdef USE_DRI
@@ -1240,7 +1238,7 @@ RHDSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 
     RHDFUNC(rhdPtr);
 
-    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDInfo)
+    if ((rhdPtr->ChipSet < RHD_R600) && rhdPtr->TwoDPrivate)
 	R5xx2DIdle(pScrn);
 
     if (rhdPtr->randr)