Bug #1891: XAA support for Sun FFB. (Dave S. Miller)XORG-6_8_99_3XORG-6_8_99_2XORG-6_8_99_1

7 files changed, 1063 insertions, 1036 deletions

diff --git a/src/ffb.h b/src/ffb.h
index af54db2..1be10dc 100644
--- a/src/ffb.h
+++ b/src/ffb.h
@@ -24,7 +24,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb.h,v 1.8 2002/12/06 02:44:03 tsi Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb.h,v 1.7tsi Exp $ */
 
 #ifndef FFB_H
 #define FFB_H
@@ -33,6 +33,7 @@
 #include "xf86_OSproc.h"
 #include "xf86_ansic.h"
 #include "xf86RamDac.h"
+#include "xaa.h"
 #include "Xmd.h"
 #include "gcstruct.h"
 #include "windowstr.h"
@@ -188,6 +189,19 @@ typedef struct {
 	unsigned char has_z_buffer;
 	unsigned char has_double_buffer;
 
+	/* XAA related info */
+	XAAInfoRecPtr pXAAInfo;
+	unsigned int xaa_fbc;
+	unsigned int xaa_wid;
+	unsigned int xaa_planemask;
+	unsigned int xaa_linepat;
+	int xaa_xdir, xaa_ydir, xaa_rop;
+	unsigned char *xaa_scanline_buffers[2];
+	int xaa_scanline_x, xaa_scanline_y, xaa_scanline_w;
+	unsigned char *xaa_tex;
+	int xaa_tex_pitch, xaa_tex_width, xaa_tex_height;
+	unsigned int xaa_tex_color;
+
 	enum ffb_resolution ffb_res;
 	BoxRec ClippedBoxBuf[64];
 	xRectangle Pf_Fixups[4];
diff --git a/src/ffb_accel.c b/src/ffb_accel.c
index 80c2d5c..9d20e08 100644
--- a/src/ffb_accel.c
+++ b/src/ffb_accel.c
@@ -24,28 +24,15 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_accel.c,v 1.6 2003/06/23 17:35:48 eich Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_accel.c,v 1.6tsi Exp $ */
 
 #include	"scrnintstr.h"
 #include	"pixmapstr.h"
 #include	"regionstr.h"
 #include	"mistruct.h"
-#include	"fontstruct.h"
-#include	"dixfontstr.h"
-#define PSZ 8
-#include	"cfb.h"
-#undef PSZ
-#include	"cfb32.h"
-#include	"mibstore.h"
-#include	"mifillarc.h"
-#include	"miwideline.h"
 #include	"miline.h"
-#include	"fastblt.h"
-#include	"mergerop.h"
-#include	"migc.h"
-#include	"mi.h"
-
-#include	"cfb8_32wid.h"
+#include	"fb.h"
+#include	"xaa.h"
 
 #include	"ffb.h"
 #include	"ffb_fifo.h"
@@ -69,635 +56,6 @@ struct fastfill_parms ffb_fastfill_parms[] = {
 /*XXX*/	{  0x00c0, 0x0a00, 0x04, 0x08, 0x08, 0x50 },	/* Portrait: 1280 x 2048 XXX */
 };
 
-static Bool
-CreatorCreateWindow (WindowPtr pWin)
-{
-	ScreenPtr pScreen = pWin->drawable.pScreen;
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
-	CreatorPrivWinPtr pFfbPrivWin;
-	unsigned int fbc;
-	int depth = (pWin->drawable.depth == 8) ? 8 : 24;
-	int i, visual, visclass;
-
-	if (depth == 8) {
-		if (!cfbCreateWindow (pWin))
-			return FALSE;
-	} else {
-		if (!cfb32CreateWindow (pWin))
-			return FALSE;
-	}
-
-	pFfbPrivWin = xalloc(sizeof(CreatorPrivWinRec));
-	if (!pFfbPrivWin)
-		return FALSE;
-
-	fbc  = FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A;
-	fbc |= FFB_FBC_WE_FORCEON;
-	fbc |= FFB_FBC_SB_BOTH;
-	fbc |= FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF;
-	if (depth == 8)
-		fbc |= (FFB_FBC_RE_MASK | FFB_FBC_GE_OFF | FFB_FBC_BE_OFF);
-	else
-		fbc |= FFB_FBC_RGBE_MASK;
-	fbc |= FFB_FBC_XE_ON;
-	pFfbPrivWin->fbc_base = fbc;
-
-	visual = wVisual(pWin);
-	visclass = 0;
-	for (i = 0; i < pScreen->numVisuals; i++) {
-		if (pScreen->visuals[i].vid == visual) {
-			visclass = pScreen->visuals[i].class;
-			break;
-		}
-	}
-
-	pFfbPrivWin->wid = FFBWidAlloc(pFfb, visclass, wColormap(pWin), TRUE);
-	if (pFfbPrivWin->wid == (unsigned int) -1) {
-		xfree(pFfbPrivWin);
-		return FALSE;
-	}
-	FFBLOG(("CreatorCreateWindow: pWin %p depth %d wid %x fbc_base %x\n",
-		pWin, depth, pFfbPrivWin->wid, pFfbPrivWin->fbc_base));
-
-	pFfbPrivWin->Stipple = NULL;
-	CreatorSetWindowPrivate(pWin, pFfbPrivWin);
-
-	return TRUE;
-}
-
-static Bool
-CreatorDestroyWindow (WindowPtr pWin)
-{
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen);
-	CreatorPrivWinPtr pFfbPrivWin;
-	int depth = (pWin->drawable.depth == 8) ? 8 : 24;
-
-	FFBLOG(("CreatorDestroyWindow: pWin %p depth %d\n", pWin, depth));
-	pFfbPrivWin = CreatorGetWindowPrivate(pWin);
-	if (pFfbPrivWin->Stipple)
-		xfree(pFfbPrivWin->Stipple);
-	FFBWidFree(pFfb, pFfbPrivWin->wid);
-	xfree(pFfbPrivWin);
-
-	if (depth == 8)
-		return cfbDestroyWindow (pWin);
-	else
-		return cfb32DestroyWindow (pWin);
-}
-
-extern CreatorStipplePtr FFB_tmpStipple;
-
-static int
-CreatorChangeWindowAttributes (WindowPtr pWin, unsigned long mask)
-{
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen);
-	CreatorPrivWinPtr pFfbPrivWin;
-	CreatorStipplePtr stipple;
-	Mask index;
-	WindowPtr pBgWin;
-	register cfbPrivWin *pPrivWin;
-	int width, depth;
-
-	FFBLOG(("CreatorChangeWindowAttributes: WIN(%p) mask(%08x)\n", pWin, mask));
-	pPrivWin = (cfbPrivWin *)(pWin->devPrivates[cfbWindowPrivateIndex].ptr);
-	pFfbPrivWin = CreatorGetWindowPrivate(pWin);
-	depth = pWin->drawable.depth;
-
-	/*
-	 * When background state changes from ParentRelative and
-	 * we had previously rotated the fast border pixmap to match
-	 * the parent relative origin, rerotate to match window
-	 */
-	if (mask & (CWBackPixmap | CWBackPixel) &&
-	    pWin->backgroundState != ParentRelative &&
-	    pPrivWin->fastBorder &&
-	    (pPrivWin->oldRotate.x != pWin->drawable.x ||
-	     pPrivWin->oldRotate.y != pWin->drawable.y)) {
-		if (depth == 8) {
-			cfbXRotatePixmap(pPrivWin->pRotatedBorder,
-					 pWin->drawable.x - pPrivWin->oldRotate.x);
-			cfbYRotatePixmap(pPrivWin->pRotatedBorder,
-					 pWin->drawable.y - pPrivWin->oldRotate.y);
-		} else {
-			cfb32XRotatePixmap(pPrivWin->pRotatedBorder,
-					   pWin->drawable.x - pPrivWin->oldRotate.x);
-			cfb32YRotatePixmap(pPrivWin->pRotatedBorder,
-					   pWin->drawable.y - pPrivWin->oldRotate.y);
-		}
-		pPrivWin->oldRotate.x = pWin->drawable.x;
-		pPrivWin->oldRotate.y = pWin->drawable.y;
-	}
-	while (mask) {
-		index = lowbit(mask);
-		mask &= ~index;
-		switch (index) {
-		case CWBackPixmap:
-			stipple = pFfbPrivWin->Stipple;
-			if (pWin->backgroundState == None ||
-			    pWin->backgroundState == ParentRelative) {
-				pPrivWin->fastBackground = FALSE;
-				if (stipple) {
-					xfree (stipple);
-					pFfbPrivWin->Stipple = NULL;
-				}
-				/* Rotate border to match parent origin */
-				if (pWin->backgroundState == ParentRelative &&
-				    pPrivWin->pRotatedBorder)  {
-					for (pBgWin = pWin->parent;
-					     pBgWin->backgroundState == ParentRelative;
-					     pBgWin = pBgWin->parent);
-					if (depth == 8) {
-						cfbXRotatePixmap(pPrivWin->pRotatedBorder,
-								 pBgWin->drawable.x - pPrivWin->oldRotate.x);
-						cfbYRotatePixmap(pPrivWin->pRotatedBorder,
-								 pBgWin->drawable.y - pPrivWin->oldRotate.y);
-					} else {
-						cfb32XRotatePixmap(pPrivWin->pRotatedBorder,
-								   pBgWin->drawable.x - pPrivWin->oldRotate.x);
-						cfb32YRotatePixmap(pPrivWin->pRotatedBorder,
-								   pBgWin->drawable.y - pPrivWin->oldRotate.y);
-					}
-					pPrivWin->oldRotate.x = pBgWin->drawable.x;
-					pPrivWin->oldRotate.y = pBgWin->drawable.y;
-				}
-				break;
-			}
-			if (!stipple) {
-				if (!FFB_tmpStipple)
-					FFB_tmpStipple = (CreatorStipplePtr)
-						xalloc (sizeof *FFB_tmpStipple);
-				stipple = FFB_tmpStipple;
-			}
-			if (stipple) {
-				int ph = FFB_FFPARMS(pFfb).pagefill_height;
-
-				if (CreatorCheckTile (pWin->background.pixmap, stipple,
-						      ((DrawablePtr)pWin)->x & 31,
-						      ((DrawablePtr)pWin)->y & 31, ph)) {
-					stipple->alu = GXcopy;
-					pPrivWin->fastBackground = FALSE;
-					if (stipple == FFB_tmpStipple) {
-						pFfbPrivWin->Stipple = stipple;
-						FFB_tmpStipple = 0;
-					}
-					break;
-				}
-			}
-			if ((stipple = pFfbPrivWin->Stipple) != NULL) {
-				xfree (stipple);
-				pFfbPrivWin->Stipple = NULL;
-			}
-			if (((width = (pWin->background.pixmap->drawable.width *
-				       pWin->background.pixmap->drawable.bitsPerPixel)) <= 32) &&
-			    !(width & (width - 1))) {
-				if (depth == 8) {
-					cfbCopyRotatePixmap(pWin->background.pixmap,
-							    &pPrivWin->pRotatedBackground,
-							    pWin->drawable.x,
-							    pWin->drawable.y);
-				} else {
-					cfb32CopyRotatePixmap(pWin->background.pixmap,
-							      &pPrivWin->pRotatedBackground,
-							      pWin->drawable.x,
-							      pWin->drawable.y);
-				}
-				if (pPrivWin->pRotatedBackground) {
-					pPrivWin->fastBackground = TRUE;
-					pPrivWin->oldRotate.x = pWin->drawable.x;
-					pPrivWin->oldRotate.y = pWin->drawable.y;
-				} else
-					pPrivWin->fastBackground = FALSE;
-				break;
-			}
-			pPrivWin->fastBackground = FALSE;
-			break;
-
-		case CWBackPixel:
-			pPrivWin->fastBackground = FALSE;
-			break;
-
-		case CWBorderPixmap:
-			/* don't bother with accelerator for border tiles (just lazy) */
-			if (((width = (pWin->border.pixmap->drawable.width *
-				       pWin->border.pixmap->drawable.bitsPerPixel)) <= 32) &&
-			    !(width & (width - 1))) {
-				for (pBgWin = pWin;
-				     pBgWin->backgroundState == ParentRelative;
-				     pBgWin = pBgWin->parent)
-					;
-				if (depth == 8) {
-					cfbCopyRotatePixmap(pWin->border.pixmap,
-							    &pPrivWin->pRotatedBorder,
-							    pBgWin->drawable.x,
-							    pBgWin->drawable.y);
-				} else {
-					cfb32CopyRotatePixmap(pWin->border.pixmap,
-							      &pPrivWin->pRotatedBorder,
-							      pBgWin->drawable.x,
-							      pBgWin->drawable.y);
-				}
-				if (pPrivWin->pRotatedBorder) {
-					pPrivWin->fastBorder = TRUE;
-					pPrivWin->oldRotate.x = pBgWin->drawable.x;
-					pPrivWin->oldRotate.y = pBgWin->drawable.y;
-				} else
-					pPrivWin->fastBorder = FALSE;
-			} else
-				pPrivWin->fastBorder = FALSE;
-			break;
-			
-		case CWBorderPixel:
-			pPrivWin->fastBorder = FALSE;
-			break;
-		}
-	}
-	return (TRUE);
-}
-
-static void
-CreatorPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
-{
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN (pWin->drawable.pScreen);
-	ffb_fbcPtr ffb = pFfb->regs;
-	register cfbPrivWin *pPrivWin;
-	CreatorPrivWinPtr pFfbPrivWin;
-	CreatorStipplePtr stipple;
-	WindowPtr pBgWin;
-	int depth = pWin->drawable.depth;
-
-	if (pFfb->vtSema)
-		return;
-
-	FFBLOG(("CreatorPaintWindow: WIN(%p) what(%d)\n", pWin, what));
-	pPrivWin = cfbGetWindowPrivate(pWin);
-	pFfbPrivWin = CreatorGetWindowPrivate(pWin);
-	switch (what) {
-	case PW_BACKGROUND:
-		stipple = pFfbPrivWin->Stipple;
-		switch (pWin->backgroundState) {
-		case None:
-			return;
-		case ParentRelative:
-			do {
-				pWin = pWin->parent;
-			} while (pWin->backgroundState == ParentRelative);
-			(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, what);
-			return;
-		case BackgroundPixmap:
-			if (stipple) {
-				CreatorFillBoxStipple ((DrawablePtr)pWin, 
-						       (int)REGION_NUM_RECTS(pRegion),
-						       REGION_RECTS(pRegion),
-						       stipple);
-				return;
-			}
-			FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
-			FFBWait(pFfb, ffb);
-			if (pPrivWin->fastBackground) {
-				if (depth == 8) {
-					cfbFillBoxTile32 ((DrawablePtr)pWin,
-							  (int)REGION_NUM_RECTS(pRegion),
-							  REGION_RECTS(pRegion),
-							  pPrivWin->pRotatedBackground);
-				} else {
-					cfb32FillBoxTile32 ((DrawablePtr)pWin,
-							    (int)REGION_NUM_RECTS(pRegion),
-							    REGION_RECTS(pRegion),
-							    pPrivWin->pRotatedBackground);
-				}
-			} else {
-				if (depth == 8) {
-					cfbFillBoxTileOdd ((DrawablePtr)pWin,
-							   (int)REGION_NUM_RECTS(pRegion),
-							   REGION_RECTS(pRegion),
-							   pWin->background.pixmap,
-							   (int) pWin->drawable.x,
-							   (int) pWin->drawable.y);
-				} else {
-					cfb32FillBoxTileOdd ((DrawablePtr)pWin,
-							     (int)REGION_NUM_RECTS(pRegion),
-							     REGION_RECTS(pRegion),
-							     pWin->background.pixmap,
-							     (int) pWin->drawable.x,
-							     (int) pWin->drawable.y);
-				}
-			}
-			return;
-		case BackgroundPixel:
-			CreatorFillBoxSolid ((DrawablePtr)pWin,
-					     (int)REGION_NUM_RECTS(pRegion),
-					     REGION_RECTS(pRegion),
-					     pWin->background.pixel);
-			return;
-		}
-		break;
-	case PW_BORDER:
-		if (pWin->borderIsPixel) {
-			CreatorFillBoxSolid ((DrawablePtr)pWin,
-					     (int)REGION_NUM_RECTS(pRegion),
-					     REGION_RECTS(pRegion),
-					     pWin->border.pixel);
-			return;
-		}
-		FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
-		FFBWait(pFfb, ffb);
-		if (pPrivWin->fastBorder) {
-			if (depth == 8) {
-				cfbFillBoxTile32 ((DrawablePtr)pWin,
-						  (int)REGION_NUM_RECTS(pRegion),
-						  REGION_RECTS(pRegion),
-						  pPrivWin->pRotatedBorder);
-			} else {
-				cfb32FillBoxTile32 ((DrawablePtr)pWin,
-						    (int)REGION_NUM_RECTS(pRegion),
-						    REGION_RECTS(pRegion),
-						    pPrivWin->pRotatedBorder);
-			}
-		} else {
-			for (pBgWin = pWin;
-			     pBgWin->backgroundState == ParentRelative;
-			     pBgWin = pBgWin->parent)
-				;
-
-			if (depth == 8) {
-				cfbFillBoxTileOdd ((DrawablePtr)pWin,
-						   (int)REGION_NUM_RECTS(pRegion),
-						   REGION_RECTS(pRegion),
-						   pWin->border.pixmap,
-						   (int) pBgWin->drawable.x,
-						   (int) pBgWin->drawable.y);
-			} else {
-				cfb32FillBoxTileOdd ((DrawablePtr)pWin,
-						     (int)REGION_NUM_RECTS(pRegion),
-						     REGION_RECTS(pRegion),
-						     pWin->border.pixmap,
-						     (int) pBgWin->drawable.x,
-						     (int) pBgWin->drawable.y);
-			}
-		}
-		return;
-	}
-}
-
-static void 
-CreatorCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
-	ScreenPtr pScreen = pWin->drawable.pScreen;
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
-	DDXPointPtr pptSrc;
-	DDXPointPtr ppt;
-	RegionRec rgnDst;
-	BoxPtr pbox;
-	int dx, dy;
-	int i, nbox;
-	WindowPtr pwinRoot;
-
-	if (pFfb->vtSema)
-		return;
-
-	FFBLOG(("CreatorCopyWindow: WIN(%p)\n", pWin));
-
-	REGION_INIT(pScreen, &rgnDst, NullBox, 0);
-
-	dx = ptOldOrg.x - pWin->drawable.x;
-	dy = ptOldOrg.y - pWin->drawable.y;
-	REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
-	REGION_INTERSECT(pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
-
-	pbox = REGION_RECTS(&rgnDst);
-	nbox = REGION_NUM_RECTS(&rgnDst);
-	if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
-		return;
-
-	ppt = pptSrc;
-	for (i = nbox; --i >= 0; ppt++, pbox++) {
-		ppt->x = pbox->x1 + dx;
-		ppt->y = pbox->y1 + dy;
-	}
-
-	/* XXX Optimize this later to only gcopy/vcopy the 8bpp+WID plane
-	 * XXX when possible.  -DaveM
-	 */
-
-	pwinRoot = WindowTable[pScreen->myNum];
-
-	if (!pFfb->disable_vscroll && (!dx && dy)) {
-		FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
-
-		FFB_ATTR_VSCROLL_WINCOPY(pFfb);
-		CreatorDoVertBitblt ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
-				     GXcopy, &rgnDst, pptSrc, ~0L);
-	} else {
-		FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
-		ffb_fbcPtr ffb = pFfb->regs;
-
-		FFB_ATTR_SFB_VAR_WINCOPY(pFfb);
-		FFBWait(pFfb, ffb);
-		CreatorDoBitblt ((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
-				 GXcopy, &rgnDst, pptSrc, ~0L);
-	}
-	DEALLOCATE_LOCAL(pptSrc);
-	REGION_UNINIT(pScreen, &rgnDst);
-}
-
-static void
-CreatorSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg, WindowPtr pWin)
-{
-	ScreenPtr pScreen = pPixmap->drawable.pScreen;
-	FFBPtr pFfb = GET_FFB_FROM_SCREEN(pScreen);
-	cfb8_32WidScreenPtr pScreenPriv =
-		CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
-	ffb_fbcPtr ffb = pFfb->regs;
-	register DDXPointPtr pPt;
-	DDXPointPtr pPtsInit;
-	register BoxPtr pBox;
-	register int i;
-	PixmapPtr pScrPix;
-
-	if (pFfb->vtSema)
-		return;
-
-	FFBLOG(("CreatorSaveAreas: WIN(%p)\n", pWin));
-	i = REGION_NUM_RECTS(prgnSave);
-	pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
-	if (!pPtsInit)
-		return;
-    
-	pBox = REGION_RECTS(prgnSave);
-	pPt = pPtsInit;
-	while (--i >= 0) {
-		pPt->x = pBox->x1 + xorg;
-		pPt->y = pBox->y1 + yorg;
-		pPt++;
-		pBox++;
-	}
-
-	if (pWin->drawable.bitsPerPixel == 8)
-		pScrPix = (PixmapPtr) pScreenPriv->pix8;
-	else
-		pScrPix = (PixmapPtr) pScreenPriv->pix32;
-
-	/* SRC is the framebuffer, DST is a pixmap.  The SFB_VAR attributes may
-	 * seem silly, but they are needed even in this case to handle
-	 * double-buffered windows properly.
-	 */
-	FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
-	FFBWait(pFfb, ffb);
-	CreatorDoBitblt((DrawablePtr) pScrPix, (DrawablePtr)pPixmap,
-			GXcopy, prgnSave, pPtsInit, ~0L);
-
-	DEALLOCATE_LOCAL (pPtsInit);
-}
-
-static void
-CreatorRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg, int yorg, WindowPtr pWin)
-{
-	FFBPtr pFfb;
-	ffb_fbcPtr ffb;
-	register DDXPointPtr pPt;
-	DDXPointPtr pPtsInit;
-	register BoxPtr pBox;
-	register int i;
-	ScreenPtr pScreen = pPixmap->drawable.pScreen;
-	cfb8_32WidScreenPtr pScreenPriv =
-		CFB8_32WID_GET_SCREEN_PRIVATE(pScreen);
-	PixmapPtr pScrPix;
-
-	pFfb = GET_FFB_FROM_SCREEN(pScreen);
-	if (pFfb->vtSema)
-		return;
-
-	FFBLOG(("CreatorRestoreAreas: WIN(%p)\n", pWin));
-	i = REGION_NUM_RECTS(prgnRestore);
-	pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i*sizeof(DDXPointRec));
-	if (!pPtsInit)
-		return;
-    
-	pBox = REGION_RECTS(prgnRestore);
-	pPt = pPtsInit;
-	while (--i >= 0) {
-		pPt->x = pBox->x1 - xorg;
-		pPt->y = pBox->y1 - yorg;
-		pPt++;
-		pBox++;
-	}
-
-	if (pWin->drawable.bitsPerPixel == 8)
-		pScrPix = (PixmapPtr) pScreenPriv->pix8;
-	else
-		pScrPix = (PixmapPtr) pScreenPriv->pix32;
-
-	pFfb = GET_FFB_FROM_SCREEN(pScreen);
-	ffb = pFfb->regs;
-
-	/* SRC is a pixmap, DST is the framebuffer */
-	FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
-	FFBWait(pFfb, ffb);
-	CreatorDoBitblt((DrawablePtr)pPixmap, (DrawablePtr) pScrPix,
-			GXcopy, prgnRestore, pPtsInit, ~0L);
-
-	DEALLOCATE_LOCAL (pPtsInit);
-}
-
-static void
-CreatorGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h, unsigned int format, unsigned long planeMask, char* pdstLine)
-{
-	BoxRec box;
-	DDXPointRec ptSrc;
-	RegionRec rgnDst;
-	ScreenPtr pScreen;
-	PixmapPtr pPixmap;
-
-	FFBLOG(("CreatorGetImage: s[%08x:%08x] wh[%08x:%08x]\n", sx, sy, w, h));
-	if ((w == 0) || (h == 0))
-		return;
-	if (pDrawable->bitsPerPixel == 1) {
-		mfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
-		return;
-	}
-	pScreen = pDrawable->pScreen;
-	/*
-	 * XFree86 DDX empties the root borderClip when the VT is
-	 * switched away; this checks for that case
-	 */
-	if (!cfbDrawableEnabled (pDrawable))
-		return;
-	if(format == ZPixmap) {
-		FFBPtr pFfb = GET_FFB_FROM_SCREEN (pScreen);
-		ffb_fbcPtr ffb = pFfb->regs;
-
-		/* We have to have the full planemask. */
-		if (pDrawable->type == DRAWABLE_WINDOW) {
-			WindowPtr pWin = (WindowPtr) pDrawable;
-
-			FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, pWin);
-			FFBWait(pFfb, ffb);
-		}
-
-		if (pDrawable->bitsPerPixel == 8) {
-			if((planeMask & 0x000000ff) != 0x000000ff) {
-				cfbGetImage(pDrawable, sx, sy, w, h,
-					    format, planeMask, pdstLine);
-				return;
-			}
-		} else {
-			if((planeMask & 0x00ffffff) != 0x00ffffff) {
-				cfb32GetImage(pDrawable, sx, sy, w, h,
-					      format, planeMask, pdstLine);
-				return;
-			}
-		}
-
-		/* SRC is the framebuffer, DST is a pixmap */
-		if (pDrawable->type == DRAWABLE_WINDOW && w == 1 && h == 1) {
-			/* Benchmarks do this make sure the acceleration hardware
-			 * has completed all of it's operations, therefore I feel
-			 * it is not cheating to special case this because if
-			 * anything it gives the benchmarks more accurate results.
-			 */
-			if (pDrawable->bitsPerPixel == 32) {
-				unsigned char *sfb = (unsigned char *)pFfb->sfb32;
-				unsigned int *dstPixel = (unsigned int *)pdstLine;
-				unsigned int tmp;
-
-				tmp = *((unsigned int *)(sfb +
-							 ((sy + pDrawable->y) << 13) +
-							 ((sx + pDrawable->x) << 2)));
-				*dstPixel = (tmp & 0x00ffffff);
-			} else {
-				unsigned char *sfb = (unsigned char *)pFfb->sfb8r;
-				unsigned char *dstPixel = (unsigned char *)pdstLine;
-
-				*dstPixel = *((unsigned char *)(sfb +
-								((sy + pDrawable->y) << 11) +
-								((sx + pDrawable->x) << 0)));
-			}
-			return;
-		}
-		pPixmap = GetScratchPixmapHeader(pScreen, w, h, 
-						 pDrawable->depth, pDrawable->bitsPerPixel,
-						 PixmapBytePad(w,pDrawable->depth), (pointer)pdstLine);
-		if (!pPixmap)
-			return;
-		ptSrc.x = sx + pDrawable->x;
-		ptSrc.y = sy + pDrawable->y;
-		box.x1 = 0;
-		box.y1 = 0;
-		box.x2 = w;
-		box.y2 = h;
-		REGION_INIT(pScreen, &rgnDst, &box, 1);
-		CreatorDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
-				&ptSrc, planeMask);
-		REGION_UNINIT(pScreen, &rgnDst);
-		FreeScratchPixmapHeader(pPixmap);
-	} else
-		miGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
-}
-
-extern void
-CreatorGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
-		int *pwidth, int nspans, char *pchardstStart);
-
 void
 CreatorVtChange (ScreenPtr pScreen, int enter)
 {
@@ -705,7 +63,7 @@ CreatorVtChange (ScreenPtr pScreen, int enter)
 	ffb_fbcPtr ffb = pFfb->regs;
 
 	pFfb->rp_active = 1;
-	FFBWait(pFfb, ffb);	
+	FFBWait(pFfb, ffb);     
 	pFfb->fifo_cache = -1;
 	pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
 			   FFB_FBC_RB_A | FFB_FBC_SB_BOTH| FFB_FBC_XE_OFF |
@@ -743,8 +101,8 @@ CreatorVtChange (ScreenPtr pScreen, int enter)
 			   FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON);
 	pFfb->ppc_cache &= ~FFB_PPC_XS_MASK;
 	pFfb->ppc_cache |= FFB_PPC_XS_WID;
-	pFfb->wid_cache = 0xff;
-	FFBFifo(pFfb, 8);
+	pFfb->wid_cache = (enter ? pFfb->xaa_wid : 0xff);
+	FFBFifo(pFfb, 11);
 	ffb->fbc = pFfb->fbc_cache;
 	ffb->ppc = FFB_PPC_XS_WID;
 	ffb->wid = pFfb->wid_cache;
@@ -753,7 +111,718 @@ CreatorVtChange (ScreenPtr pScreen, int enter)
 	ffb->cmp = 0x80808080;
 	ffb->matchab = 0x80808080;
 	ffb->magnab = 0x80808080;
+	ffb->blendc = (FFB_BLENDC_FORCE_ONE |
+		       FFB_BLENDC_DF_ONE_M_A |
+		       FFB_BLENDC_SF_A);
+	ffb->blendc1 = 0;
+	ffb->blendc2 = 0;
+	pFfb->rp_active = 1;
 	FFBWait(pFfb, ffb);
+
+	if (enter) {
+		pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
+		
+		FFBFifo(pFfb, 5);
+		ffb->drawop = pFfb->drawop_cache;
+		FFB_WRITE64(&ffb->by, 0, 0);
+		FFB_WRITE64_2(&ffb->bh, pFfb->psdp->height, pFfb->psdp->width);
+		pFfb->rp_active = 1;
+		FFBWait(pFfb, ffb);
+
+		SET_SYNC_FLAG(pFfb->pXAAInfo);
+	}
+}
+
+#ifdef DEBUG_FFB
+FILE *FDEBUG_FD = NULL;
+#endif
+
+#define FFB_ATTR_SFB_VAR_XAA(__fpriv, __pmask, __alu) \
+do {   unsigned int __ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
+       unsigned int __ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
+       unsigned int __rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
+       unsigned int __fbc = (__fpriv)->xaa_fbc; \
+       unsigned int __wid = (__fpriv)->xaa_wid; \
+       if (((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+           (__fpriv)->fbc_cache != __fbc || \
+           (__fpriv)->wid_cache != __wid || \
+           (__fpriv)->rop_cache != __rop || \
+           (__fpriv)->pmask_cache != (__pmask)) \
+               __FFB_Attr_SFB_VAR(__fpriv, __ppc, __ppc_mask, __fbc, \
+                                  __wid, __rop, (__pmask)); \
+} while(0)
+
+#define FFB_ATTR_VSCROLL_XAA(__fpriv, __pmask) \
+do {   unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+       unsigned int __fbc = (__fpriv)->xaa_fbc; \
+       if ((__fpriv)->fbc_cache != __fbc || \
+           (__fpriv)->rop_cache != __rop || \
+           (__fpriv)->pmask_cache != (__pmask) || \
+           (__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
+               ffb_fbcPtr __ffb = (__fpriv)->regs; \
+               (__fpriv)->fbc_cache = __fbc; \
+               (__fpriv)->rop_cache = __rop; \
+               (__fpriv)->pmask_cache = (__pmask); \
+               (__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
+               (__fpriv)->rp_active = 1; \
+               FFBFifo(__fpriv, 4); \
+               (__ffb)->fbc = __fbc; \
+               (__ffb)->rop = __rop; \
+               (__ffb)->pmask = (__pmask); \
+               (__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
+       } \
+} while(0)
+
+static CARD32 FFBAlphaTextureFormats[2] = { PICT_a8, 0 };
+static CARD32 FFBTextureFormats[2] = { PICT_a8b8g8r8, 0 };
+
+static void FFB_SetupTextureAttrs(FFBPtr pFfb)
+{
+       ffb_fbcPtr ffb = pFfb->regs;
+       unsigned int ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_VAR;
+       unsigned int ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+       unsigned int rop = FFB_ROP_NEW | (FFB_ROP_NEW << 8);
+       unsigned int fbc = pFfb->xaa_fbc;
+       unsigned int wid = pFfb->xaa_wid;
+
+       ppc |= FFB_PPC_ABE_ENABLE;
+       ppc_mask |= FFB_PPC_ABE_MASK;
+
+       if ((pFfb->ppc_cache & ppc_mask) != ppc ||
+           pFfb->fbc_cache != fbc ||
+           pFfb->wid_cache != wid ||
+           pFfb->rop_cache != rop ||
+           pFfb->pmask_cache != 0xffffffff)
+               __FFB_Attr_SFB_VAR(pFfb, ppc, ppc_mask, fbc,
+                                  wid, rop, 0xffffffff);
+       FFBWait(pFfb, ffb);
+}
+
+static Bool FFB_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)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+
+       FFBLOG(("FFB_SetupForCPUToScreenAlphaTexture: "
+               "argb[%04x:%04x:%04x:%04x] alpha[T(%x):P(%d)] "
+               "wh[%d:%d] flgs[%x]\n",
+               alpha, red, green, blue,
+               alphaType, alphaPitch,
+               width, height, flags));
+
+       FFB_SetupTextureAttrs(pFfb);
+
+       pFfb->xaa_tex = (unsigned char *) alphaPtr;
+       pFfb->xaa_tex_pitch = alphaPitch;
+       pFfb->xaa_tex_width = width;
+       pFfb->xaa_tex_height = height;
+       pFfb->xaa_tex_color = (/*((alpha >> 8) << 24) |*/
+                              ((blue >> 8) << 16) |
+                              ((green >> 8) << 8) |
+                              ((red >> 8) << 0));
+       return TRUE;
+}
+
+static void FFB_SubsequentCPUToScreenAlphaTexture(ScrnInfoPtr pScrn,
+                                                 int dstx, int dsty,
+                                                 int srcx, int srcy,
+                                                 int width, int height)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       unsigned char *dst_base, *alpha_base, *sfb32;
+       unsigned int pixel_base;
+       int psz_shift = 2;
+
+       FFBLOG(("FFB_SubsequentCPUToScreenAlphaTexture: "
+               "dst[%d:%d] src[%d:%d] wh[%d:%d]\n",
+               dstx, dsty, srcx, srcy, width, height));
+
+       sfb32 = (unsigned char *) pFfb->sfb32;
+       dst_base = sfb32 + (dsty * (2048 << psz_shift)) + (dstx << psz_shift);
+       alpha_base = pFfb->xaa_tex;
+       alpha_base += srcx;
+       if (srcy)
+               alpha_base += (srcy * pFfb->xaa_tex_pitch);
+       pixel_base = pFfb->xaa_tex_color;
+       while (height--) {
+               unsigned int *dst = (unsigned int *) dst_base;
+               unsigned char *alpha = alpha_base;
+               int w = width;
+
+               while (w--) {
+                       (*dst) = (((unsigned int)*alpha << 24) | pixel_base);
+                       dst++;
+                       alpha++;
+	       }
+	       dst_base += (2048 << psz_shift);
+	       alpha_base += pFfb->xaa_tex_pitch;
+       }
+}
+
+
+static Bool FFB_SetupForCPUToScreenTexture(ScrnInfoPtr pScrn, int op,
+                                          int texType,
+                                          CARD8 *texPtr, int texPitch,
+                                          int width, int height, int flags)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+
+       FFBLOG(("FFB_SetupForCPUToScreenTexture: "
+               "TEX[T(%x):P(%d)] "
+               "wh[%d:%d] flgs[%x]\n",
+               texType, texPitch,
+               width, height, flags));
+
+       FFB_SetupTextureAttrs(pFfb);
+
+       pFfb->xaa_tex = (unsigned char *) texPtr;
+       pFfb->xaa_tex_pitch = texPitch;
+       pFfb->xaa_tex_width = width;
+       pFfb->xaa_tex_height = height;
+
+       return TRUE;
+}
+
+static void FFB_SubsequentCPUToScreenTexture(ScrnInfoPtr pScrn,
+                                            int dstx, int dsty,
+                                            int srcx, int srcy,
+                                            int width, int height)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       unsigned char *dst_base, *sfb32;
+       unsigned int *tex_base;
+       int psz_shift = 2;
+
+       FFBLOG(("FFB_SubsequentCPUToScreenAlphaTexture: "
+               "dst[%d:%d] src[%d:%d] wh[%d:%d]\n",
+               dstx, dsty, srcx, srcy, width, height));
+
+       sfb32 = (unsigned char *) pFfb->sfb32;
+       dst_base = sfb32 + (dsty * (2048 << psz_shift)) + (dstx << psz_shift);
+       tex_base = (unsigned int *) pFfb->xaa_tex;
+       tex_base += srcx;
+       if (srcy)
+               tex_base += (srcy * pFfb->xaa_tex_pitch);
+       while (height--) {
+               unsigned int *dst = (unsigned int *) dst_base;
+               unsigned int *tex = tex_base;
+               int w = width;
+               while (w--) {
+                       (*dst) = *tex;
+
+                       dst++;
+                       tex++;
+               }
+               dst_base += (2048 << psz_shift);
+               tex_base += pFfb->xaa_tex_pitch;
+       }
+}
+
+static void FFB_WritePixmap(ScrnInfoPtr pScrn,
+                           int x, int y, int w, int h,
+                           unsigned char *src,
+                           int srcwidth,
+                           int rop,
+                           unsigned int planemask,
+                           int trans, int bpp, int depth)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       unsigned char *dst, *sfb32;
+       int psz_shift = 2;
+       ffb_fbcPtr ffb = pFfb->regs;
+
+       FFBLOG(("FFB_WritePixmap: "
+               "x[%d] y[%d] w[%d] h[%d] srcw[%d] rop[%d] pmask[%x] "
+               "trans[%d] bpp[%d] depth[%d]\n",
+               x, y, w, h, srcwidth, rop, planemask,
+               trans, bpp, depth));
+
+       FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
+       FFBWait(pFfb, ffb);
+
+       sfb32 = (unsigned char *) pFfb->sfb32;
+       dst = sfb32 + (y * (2048 << psz_shift)) + (x << psz_shift);
+       VISmoveImageLR(src, dst, w << psz_shift, h,
+                      srcwidth, (2048 << psz_shift));
+}
+
+static void FFB_SetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
+                                          int pat_word1, int pat_word2,
+                                          int fg, int bg, int rop,
+                                          unsigned int planemask)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       unsigned int ppc, ppc_mask, fbc;
+       int i;
+
+       FFBLOG(("FFB_SetupForMono8x8PatternFill: "
+               "pat[%08x:%08x] fg[%x] bg[%x] rop[%d] pmask[%x]\n",
+               pat_word1, pat_word2,
+               fg, bg, rop, planemask));
+
+       ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_ENABLE | FFB_PPC_CS_CONST;
+       if (bg < 0)
+               ppc |= FFB_PPC_TBE_TRANSPARENT;
+       else
+               ppc |= FFB_PPC_TBE_OPAQUE;
+       ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK |
+         FFB_PPC_TBE_MASK | FFB_PPC_CS_MASK;
+       fbc = pFfb->xaa_fbc;
+       rop = (rop | FFB_ROP_EDIT_BIT) | (FFB_ROP_NEW << 8);
+
+       FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask, rop,
+                    FFB_DRAWOP_RECTANGLE, fg, fbc, pFfb->xaa_wid);
+       if (bg >= 0)
+               FFB_WRITE_BG(pFfb, ffb, bg);
+
+       FFBFifo(pFfb, 32);
+       for (i = 0; i < 32; i += 2) {
+               CARD32 val1, val2;
+               int shift = (24 - ((i % 4) * 8));
+
+               if ((i % 8) < 4) {
+                       val1 = (pat_word1 >> shift) & 0xff;
+                       val2 = (pat_word1 >> (shift + 8)) & 0xff;
+               } else {
+                       val1 = (pat_word2 >> shift) & 0xff;
+                       val2 = (pat_word2 >> (shift + 8)) & 0xff;
+               }
+               val1 |= (val1 << 8) | (val1 << 16) | (val1 << 24);
+               val2 |= (val2 << 8) | (val2 << 16) | (val2 << 24);
+               FFB_WRITE64(&ffb->pattern[i], val1, val2);
+       }
+       pFfb->rp_active = 1;
+}
+
+static void FFB_SubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
+                                                int pat_word1, int pat_word2,
+                                                int x, int y, int w, int h)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+
+       FFBLOG(("FFB_SubsequentMono8x8PatternFillRect: "
+               "x[%d] y[%d] w[%d] h[%d]\n", x, y, w, h));
+
+       FFBFifo(pFfb, 4);
+       FFB_WRITE64(&ffb->by, y, x);
+       FFB_WRITE64_2(&ffb->bh, h, w);
+}
+
+static void FFB_SetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                          int fg, int bg,
+                                                          int rop,
+                                                          unsigned int planemask)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       unsigned int ppc, ppc_mask, fbc;
+
+       FFBLOG(("FFB_SetupForScanlineCPUToScreenColorExpandFill: "
+               "fg[%x] bg[%x] rop[%d] pmask[%x]\n",
+               fg, bg, rop, planemask));
+
+       ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST;
+       if (bg < 0)
+               ppc |= FFB_PPC_TBE_TRANSPARENT;
+       else
+               ppc |= FFB_PPC_TBE_OPAQUE;
+       ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK |
+         FFB_PPC_TBE_MASK | FFB_PPC_CS_MASK;
+       fbc = pFfb->xaa_fbc;
+       rop = (rop | FFB_ROP_EDIT_BIT) | (FFB_ROP_NEW << 8);
+
+       if ((pFfb->ppc_cache & ppc_mask) != ppc ||
+           pFfb->fg_cache != fg ||
+           pFfb->fbc_cache != fbc ||
+           pFfb->rop_cache != rop ||
+           pFfb->pmask_cache != planemask ||
+           pFfb->fontinc_cache != ((0<<16) | 32) ||
+           (bg >= 0 && pFfb->bg_cache != bg)) {
+               pFfb->ppc_cache &= ~ppc_mask;
+               pFfb->ppc_cache |= ppc;
+               pFfb->fg_cache = fg;
+               pFfb->fbc_cache = fbc;
+               pFfb->rop_cache = rop;
+               pFfb->pmask_cache = planemask;
+               pFfb->fontinc_cache = ((0<<16) | 32);
+               if (bg >= 0)
+                       pFfb->bg_cache = bg;
+               FFBFifo(pFfb, (bg >= 0 ? 7 : 6));
+               ffb->ppc = ppc;
+               ffb->fg = fg;
+               ffb->fbc = fbc;
+               ffb->rop = rop;
+               ffb->pmask = planemask;
+               ffb->fontinc = ((0 << 16) | 32);
+               if(bg >= 0)
+                       ffb->bg = bg;
+       }
+       pFfb->rp_active = 1;
+}
+
+static void FFB_SubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
+                                                            int x, int y, int w, int h,
+                                                            int skipleft)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       FFBLOG(("FFB_SubsequentCPUToScreenColorExpandFill: "
+               "x[%d] y[%d] w[%d] h[%d] skipleft[%d]\n",
+               x, y, w, h, skipleft));
+
+       pFfb->xaa_scanline_x = x;
+       pFfb->xaa_scanline_y = y;
+       pFfb->xaa_scanline_w = w;
+}
+
+static void FFB_SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       CARD32 *bits = (CARD32 *) pFfb->xaa_scanline_buffers[bufno];
+       int w;
+
+       FFBFifo(pFfb, 1);
+       ffb->fontxy = ((pFfb->xaa_scanline_y << 16) | pFfb->xaa_scanline_x);
+
+       w = pFfb->xaa_scanline_w;
+       if (w >= 32) {
+               FFB_WRITE_FONTW(pFfb, ffb, 32);
+               FFBFifo(pFfb, (w / 32));
+               do {
+                       ffb->font = *bits++;
+                       w -= 32;
+               } while (w >= 32);
+       }
+       if (w > 0) {
+               FFB_WRITE_FONTW(pFfb, ffb, w);
+               FFBFifo(pFfb, 1);
+               ffb->font = *bits++;
+       }
+
+       pFfb->xaa_scanline_y++;
+}
+
+static void FFB_SetupForDashedLine(ScrnInfoPtr pScrn,
+                                  int fg, int bg, int rop,
+                                  unsigned int planemask,
+                                  int length, unsigned char *pattern)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       CARD32 *pat_ptr = (CARD32 *)pattern;
+       unsigned int ppc, ppc_mask, fbc;
+
+       FFBLOG(("FFB_SetupForDashedLine: "
+               "fg[%x] bg[%x] rop[%d] pmask[%x] patlen[%d] pat[%x]\n",
+               fg, bg, rop, planemask, length, *pat_ptr));
+
+       pFfb->xaa_planemask = planemask;
+       pFfb->xaa_rop = rop;
+       pFfb->xaa_linepat = 
+               (*pat_ptr << FFB_LPAT_PATTERN_SHIFT) |
+               (1 << FFB_LPAT_SCALEVAL_SHIFT) |
+               ((length & 0xf) << FFB_LPAT_PATLEN_SHIFT);
+
+       fbc = pFfb->xaa_fbc;
+       ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+       ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+       FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+                    (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+                    FFB_DRAWOP_BRLINEOPEN, fg, fbc, pFfb->xaa_wid);
+       pFfb->rp_active = 1;
+}
+
+static void FFB_SubsequentDashedTwoPointLine( ScrnInfoPtr pScrn,
+                                             int x1, int y1,
+                                             int x2, int y2,
+                                             int flags, int phase)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       unsigned int linepat = pFfb->xaa_linepat;
+       unsigned int drawop;
+
+       FFBLOG(("FFB_SubsequentDashedTwoPointLine: "
+               "x1[%d] y1[%d] x2[%d] y2[%d] flgs[%x] phase[%d]\n",
+               x1, y2, x2, y2, flags, phase));
+
+       linepat |= (phase & 0xf) << FFB_LPAT_PATPTR_SHIFT;
+
+       drawop = (flags & OMIT_LAST) ?
+         FFB_DRAWOP_BRLINEOPEN : FFB_DRAWOP_BRLINECAP;
+       FFB_WRITE_DRAWOP(pFfb, ffb, drawop);
+
+       if (pFfb->has_brline_bug) {
+               FFBFifo(pFfb, 6);
+               ffb->ppc = 0;
+       } else
+               FFBFifo(pFfb, 5);
+       ffb->lpat = linepat;
+       FFB_WRITE64(&ffb->by, y1, x1);
+       FFB_WRITE64_2(&ffb->bh, y2, x2);
+}
+
+static void FFB_SetupForSolidLine(ScrnInfoPtr pScrn, 
+                                 int color, int rop, unsigned int planemask)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       unsigned int ppc, ppc_mask, fbc;
+       FFBLOG(("FFB_SetupForSolidLine: "
+               "color[%d] rop[%d] pmask[%x]\n",
+               color, rop, planemask));
+
+       pFfb->xaa_planemask = planemask;
+       pFfb->xaa_rop = rop;
+
+       fbc = pFfb->xaa_fbc;
+       ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+       ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+       FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+                    (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+                    FFB_DRAWOP_BRLINEOPEN, color, fbc, pFfb->xaa_wid);
+       FFBFifo(pFfb, 1);
+       ffb->lpat = 0;
+       pFfb->rp_active = 1;
+}
+
+static void FFB_SubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
+                                           int x1, int y1,
+                                           int x2, int y2,
+                                           int flags)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       int drawop;
+
+       FFBLOG(("FFB_SubsequentSolidTwoPointLine: "
+               "x1[%d] y1[%d] x2[%d] y2[%d] flags[%d]\n",
+               x1, y1, x2, y2, flags));
+
+       drawop = (flags & OMIT_LAST) ?
+         FFB_DRAWOP_BRLINEOPEN : FFB_DRAWOP_BRLINECAP;
+       FFB_WRITE_DRAWOP(pFfb, ffb, drawop);
+
+       if (pFfb->has_brline_bug) {
+               FFBFifo(pFfb, 5);
+               ffb->ppc = 0;
+       } else
+               FFBFifo(pFfb, 4);
+       FFB_WRITE64(&ffb->by, y1, x1);
+       FFB_WRITE64_2(&ffb->bh, y2, x2);
+}
+
+void FFB_SetupForSolidFill(ScrnInfoPtr pScrn,
+                          int color, int rop, unsigned int planemask)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       unsigned int ppc, ppc_mask, fbc;
+
+       FFBLOG(("FFB_SetupForSolidFill: "
+               "color[%d] rop[%d] pmask[%u]\n",
+               color, rop, planemask));
+
+       pFfb->xaa_planemask = planemask;
+       pFfb->xaa_rop = rop;
+
+       fbc = pFfb->xaa_fbc;
+       if (pFfb->ffb_res == ffb_res_high)
+               fbc |= FFB_FBC_WB_B;
+       ppc = FFB_PPC_ABE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID;
+       ppc_mask = FFB_PPC_ABE_MASK | FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK;
+
+       FFB_ATTR_RAW(pFfb, ppc, ppc_mask, planemask,
+                    (FFB_ROP_EDIT_BIT | rop) | (FFB_ROP_NEW << 8),
+                    FFB_DRAWOP_RECTANGLE, color, fbc, pFfb->xaa_wid);
+       pFfb->rp_active = 1;
+}
+
+void FFB_SubsequentSolidFillRect(ScrnInfoPtr pScrn,
+                                int x, int y,
+                                int w, int h)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+
+       FFBLOG(("FFB_SubsequentSolidFillRect: "
+               "x[%d] y[%d] w[%d] h[%d]\n", x, y, w, h));
+
+       FFBFifo(pFfb, 4);
+       FFB_WRITE64(&ffb->by, y, x);
+       FFB_WRITE64_2(&ffb->bh, h, w);
+}
+
+static void FFB_ScreenToScreenBitBlt(ScrnInfoPtr pScrn,
+                                    int nbox,
+                                    DDXPointPtr pptSrc,
+                                    BoxPtr pbox,
+                                    int xdir, int ydir,
+                                    int rop, unsigned int planemask)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       int use_vscroll;
+
+       FFBLOG(("FFB_ScreenToScreenBitBlt: "
+               "nbox[%d] xdir[%d] ydir[%d] rop[%d] pmask[%x]\n",
+               nbox, xdir, ydir, rop, planemask));
+
+       use_vscroll = 0;
+       if (!pFfb->disable_vscroll &&
+           rop == GXcopy) {
+               int i;
+
+               for (i = 0; i < nbox; i++)
+                       if (pptSrc[i].x != pbox[i].x1 ||
+                           pptSrc[i].y == pbox[i].y1)
+                               break;
+               if (i == nbox) {
+                       /* If/When double buffer extension is re-enabled
+                        * check buffers here.
+                        */
+                       use_vscroll = 1;
+               }
+       }
+       if (use_vscroll) {
+               FFB_ATTR_VSCROLL_XAA(pFfb, planemask);
+               while (nbox--) {
+                       FFBFifo(pFfb, 7);
+                       ffb->drawop = FFB_DRAWOP_VSCROLL;
+                       FFB_WRITE64(&ffb->by, pptSrc->y, pptSrc->x);
+                       FFB_WRITE64_2(&ffb->dy, pbox->y1, pbox->x1);
+                       FFB_WRITE64_3(&ffb->bh, (pbox->y2 - pbox->y1),
+                                     (pbox->x2 - pbox->x1));
+
+                       pbox++;
+                       pptSrc++;
+               }
+               pFfb->rp_active = 1;
+               SET_SYNC_FLAG(pFfb->pXAAInfo);
+       } else {
+               unsigned char *sfb32 = (unsigned char *) pFfb->sfb32;
+               int psz_shift = 2;
+
+               FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
+               if (pFfb->use_blkread_prefetch) {
+                       unsigned int bit;
+
+                       if (xdir < 0)
+                               bit = FFB_MER_EDRA;
+                       else
+                               bit = FFB_MER_EIRA;
+                       FFBFifo(pFfb, 1);
+                       ffb->mer = bit;
+                       pFfb->rp_active = 1;
+               }
+               FFBWait(pFfb, ffb);
+
+               while (nbox--) {
+                       unsigned char *src, *dst;
+                       int x1, y1, x2, y2;
+                       int width, height;
+                       int sdkind;
+
+                       x1 = pptSrc->x;
+                       y1 = pptSrc->y;
+                       x2 = pbox->x1;
+                       y2 = pbox->y1;
+                       width = (pbox->x2 - pbox->x1);
+                       height = (pbox->y2 - pbox->y1);
+
+                       src = sfb32 + (y1 * (2048 << psz_shift))
+                               + (x1 << psz_shift);
+                       dst = sfb32 + (y2 * (2048 << psz_shift))
+                               + (x2 << psz_shift);
+                       sdkind = (2048 << psz_shift);
+
+                       if (ydir < 0) {
+                               src += ((height - 1) * (2048 << psz_shift));
+                               dst += ((height - 1) * (2048 << psz_shift));
+                               sdkind = -sdkind;
+                       }
+                       width <<= psz_shift;
+                       if (xdir < 0)
+                               VISmoveImageRL(src, dst, width, height,
+                                              sdkind, sdkind);
+                       else
+                               VISmoveImageLR(src, dst, width, height,
+                                              sdkind, sdkind);
+                       pbox++;
+                       pptSrc++;
+	       }
+               if (pFfb->use_blkread_prefetch) {
+                       FFBFifo(pFfb, 1);
+                       ffb->mer = FFB_MER_DRA;
+                       pFfb->rp_active = 1;
+                       FFBWait(pFfb, ffb);
+               }
+       }
+}
+
+void FFB_SetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
+                                   int xdir, int ydir, int rop,
+                                   unsigned int planemask,
+                                   int trans_color)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+       FFBLOG(("FFB_SetupForScreenToScreenCopy: "
+               "xdir[%d] ydir[%d] rop[%d] pmask[%x] tcolor[%d]\n",
+               xdir, ydir, rop, planemask, trans_color));
+
+       pFfb->xaa_planemask = planemask;
+       pFfb->xaa_xdir = xdir;
+       pFfb->xaa_ydir = ydir;
+       pFfb->xaa_rop = rop;
+       FFB_ATTR_SFB_VAR_XAA(pFfb, planemask, rop);
+       FFBWait(pFfb, ffb);
+}
+		  
+void FFB_SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
+                                     int x1, int y1,
+                                     int x2, int y2,
+                                     int width, int height)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       unsigned char *src, *dst, *sfb32;
+       int psz_shift = 2;
+       int sdkind;
+
+       FFBLOG(("FFB_SubsequentScreenToScreenCopy: "
+               "x1[%d] y1[%d] x2[%d] y2[%u] w[%d] h[%d]\n",
+               x1, y1, x2, y2, width, height));
+
+       sfb32 = (unsigned char *) pFfb->sfb32;
+       src = sfb32 + (y1 * (2048 << psz_shift)) + (x1 << psz_shift);
+       dst = sfb32 + (y2 * (2048 << psz_shift)) + (x2 << psz_shift);
+       sdkind = (2048 << psz_shift);
+
+       if (pFfb->xaa_ydir < 0) {
+               src += ((height - 1) * (2048 << psz_shift));
+               dst += ((height - 1) * (2048 << psz_shift));
+               sdkind = -sdkind;
+       }
+
+       width <<= psz_shift;
+       if (pFfb->xaa_xdir < 0)
+               VISmoveImageRL(src, dst, width, height, sdkind, sdkind);
+       else
+               VISmoveImageLR(src, dst, width, height, sdkind, sdkind);
+}
+
+static void FFB_Sync(ScrnInfoPtr pScrn)
+{
+       FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+       ffb_fbcPtr ffb = pFfb->regs;
+
+       FFB_ATTR_SFB_VAR_XAA(pFfb, 0xffffffff, GXcopy);
+       FFBWait(pFfb, ffb);
 }
 
 /* Multiplies and divides suck... */
@@ -771,36 +840,15 @@ static void CreatorAlignTabInit(FFBPtr pFfb)
 	}
 }
 
-static Bool
-CreatorPositionWindow(WindowPtr pWin, int x, int y)
+Bool FFBAccelInit(ScreenPtr pScreen, FFBPtr pFfb)
 {
-	if (pWin->drawable.bitsPerPixel == 8)
-		return cfbPositionWindow(pWin, x, y);
-	else
-		return cfb32PositionWindow(pWin, x, y);
-}
-
-extern Bool CreatorCreateGC (GCPtr pGC);
-
-#ifdef DEBUG_FFB
-FILE *FDEBUG_FD = NULL;
-#endif
-
-BSFuncRec CreatorBSFuncRec = {
-    CreatorSaveAreas,
-    CreatorRestoreAreas,
-    (BackingStoreSetClipmaskRgnProcPtr) 0,
-    (BackingStoreGetImagePixmapProcPtr) 0,
-    (BackingStoreGetSpansPixmapProcPtr) 0,
-};
-
-Bool FFBAccelInit (ScreenPtr pScreen, FFBPtr pFfb)
-{
-	ffb_fbcPtr ffb;
+	XAAInfoRecPtr infoRec;
+	ffb_fbcPtr ffb = pFfb->regs;
 
 	if (serverGeneration != CreatorGeneration) {
 		CreatorScreenPrivateIndex = AllocateScreenPrivateIndex ();
-		if (CreatorScreenPrivateIndex == -1) return FALSE;
+		if (CreatorScreenPrivateIndex == -1)
+			return FALSE;
 		CreatorGCPrivateIndex = AllocateGCPrivateIndex ();
 		CreatorWindowPrivateIndex = AllocateWindowPrivateIndex ();
 		CreatorGeneration = serverGeneration;
@@ -810,32 +858,132 @@ Bool FFBAccelInit (ScreenPtr pScreen, FFBPtr pFfb)
 		return FALSE;
 	if (!AllocateWindowPrivate(pScreen, CreatorWindowPrivateIndex, 0))
 		return FALSE;
+
 	pScreen->devPrivates[CreatorScreenPrivateIndex].ptr = pFfb;
 
-	pFfb->fifo_cache = 0;
-	ffb = pFfb->regs;
-
-	/* Replace various screen functions. */
-	pScreen->CreateGC = CreatorCreateGC;
-	pScreen->CreateWindow = CreatorCreateWindow;
-	pScreen->DestroyWindow = CreatorDestroyWindow;
-	pScreen->PositionWindow = CreatorPositionWindow;
-	pScreen->ChangeWindowAttributes = CreatorChangeWindowAttributes;
-	pScreen->PaintWindowBackground = CreatorPaintWindow;
-	pScreen->PaintWindowBorder = CreatorPaintWindow;
-	pScreen->GetSpans = CreatorGetSpans;
-	pScreen->CopyWindow = CreatorCopyWindow;
-	pScreen->GetImage = CreatorGetImage;
-	pScreen->BackingStoreFuncs = CreatorBSFuncRec;
-
-	/* cfb8_32wid took over this to init the WID plane,
-	 * and with how our code works that is not necessary.
-	 */
-	pScreen->WindowExposures = miWindowExposures;
+	pFfb->xaa_fbc = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A |
+			 FFB_FBC_WE_FORCEON |
+			 FFB_FBC_SB_BOTH |
+			 FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF |
+			 FFB_FBC_RGBE_MASK |
+			 FFB_FBC_XE_ON);
+	pFfb->xaa_wid = FFBWidAlloc(pFfb, TrueColor, 0, TRUE);
+	if (pFfb->xaa_wid == (unsigned int) -1)
+		return FALSE;
+
+	pFfb->pXAAInfo = infoRec = XAACreateInfoRec();
+	if (!infoRec) {
+		FFBWidFree(pFfb, pFfb->xaa_wid);
+		return FALSE;
+	}
+
+	pFfb->xaa_scanline_buffers[0] = xalloc(2048 * 4);
+	if (!pFfb->xaa_scanline_buffers[0]) {
+		XAADestroyInfoRec(infoRec);
+		return FALSE;
+	}
+
+	pFfb->xaa_scanline_buffers[1] = xalloc(2048 * 4);
+	if (!pFfb->xaa_scanline_buffers[1]) {
+		xfree(pFfb->xaa_scanline_buffers[0]);
+		XAADestroyInfoRec(infoRec);
+		return FALSE;
+	}
 
-	/* Set FFB line-bias for clipping. */
+	infoRec->Sync = FFB_Sync;
+
+	/* Use VIS and VSCROLL for screen to screen copies.  */
+	infoRec->ScreenToScreenCopyFlags = NO_TRANSPARENCY;
+	infoRec->SetupForScreenToScreenCopy =
+		FFB_SetupForScreenToScreenCopy;
+	infoRec->SubsequentScreenToScreenCopy =
+		FFB_SubsequentScreenToScreenCopy;
+
+	/* In order to optimize VSCROLL and prefetching properly we
+	 * have to use our own mid-layer routine.
+	 */
+	infoRec->ScreenToScreenBitBltFlags = NO_TRANSPARENCY;
+	infoRec->ScreenToScreenBitBlt =
+		FFB_ScreenToScreenBitBlt;
+
+	infoRec->SolidFillFlags = 0;
+	infoRec->SetupForSolidFill =
+		FFB_SetupForSolidFill;
+	infoRec->SubsequentSolidFillRect =
+		FFB_SubsequentSolidFillRect;
+
+	infoRec->SolidLineFlags = 0;
+	infoRec->SetupForSolidLine =
+		FFB_SetupForSolidLine;
+	infoRec->SubsequentSolidTwoPointLine =
+		FFB_SubsequentSolidTwoPointLine;
 	miSetZeroLineBias(pScreen, OCTANT3 | OCTANT4 | OCTANT6 | OCTANT1);
 
+	infoRec->DashedLineFlags = (TRANSPARENCY_ONLY |
+				    LINE_PATTERN_LSBFIRST_LSBJUSTIFIED);
+	infoRec->DashPatternMaxLength = 16;
+	infoRec->SetupForDashedLine =
+		FFB_SetupForDashedLine;
+	infoRec->SubsequentDashedTwoPointLine =
+		FFB_SubsequentDashedTwoPointLine;
+
+	/* We cannot use the non-scanline color expansion mechanism on FFB
+	 * for two reasons:
+	 *
+	 * 1) A render pass can only render 32-pixels wide on FFB, XAA expects
+	 *    that arbitrary widths are possible per render pass.
+	 *
+	 * 2) The FFB accelerator FIFO is only 100 or so words deep, and
+	 *    XAA gives no way to limit the number of words it writes into
+	 *    the ColorExpandBase register per rendering pass.
+	 */
+	infoRec->ScanlineColorExpandBuffers = pFfb->xaa_scanline_buffers;
+	infoRec->NumScanlineColorExpandBuffers = 2;
+	infoRec->ScanlineCPUToScreenColorExpandFillFlags =
+		CPU_TRANSFER_PAD_DWORD |
+		SCANLINE_PAD_DWORD |
+		CPU_TRANSFER_BASE_FIXED |
+		BIT_ORDER_IN_BYTE_LSBFIRST;
+	infoRec->SetupForScanlineCPUToScreenColorExpandFill =
+		FFB_SetupForScanlineCPUToScreenColorExpandFill;
+	infoRec->SubsequentScanlineCPUToScreenColorExpandFill =
+		FFB_SubsequentScanlineCPUToScreenColorExpandFill;
+	infoRec->SubsequentColorExpandScanline =
+		FFB_SubsequentColorExpandScanline;
+
+	infoRec->Mono8x8PatternFillFlags =
+		HARDWARE_PATTERN_PROGRAMMED_BITS |
+		HARDWARE_PATTERN_SCREEN_ORIGIN |
+		BIT_ORDER_IN_BYTE_LSBFIRST;
+	infoRec->SetupForMono8x8PatternFill =
+		FFB_SetupForMono8x8PatternFill;
+	infoRec->SubsequentMono8x8PatternFillRect =
+		FFB_SubsequentMono8x8PatternFillRect;
+
+	/* Use VIS for pixmap writes.  */
+	infoRec->WritePixmap = FFB_WritePixmap;
+
+	/* RENDER optimizations.  */
+	infoRec->CPUToScreenAlphaTextureFlags =
+		XAA_RENDER_NO_TILE |
+		XAA_RENDER_NO_SRC_ALPHA;
+	infoRec->CPUToScreenAlphaTextureFormats = FFBAlphaTextureFormats;
+	infoRec->SetupForCPUToScreenAlphaTexture =
+		FFB_SetupForCPUToScreenAlphaTexture;
+	infoRec->SubsequentCPUToScreenAlphaTexture =
+		FFB_SubsequentCPUToScreenAlphaTexture;
+
+	infoRec->CPUToScreenTextureFlags =
+		XAA_RENDER_NO_TILE |
+		XAA_RENDER_NO_SRC_ALPHA;
+	infoRec->CPUToScreenTextureFormats = FFBTextureFormats;
+	infoRec->SetupForCPUToScreenTexture =
+		FFB_SetupForCPUToScreenTexture;
+	infoRec->SubsequentCPUToScreenTexture =
+		FFB_SubsequentCPUToScreenTexture;
+
+	pFfb->fifo_cache = 0;
+
 	FFB_DEBUG_init();
 	FDEBUG((FDEBUG_FD,
 		"FFB: cfg0(%08x) cfg1(%08x) cfg2(%08x) cfg3(%08x) ppcfg(%08x)\n",
@@ -904,26 +1052,31 @@ Bool FFBAccelInit (ScreenPtr pScreen, FFBPtr pFfb)
 
 	pFfb->ppc_cache = (FFB_PPC_FW_DISABLE |
 			   FFB_PPC_VCE_DISABLE | FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST |
-			   FFB_PPC_XS_CONST | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST |
+			   FFB_PPC_XS_WID | FFB_PPC_YS_CONST | FFB_PPC_ZS_CONST |
 			   FFB_PPC_DCE_DISABLE | FFB_PPC_ABE_DISABLE | FFB_PPC_TBE_OPAQUE);
-
+	pFfb->wid_cache = pFfb->xaa_wid;
 	pFfb->pmask_cache = ~0;
-	pFfb->rop_cache = (FFB_ROP_ZERO | (FFB_ROP_NEW << 8));
+	pFfb->rop_cache = (FFB_ROP_NEW | (FFB_ROP_NEW << 8));
 	pFfb->drawop_cache = FFB_DRAWOP_RECTANGLE;
 	pFfb->fg_cache = pFfb->bg_cache = 0;
 	pFfb->fontw_cache = 32;
 	pFfb->fontinc_cache = (1 << 16) | 0;
-	pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
-			   FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_OFF |
-			   FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_MASK);
+	pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED | FFB_FBC_RB_A |
+			   FFB_FBC_WE_FORCEON |
+			   FFB_FBC_SB_BOTH |
+			   FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF |
+			   FFB_FBC_RGBE_OFF |
+			   FFB_FBC_XE_ON);
 	pFfb->laststipple = NULL;
 
 	/* We will now clear the screen: we'll draw a rectangle covering all the
 	 * viewscreen, using a 'blackness' ROP.
 	 */
-	FFBFifo(pFfb, 13);
+	FFBFifo(pFfb, 22);
 	ffb->fbc = pFfb->fbc_cache;
 	ffb->ppc = pFfb->ppc_cache;
+	ffb->wid = pFfb->wid_cache;
+	ffb->xpmask = 0xff;
 	ffb->pmask = pFfb->pmask_cache;
 	ffb->rop = pFfb->rop_cache;
 	ffb->drawop = pFfb->drawop_cache;
@@ -931,31 +1084,32 @@ Bool FFBAccelInit (ScreenPtr pScreen, FFBPtr pFfb)
 	ffb->bg = pFfb->bg_cache;
 	ffb->fontw = pFfb->fontw_cache;
 	ffb->fontinc = pFfb->fontinc_cache;
+	ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
+	ffb->cmp = 0x80808080;
+	ffb->matchab = 0x80808080;
+	ffb->magnab = 0x80808080;
+	ffb->blendc = (FFB_BLENDC_FORCE_ONE |
+		       FFB_BLENDC_DF_ONE_M_A |
+		       FFB_BLENDC_SF_A);
+	ffb->blendc1 = 0;
+	ffb->blendc2 = 0;
 	FFB_WRITE64(&ffb->by, 0, 0);
 	FFB_WRITE64_2(&ffb->bh, pFfb->psdp->height, pFfb->psdp->width);
 	pFfb->rp_active = 1;
 	FFBWait(pFfb, ffb);
 	
-	/* Fixup the FBC/PPC caches to deal with actually using
-	 * a WID for every ROP.
-	 */
-	pFfb->fbc_cache = (FFB_FBC_WB_A | FFB_FBC_WM_COMBINED |
-			   FFB_FBC_RB_A | FFB_FBC_SB_BOTH | FFB_FBC_XE_ON |
-			   FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON);
-	pFfb->ppc_cache &= ~FFB_PPC_XS_MASK;
-	pFfb->ppc_cache |= FFB_PPC_XS_WID;
-	pFfb->wid_cache = 0xff;
-	FFBFifo(pFfb, 8);
-	ffb->fbc = pFfb->fbc_cache;
-	ffb->ppc = FFB_PPC_XS_WID;
-	ffb->wid = pFfb->wid_cache;
-	ffb->xpmask = 0xff;
-	ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
-	ffb->cmp = 0x80808080;
-	ffb->matchab = 0x80808080;
-	ffb->magnab = 0x80808080;
+	FFB_ATTR_SFB_VAR_XAA(pFfb, 0xffffffff, GXcopy);
 	FFBWait(pFfb, ffb);
 
+	if (!XAAInit(pScreen, infoRec)) {
+		XAADestroyInfoRec(infoRec);
+		xfree(pFfb->xaa_scanline_buffers[0]);
+		xfree(pFfb->xaa_scanline_buffers[1]);
+		pFfb->pXAAInfo = NULL;
+		FFBWidFree(pFfb, pFfb->xaa_wid);
+		return FALSE;
+	}
+
 	/* Success */
 	return TRUE;
 }
diff --git a/src/ffb_bcopy.c b/src/ffb_bcopy.c
index 6de0eac..39faa68 100644
--- a/src/ffb_bcopy.c
+++ b/src/ffb_bcopy.c
@@ -22,7 +22,7 @@
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_bcopy.c,v 1.2 2000/05/23 04:47:44 dawes Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_bcopy.c,v 1.1 2000/05/18 23:21:35 dawes Exp $ */
 
 #include "ffb.h"
 #include "ffb_regs.h"
@@ -382,7 +382,6 @@ CreatorDoBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst,
 						if (use_prefetch) {
 							FFBFifo(pFfb, 1);
 							pFfb->regs->mer = FFB_MER_EDRA;
-							pFfb->regs->mer = FFB_MER_EIRA;
 							pFfb->rp_active = 1;
 						}
 						VISmoveImageRL ((psrcBase +
diff --git a/src/ffb_dga.c b/src/ffb_dga.c
index 3ba43df..851081c 100644
--- a/src/ffb_dga.c
+++ b/src/ffb_dga.c
@@ -21,7 +21,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dga.c,v 1.2 2000/10/17 16:53:17 tsi Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dga.c,v 1.1 2000/05/23 04:47:44 dawes Exp $ */
 
 #include "xf86.h"
 #include "xf86_OSproc.h"
@@ -35,30 +35,16 @@
 #include "ffb_stip.h"
 #include "ffb_loops.h"
 
-static Bool FFB_OpenFramebuffer(ScrnInfoPtr pScrn, char **name, unsigned char **mem,
-				int *size, int *offset, int *extra);
-static void FFB_CloseFramebuffer(ScrnInfoPtr pScrn);
-static Bool FFB_SetMode(ScrnInfoPtr pScrn, DGAModePtr pMode);
-static void FFB_SetViewport(ScrnInfoPtr pScrn, int x, int y, int flags);
-static int FFB_GetViewport(ScrnInfoPtr pScrn);
-static void FFB_Flush(ScrnInfoPtr pScrn);
-
-/* Have to disable all this stuff for now until I figure out where
- * we should get the WID values from... ho hum... -DaveM
- */
-#if 0
-static void FFB_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color);
-
-#ifdef USE_VIS
-static void FFB_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy, int w, int h,
-			 int dstx, int dsty);
-#else
-#define FFB_BlitRect NULL
-#endif
-#else
-#define FFB_FillRect NULL
-#define FFB_BlitRect NULL
-#endif
+static Bool FFB_OpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
+				int *, int *, int *);
+static void FFB_CloseFramebuffer(ScrnInfoPtr);
+static Bool FFB_SetMode(ScrnInfoPtr, DGAModePtr);
+static void FFB_SetViewport(ScrnInfoPtr, int, int, int);
+static int FFB_GetViewport(ScrnInfoPtr);
+static void FFB_Flush(ScrnInfoPtr);
+static void FFB_FillRect(ScrnInfoPtr, int, int, int, int, unsigned long);
+static void FFB_BlitRect(ScrnInfoPtr, int, int, int, int,
+			 int, int);
 
 static DGAFunctionRec FFB_DGAFuncs = {
 	FFB_OpenFramebuffer,
@@ -93,10 +79,7 @@ void FFB_InitDGA(ScreenPtr pScreen)
 
 	/* Hmmm, what does concurrent access really mean? -DaveM */
 	mode->flags = (DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE | DGA_FILL_RECT);
-
-#ifdef USE_VIS
 	mode->flags |= DGA_BLIT_RECT;
-#endif
 
 	mode->imageWidth = 2048;
 	mode->imageHeight = 2048;
@@ -195,86 +178,31 @@ static void FFB_Flush(ScrnInfoPtr pScrn)
 	FFBWait(pFfb, ffb);
 }
 
-#if 0
-
-extern void CreatorFillBoxSolid (DrawablePtr pDrawable, int nBox,
-				 BoxPtr pBox, unsigned long pixel);
+extern void FFB_SetupForSolidFill(ScrnInfoPtr, int, int, unsigned int);
+extern void FFB_SubsequentSolidFillRect(ScrnInfoPtr, int, int, int, int);
 
 static void FFB_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color)
 {
-	DrawableRec draw;
-	BoxRec box;
-
-	draw.pScreen = pScrn->pScreen;
-	box.x1 = x;
-	box.y1 = y;
-	box.x2 = x + w;
-	box.y2 = y + h;
+	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
 
-	CreatorFillBoxSolid(&draw, 1, &box, color);
+	FFB_SetupForSolidFill(pScrn, color, GXcopy, ~0);
+	FFB_SubsequentSolidFillRect(pScrn, x, y, w, h);
+	SET_SYNC_FLAG(pFfb->pXAAInfo);
 }
 
-#ifdef USE_VIS
-extern void VISmoveImageLR(unsigned char *, unsigned char *, long, long, long, long);
-extern void VISmoveImageRL(unsigned char *, unsigned char *, long, long, long, long);
+extern void FFB_SetupForScreenToScreenCopy(ScrnInfoPtr, int, int, int,
+					   unsigned int, int);
+extern void FFB_SubsequentScreenToScreenCopy(ScrnInfoPtr, int, int,
+					     int, int, int, int);
 
 static void FFB_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy,
 			 int w, int h, int dstx, int dsty)
 {
 	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
-	ffb_fbcPtr ffb = pFfb->regs;
-
-	if (!pFfb->disable_vscroll &&
-	    dstx == srcx &&
-	    dsty != dsty) {
-		FFB_WRITE_ATTRIBUTES_VSCROLL(pFfb, 0x00ffffff);
-		FFBFifo(pFfb, 7);
-		ffb->drawop = FFB_DRAWOP_VSCROLL;
-		FFB_WRITE64(&ffb->by, srcy, srcx);
-		FFB_WRITE64_2(&ffb->dy, dsty, dstx);
-		FFB_WRITE64_3(&ffb->bh, h, w);
-		pFfb->rp_active = 1;
-	} else {
-		unsigned char *base = (unsigned char *)pFfb->fb;
-		int use_prefetch = pFfb->use_blkread_prefetch;
+	int xdir = ((srcx < dstx) && (srcy == dsty)) ? -1 : 1;
+	int ydir = (srcy < dsty) ? -1 : 1;
 
-		FFB_WRITE_ATTRIBUTES_SFB_VAR(pFfb, 0x00ffffff, GXcopy);
-		FFBWait(pFfb, ffb);
-		if (use_prefetch) {
-			FFBFifo(pFfb, 1);
-			ffb->mer = FFB_MER_EIRA;
-			pFfb->rp_active = 1;
-			FFBWait(pFfb, ffb);
-		}
-		if (srcx < dstx) {
-			VISmoveImageRL((base +
-					((srcy + h - 1) * (2048 * 4)) +
-					(srcx * (32 / 8))),
-				       (base +
-					((dsty + h - 1) * (2048 * 4)) +
-					(dstx * (32 / 8))),
-				       (w * (32 / 8)),
-				       h,
-				       -(2048 * 4), - (2048 * 4));
-		} else {
-			VISmoveImageLR((base +
-					((srcy + h - 1) * (2048 * 4)) +
-					(srcx * (32 / 8))),
-				       (base +
-					((dsty + h - 1) * (2048 * 4)) +
-					(dstx * (32 / 8))),
-				       (w * (32 / 8)),
-				       h,
-				       -(2048 * 4), - (2048 * 4));
-		}
-		if (use_prefetch) {
-			FFBFifo(pFfb, 1);
-			ffb->mer = FFB_MER_DRA;
-			pFfb->rp_active = 1;
-			FFBWait(pFfb, pFfb->regs);
-		}
-	}
+	FFB_SetupForScreenToScreenCopy(pScrn, xdir, ydir, GXcopy, ~0, -1);
+	FFB_SubsequentScreenToScreenCopy(pScrn, srcx, srcy, dstx,dsty, w, h);
+	SET_SYNC_FLAG(pFfb->pXAAInfo);
 }
-#endif
-
-#endif
diff --git a/src/ffb_driver.c b/src/ffb_driver.c
index 8921955..5603085 100644
--- a/src/ffb_driver.c
+++ b/src/ffb_driver.c
@@ -29,12 +29,7 @@
 #include "mipointer.h"
 #include "mibstore.h"
 #include "micmap.h"
-
-#define PSZ 8
-#include "cfb.h"
-#undef PSZ
-#include "cfb32.h"
-#include "cfb8_32wid.h"
+#include "fb.h"
 
 #include "xf86cmap.h"
 
@@ -50,6 +45,7 @@ static Bool	FFBEnterVT(int scrnIndex, int flags);
 static void	FFBLeaveVT(int scrnIndex, int flags);
 static Bool	FFBCloseScreen(int scrnIndex, ScreenPtr pScreen);
 static Bool	FFBSaveScreen(ScreenPtr pScreen, int mode);
+static void	FFBDPMSSet(ScrnInfoPtr pScrn, int mode, int flags);
 
 /* Required if the driver supports mode switching */
 static Bool	FFBSwitchMode(int scrnIndex, DisplayModePtr mode, int flags);
@@ -58,8 +54,8 @@ static void	FFBAdjustFrame(int scrnIndex, int x, int y, int flags);
 
 /* Optional functions */
 static void	FFBFreeScreen(int scrnIndex, int flags);
-static int	FFBValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose,
-			     int flags);
+static ModeStatus FFBValidMode(int scrnIndex, DisplayModePtr mode,
+			       Bool verbose, int flags);
 static void     FFBDPMSMode(ScrnInfoPtr pScrn, int DPMSMode, int flags);
 /* ffb_dga.c */
 extern void FFB_InitDGA(ScreenPtr pScreen);
@@ -114,7 +110,7 @@ static XF86ModuleVersionInfo sunffbVersRec =
 	MODULEVENDORSTRING,
 	MODINFOSTRING1,
 	MODINFOSTRING2,
-	XF86_VERSION_CURRENT,
+	XORG_VERSION_CURRENT,
 	FFB_MAJOR_VERSION, FFB_MINOR_VERSION, FFB_PATCHLEVEL,
 	ABI_CLASS_VIDEODRV,
 	ABI_VIDEODRV_VERSION,
@@ -416,12 +412,12 @@ FFBPreInit(ScrnInfoPtr pScrn, int flags)
 	return FALSE;
     }
 
-    if (xf86LoadSubModule(pScrn, "cfb32") == NULL) {
+    if (xf86LoadSubModule(pScrn, "fb") == NULL) {
 	FFBFreeRec(pScrn);
 	return FALSE;
     }
 
-    if (xf86LoadSubModule(pScrn, "cfb") == NULL) {
+    if (xf86LoadSubModule(pScrn, "xaa") == NULL) {
 	FFBFreeRec(pScrn);
 	return FALSE;
     }
@@ -570,8 +566,6 @@ FFBProbeBoardType(FFBPtr pFfb)
 			pFfb->has_z_buffer = 0;
 		}
 		if (sbits & (1 << 0)) {
-			ErrorF("Double-buffered.\n");
-
 			/* This state really means to the driver that the double
 			 * buffers are available for hw accelerate Dbe.  When the
 			 * FFB is in high-resolution mode, the buffers are combined
@@ -581,86 +575,17 @@ FFBProbeBoardType(FFBPtr pFfb)
 			if ((ffb->fbcfg0 & FFB_FBCFG0_RES_MASK) != FFB_FBCFG0_RES_HIGH)
 				pFfb->has_double_buffer = 1;
 			else
-				pFfb->has_double_buffer = 1;
+				pFfb->has_double_buffer = 0;
 		} else {
-			ErrorF("Single-buffered.\n");
 			pFfb->has_double_buffer = 0;
 		}
+		if (pFfb->has_double_buffer)
+			ErrorF("Double-buffered.\n");
+		else
+			ErrorF("Single-buffered.\n");
 	}
 }
 
-static unsigned long CreatorUnaccelGeneration = 0;
-static int CreatorUnaccelWindowPrivateIndex;
-
-#define CreatorUnaccelGetWid(w) \
-	((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val)
-#define CreatorUnaccelSetWid(w,wid) \
-	(((w)->devPrivates[CreatorUnaccelWindowPrivateIndex].val) = (wid))
-
-static unsigned int
-CreatorWidGet(WindowPtr pWin)
-{
-	return CreatorUnaccelGetWid(pWin);
-}
-
-static Bool
-CreatorWidAlloc(WindowPtr pWin)
-{
-	ScreenPtr pScreen = pWin->drawable.pScreen;
-	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
-	unsigned int wid;
-	int i, visual, visclass;
-
-	visual = wVisual(pWin);
-	visclass = 0;
-	for (i = 0; i < pScreen->numVisuals; i++) {
-		if (pScreen->visuals[i].vid == visual) {
-			visclass = pScreen->visuals[i].class;
-			break;
-		}
-	}
-
-	wid = FFBWidAlloc(pFfb, visclass, wColormap(pWin), TRUE);
-	if (wid == (unsigned int) -1)
-		return FALSE;
-
-	CreatorUnaccelSetWid(pWin, wid);
-
-	return TRUE;
-}
-
-static void
-CreatorWidFree(WindowPtr pWin)
-{
-	ScrnInfoPtr pScrn = xf86Screens[pWin->drawable.pScreen->myNum];
-	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
-	unsigned int wid = CreatorUnaccelGetWid(pWin);
-
-	FFBWidFree(pFfb, wid);
-}
-
-static cfb8_32WidOps CreatorUnaccelWidOps = {
-	CreatorWidGet,
-	CreatorWidAlloc,
-	CreatorWidFree,
-	NULL,
-	NULL
-};
-
-static Bool
-CreatorUnaccelWidInit(ScreenPtr pScreen)
-{
-	if (serverGeneration != CreatorUnaccelGeneration) {
-		CreatorUnaccelWindowPrivateIndex =
-			AllocateWindowPrivateIndex();
-		if (CreatorUnaccelWindowPrivateIndex == -1)
-			return FALSE;
-	}
-
-	return TRUE;
-}
-
 /* Mandatory */
 
 /* This gets called at the start of each server generation */
@@ -674,10 +599,6 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     unsigned int afb_fem;
     VisualPtr visual;
 
-    /* Add in our Dbe hook. */
-    if (!FFBDbePreInit(pScreen))
-	return FALSE;
-
     /* 
      * First get the ScrnInfoRec
      */
@@ -797,11 +718,6 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     /* Darken the screen for aesthetic reasons and set the viewport */
     FFBSaveScreen(pScreen, SCREEN_SAVER_ON);
 
-    if (pFfb->NoAccel == TRUE) {
-	    if (!CreatorUnaccelWidInit(pScreen))
-		    return FALSE;
-    }
-
     /*
      * The next step is to setup the screen's visuals, and initialise the
      * framebuffer code.  In cases where the framebuffer's default
@@ -817,14 +733,14 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     miClearVisualTypes();
 
     /* Setup the visuals we support. */
-    if (!miSetVisualTypes(24, TrueColorMask | DirectColorMask,
+    if (!miSetVisualTypes(24, TrueColorMask,
 			  pScrn->rgbBits, TrueColor))
 	    return FALSE;
-    if (!miSetVisualTypes(8, PseudoColorMask | GrayScaleMask | StaticGrayMask,
-			  pScrn->rgbBits, PseudoColor))
-	    return FALSE;
 
-#ifdef XF86DRI
+    if (!miSetPixmapDepths())
+        return FALSE;
+
+#if 0 /*def XF86DRI*/
     if (pFfb->ffb_type != afb_m3 && pFfb->ffb_type != afb_m6 &&
 	pFfb->NoAccel == FALSE) {
 	    pFfb->dri_enabled = FFBDRIScreenInit(pScreen);
@@ -843,30 +759,14 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
      * Call the framebuffer layer's ScreenInit function, and fill in other
      * pScreen fields.
      */
-    if (pFfb->NoAccel == TRUE) {
-	    ret = cfb8_32WidScreenInit(pScreen, pFfb->dfb24, pFfb->dfb8r, pFfb->dfb8x,
-				       pScrn->virtualX, pScrn->virtualY,
-				       pScrn->xDpi, pScrn->yDpi,
-				       2048, 2048, 2048, 8,
-				       &CreatorUnaccelWidOps);
-    } else {
-	    /* Use smart framebuffer aperture for cfb8/cfb32. */
-	    ret = cfb8_32WidScreenInit(pScreen, pFfb->sfb32, pFfb->sfb8r, pFfb->dfb8x,
-				       pScrn->virtualX, pScrn->virtualY,
-				       pScrn->xDpi, pScrn->yDpi,
-				       2048, 2048, 2048, 8,
-				       &CreatorUnaccelWidOps);
-    }
+    ret = fbScreenInit(pScreen, (pFfb->NoAccel ? pFfb->dfb24 : pFfb->sfb32),
+		       pScrn->virtualX, pScrn->virtualY,
+		       pScrn->xDpi, pScrn->yDpi,
+		       2048, 32);
 
     if (!ret)
 	return FALSE;
 
-    miInitializeBackingStore(pScreen);
-    xf86SetBackingStore(pScreen);
-    xf86SetSilkenMouse(pScreen);
-
-    xf86SetBlackWhitePixels(pScreen);
-
     if (pScrn->bitsPerPixel > 8) {
         /* Fixup RGB ordering */
         visual = pScreen->visuals + pScreen->numVisuals;
@@ -882,12 +782,24 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
 	}
     }
 
+    if (!fbPictureInit(pScreen, NULL, 0) &&
+	(serverGeneration == 1))
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "RENDER extension initialisation failed.\n");
+
+    xf86SetBlackWhitePixels(pScreen);
+
     if (!pFfb->NoAccel) {
 	if (!FFBAccelInit(pScreen, pFfb))
 	    return FALSE;
 	xf86Msg(X_INFO, "%s: Using acceleration\n", pFfb->psdp->device);
     }
 
+
+    miInitializeBackingStore(pScreen);
+    xf86SetBackingStore(pScreen);
+    xf86SetSilkenMouse(pScreen);
+
     /* Initialise cursor functions */
     miDCInitialize (pScreen, xf86GetPointerScreenFuncs());
 
@@ -912,9 +824,6 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
      */
     if (!xf86HandleColormaps(pScreen, 256, 8,
 			     FFBDacLoadPalette, NULL,
-#if 0
-			     CMAP_PALETTED_TRUECOLOR |
-#endif
 			     CMAP_LOAD_EVEN_IF_OFFSCREEN |
 			     CMAP_RELOAD_ON_MODE_SWITCH))
 	return FALSE;
@@ -923,9 +832,9 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     if (!pFfb->NoAccel)
 	    FFB_InitDGA(pScreen);
 
-#ifdef XF86DRI
+#if 0 /*def XF86DRI*/
     if (pFfb->dri_enabled) {
-	    /* Now that mi, cfb, drm and others have done their thing, 
+	    /* Now that mi, fb, drm and others have done their thing, 
 	     * complete the DRI setup.
 	     */
 	    pFfb->dri_enabled = FFBDRIFinishScreenInit(pScreen);
@@ -938,6 +847,8 @@ FFBScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     }
 #endif
 
+    xf86DPMSInit(pScreen, FFBDPMSSet, 0);
+
     pFfb->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = FFBCloseScreen;
     pScreen->SaveScreen = FFBSaveScreen;
@@ -1034,34 +945,34 @@ FFBLeaveVT(int scrnIndex, int flags)
 static Bool
 FFBCloseScreen(int scrnIndex, ScreenPtr pScreen)
 {
-    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
-    FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
 
-#ifdef XF86DRI
-    if (pFfb->dri_enabled)
-	    FFBDRICloseScreen(pScreen);
+#if 0 /*def XF86DRI*/
+	if (pFfb->dri_enabled)
+		FFBDRICloseScreen(pScreen);
 #endif
 
-    /* Restore kernel ramdac state before we unmap registers. */
-    FFBDacFini(pFfb);
+	/* Restore kernel ramdac state before we unmap registers. */
+	FFBDacFini(pFfb);
 
-    pScrn->vtSema = FALSE;
+	pScrn->vtSema = FALSE;
 
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb24, 0x1000000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8r, 0x400000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8x, 0x400000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb32, 0x1000000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8r, 0x400000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8x, 0x400000);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->regs, 16384);
-    xf86UnmapSbusMem(pFfb->psdp, pFfb->dac, 8192);
-    xf86UnmapSbusMem(pFfb->psdp, (void *)pFfb->strapping_bits, 8192);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb24, 0x1000000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8r, 0x400000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->dfb8x, 0x400000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb32, 0x1000000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8r, 0x400000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->sfb8x, 0x400000);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->regs, 16384);
+	xf86UnmapSbusMem(pFfb->psdp, pFfb->dac, 8192);
+	xf86UnmapSbusMem(pFfb->psdp, (void *)pFfb->strapping_bits, 8192);
 
-    if (pFfb->HWCursor)
-	xf86SbusHideOsHwCursor (pFfb->psdp);
+	if (pFfb->HWCursor)
+		xf86SbusHideOsHwCursor (pFfb->psdp);
 
-    pScreen->CloseScreen = pFfb->CloseScreen;
-    return (*pScreen->CloseScreen)(scrnIndex, pScreen);
+	pScreen->CloseScreen = pFfb->CloseScreen;
+	return (*pScreen->CloseScreen)(scrnIndex, pScreen);
 }
 
 
@@ -1071,20 +982,20 @@ FFBCloseScreen(int scrnIndex, ScreenPtr pScreen)
 static void
 FFBFreeScreen(int scrnIndex, int flags)
 {
-    FFBFreeRec(xf86Screens[scrnIndex]);
+	FFBFreeRec(xf86Screens[scrnIndex]);
 }
 
 
 /* Checks if a mode is suitable for the selected chipset. */
 
 /* Optional */
-static int
+static ModeStatus
 FFBValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
 {
-    if (mode->Flags & V_INTERLACE)
-	return(MODE_BAD);
+	if (mode->Flags & V_INTERLACE)
+		return MODE_BAD;
 
-    return(MODE_OK);
+	return MODE_OK;
 }
 
 /* Do screen blanking */
@@ -1102,6 +1013,14 @@ FFBSaveScreen(ScreenPtr pScreen, int mode)
     return FFBDacSaveScreen(GET_FFB_FROM_SCREEN(pScreen), mode);
 }
 
+static void
+FFBDPMSSet(ScrnInfoPtr pScrn, int mode, int flags)
+{
+	FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
+
+	FFBDacDPMSMode(pFfb, mode, 0);
+}
+
 /*
  * This is the implementation of the Sync() function.
  */
diff --git a/src/ffb_rcache.h b/src/ffb_rcache.h
index 5beb23e..a9bac9b 100644
--- a/src/ffb_rcache.h
+++ b/src/ffb_rcache.h
@@ -23,7 +23,7 @@
  * IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_rcache.h,v 1.2 2000/05/23 04:47:45 dawes Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_rcache.h,v 1.1 2000/05/18 23:21:37 dawes Exp $ */
 
 #ifndef FFBRCACHE_H
 #define FFBRCACHE_H
@@ -41,13 +41,13 @@
  * a nice idea...
  */
 #define FFB_WRITE_PPC(__fpriv, __ffb, __val, __chg_mask) \
-do {	unsigned int oldval = (__fpriv)->ppc_cache; \
+do {	unsigned int __oldval = (__fpriv)->ppc_cache; \
 	unsigned int __t; \
-	__t = (oldval & (__chg_mask)) ^ (__val); \
+	__t = (__oldval & (__chg_mask)) ^ (__val); \
 	if (__t) { \
-		unsigned int newval = oldval & ~(__chg_mask); \
-		newval |= (__val); \
-		(__fpriv)->ppc_cache = newval; \
+		unsigned int __newval = __oldval & ~(__chg_mask); \
+		__newval |= (__val); \
+		(__fpriv)->ppc_cache = __newval; \
 		FFBFifo((__fpriv), 1); \
 		(__ffb)->ppc = (__val); \
 	} \
@@ -178,22 +178,22 @@ extern void __FFB_Attr_FastfillWin(FFBPtr pFfb, WindowPtr pWin,
 #define FFB_ATTR_FFWIN(__fpriv, __pwin, __ppc, __pixel) \
 do {	CreatorPrivWinPtr __winpriv = CreatorGetWindowPrivate(__pwin);	\
 	unsigned int ___ppc = (__ppc) | FFB_PPC_XS_WID;			\
-	unsigned int fbc = (__winpriv)->fbc_base; \
-	unsigned int rop = (FFB_ROP_NEW|(FFB_ROP_NEW<<8)); \
+	unsigned int __fbc = (__winpriv)->fbc_base; \
+	unsigned int __rop = (FFB_ROP_NEW|(FFB_ROP_NEW<<8)); \
 	if((__fpriv)->has_double_buffer) { \
-		fbc &= ~FFB_FBC_WB_MASK; \
-		fbc |= FFB_FBC_WB_AB; \
+		__fbc &= ~FFB_FBC_WB_MASK; \
+		__fbc |= FFB_FBC_WB_AB; \
 	} \
-	fbc &= ~(FFB_FBC_XE_MASK | FFB_FBC_RGBE_MASK); \
-	fbc |= FFB_FBC_XE_ON | FFB_FBC_RGBE_ON; \
+	__fbc &= ~(FFB_FBC_XE_MASK | FFB_FBC_RGBE_MASK); \
+	__fbc |= FFB_FBC_XE_ON | FFB_FBC_RGBE_ON; \
 	if (pFfb->ffb_res == ffb_res_high) \
-		fbc |= FFB_FBC_WB_B; \
+		__fbc |= FFB_FBC_WB_B; \
 	if ((((__fpriv)->ppc_cache & FFB_PPC_WINMASK) != (___ppc))||	\
 	    ((__fpriv)->pmask_cache != 0x00ffffff)		||	\
-	    ((__fpriv)->rop_cache!= rop)			||	\
+	    ((__fpriv)->rop_cache!= __rop)			||	\
 	    ((__fpriv)->drawop_cache != FFB_DRAWOP_FASTFILL)	||	\
 	    ((__fpriv)->fg_cache != (__pixel))			||	\
-	    ((__fpriv)->fbc_cache != fbc)			||	\
+	    ((__fpriv)->fbc_cache != __fbc)			||	\
 	    ((__fpriv)->wid_cache != ((__winpriv)->wid)))		\
 		__FFB_Attr_FastfillWin(__fpriv, __pwin, ___ppc, __pixel);\
 } while (0)
@@ -215,29 +215,29 @@ do {	CreatorPrivWinPtr __winpriv = CreatorGetWindowPrivate(__pwin);	\
 				 FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF | FFB_FBC_RGBE_ON)
 
 #define FFB_ATTR_SFB_VAR_WINCOPY(__fpriv) \
-do {	unsigned int ppc = FFB_PPC_WINCOPY; \
-	unsigned int ppc_mask = FFB_PPC_WINCOPY_MASK; \
-	unsigned int rop = FFB_ROP_NEW|(FFB_ROP_NEW<<8); \
-	unsigned int fbc = FFB_FBC_WINCOPY; \
+do {	unsigned int __ppc = FFB_PPC_WINCOPY; \
+	unsigned int __ppc_mask = FFB_PPC_WINCOPY_MASK; \
+	unsigned int __rop = FFB_ROP_NEW|(FFB_ROP_NEW<<8); \
+	unsigned int __fbc = FFB_FBC_WINCOPY; \
 	if((__fpriv)->has_double_buffer) { \
-		fbc &= ~FFB_FBC_WB_MASK; \
-		fbc |= FFB_FBC_WB_AB; \
+		__fbc &= ~FFB_FBC_WB_MASK; \
+		__fbc |= FFB_FBC_WB_AB; \
 	} \
-	if (((__fpriv)->ppc_cache & ppc_mask) != ppc || \
-	    (__fpriv)->fbc_cache != fbc || \
-	    (__fpriv)->rop_cache != rop || \
+	if (((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+	    (__fpriv)->fbc_cache != __fbc || \
+	    (__fpriv)->rop_cache != __rop || \
 	    (__fpriv)->pmask_cache != 0xffffffff) { \
 		ffb_fbcPtr __ffb = (__fpriv)->regs; \
-		(__fpriv)->ppc_cache &= ~ppc_mask; \
-		(__fpriv)->ppc_cache |= ppc; \
-		(__fpriv)->fbc_cache = fbc; \
-		(__fpriv)->rop_cache = rop; \
+		(__fpriv)->ppc_cache &= ~__ppc_mask; \
+		(__fpriv)->ppc_cache |= __ppc; \
+		(__fpriv)->fbc_cache = __fbc; \
+		(__fpriv)->rop_cache = __rop; \
 		(__fpriv)->pmask_cache = 0xffffffff; \
 		(__fpriv)->rp_active = 1; \
 		FFBFifo(__fpriv, 4); \
-		(__ffb)->ppc = ppc; \
-		(__ffb)->fbc = fbc; \
-		(__ffb)->rop = rop; \
+		(__ffb)->ppc = __ppc; \
+		(__ffb)->fbc = __fbc; \
+		(__ffb)->rop = __rop; \
 		(__ffb)->pmask = 0xffffffff; \
 		(__fpriv)->rp_active = 1; \
 	} \
@@ -247,21 +247,21 @@ extern void __FFB_Attr_SFB_VAR(FFBPtr pFfb, unsigned int ppc, unsigned int ppc_m
 			       unsigned int wid, unsigned int rop, unsigned int pmask);
 
 #define FFB_ATTR_SFB_VAR_WIN(__fpriv, __pmask, __alu, __pwin) \
-do {	unsigned int ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
-	unsigned int ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
-	unsigned int rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
-	unsigned int fbc = FFB_FBC_WIN(__pwin); \
+do {	unsigned int __ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
+	unsigned int __ppc_mask = FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK; \
+	unsigned int __rop = (FFB_ROP_EDIT_BIT | (__alu))|(FFB_ROP_NEW<<8); \
+	unsigned int __fbc = FFB_FBC_WIN(__pwin); \
 	if((__fpriv)->has_double_buffer) { \
-		fbc &= ~FFB_FBC_WB_MASK; \
-		fbc |= FFB_FBC_WB_AB; \
+		__fbc &= ~FFB_FBC_WB_MASK; \
+		__fbc |= FFB_FBC_WB_AB; \
 	} \
-	if(((__fpriv)->ppc_cache & ppc_mask) != ppc || \
-	   (__fpriv)->fbc_cache != fbc || \
+	if(((__fpriv)->ppc_cache & __ppc_mask) != __ppc || \
+	   (__fpriv)->fbc_cache != __fbc || \
 	   (__fpriv)->wid_cache != FFB_WID_WIN(__pwin) || \
-	   (__fpriv)->rop_cache != rop || \
+	   (__fpriv)->rop_cache != __rop || \
 	   (__fpriv)->pmask_cache != (__pmask)) \
-		__FFB_Attr_SFB_VAR(__fpriv, ppc, ppc_mask, fbc, \
-				   FFB_WID_WIN(__pwin), rop, (__pmask)); \
+		__FFB_Attr_SFB_VAR(__fpriv, __ppc, __ppc_mask, __fbc, \
+				   FFB_WID_WIN(__pwin), __rop, (__pmask)); \
 } while(0)
 
 /* VSCROLL Attributes:
@@ -277,25 +277,25 @@ do {	unsigned int ppc = FFB_PPC_APE_DISABLE | FFB_PPC_CS_VAR | FFB_PPC_XS_WID; \
  * PMASK) all options allowed
  */
 #define FFB_ATTR_VSCROLL_WINCOPY(__fpriv) \
-do {	unsigned int rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
-	unsigned int fbc = FFB_FBC_WINCOPY; \
+do {	unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+	unsigned int __fbc = FFB_FBC_WINCOPY; \
 	if((__fpriv)->has_double_buffer) { \
-		fbc &= ~FFB_FBC_WB_MASK; \
-		fbc |= FFB_FBC_WB_AB; \
+		__fbc &= ~FFB_FBC_WB_MASK; \
+		__fbc |= FFB_FBC_WB_AB; \
 	} \
-	if((__fpriv)->fbc_cache != fbc || \
-	   (__fpriv)->rop_cache != rop || \
+	if((__fpriv)->fbc_cache != __fbc || \
+	   (__fpriv)->rop_cache != __rop || \
 	   (__fpriv)->pmask_cache != 0xffffffff || \
 	   (__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
 		ffb_fbcPtr __ffb = (__fpriv)->regs; \
-		(__fpriv)->fbc_cache = fbc; \
-		(__fpriv)->rop_cache = rop; \
+		(__fpriv)->fbc_cache = __fbc; \
+		(__fpriv)->rop_cache = __rop; \
 		(__fpriv)->pmask_cache = 0xffffffff; \
 		(__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
 		(__fpriv)->rp_active = 1; \
 		FFBFifo(__fpriv, 4); \
-		(__ffb)->fbc = fbc; \
-		(__ffb)->rop = rop; \
+		(__ffb)->fbc = __fbc; \
+		(__ffb)->rop = __rop; \
 		(__ffb)->pmask = 0xffffffff; \
 		(__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
 		(__fpriv)->rp_active = 1; \
@@ -303,25 +303,25 @@ do {	unsigned int rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
 } while(0)
 
 #define FFB_ATTR_VSCROLL_WIN(__fpriv, __pmask, __pwin) \
-do {	unsigned int rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
-	unsigned int fbc = FFB_FBC_WIN(__pwin); \
+do {	unsigned int __rop = (FFB_ROP_OLD | (FFB_ROP_OLD << 8)); \
+	unsigned int __fbc = FFB_FBC_WIN(__pwin); \
 	if((__fpriv)->has_double_buffer) { \
-		fbc &= ~FFB_FBC_WB_MASK; \
-		fbc |= FFB_FBC_WB_AB; \
+		__fbc &= ~FFB_FBC_WB_MASK; \
+		__fbc |= FFB_FBC_WB_AB; \
 	} \
-	if((__fpriv)->fbc_cache != fbc || \
-	   (__fpriv)->rop_cache != rop || \
+	if((__fpriv)->fbc_cache != __fbc || \
+	   (__fpriv)->rop_cache != __rop || \
 	   (__fpriv)->pmask_cache != (__pmask) || \
 	   (__fpriv)->drawop_cache != FFB_DRAWOP_VSCROLL) { \
 		ffb_fbcPtr __ffb = (__fpriv)->regs; \
-		(__fpriv)->fbc_cache = fbc; \
-		(__fpriv)->rop_cache = rop; \
+		(__fpriv)->fbc_cache = __fbc; \
+		(__fpriv)->rop_cache = __rop; \
 		(__fpriv)->pmask_cache = (__pmask); \
 		(__fpriv)->drawop_cache = FFB_DRAWOP_VSCROLL; \
 		(__fpriv)->rp_active = 1; \
 		FFBFifo(__fpriv, 4); \
-		(__ffb)->fbc = fbc; \
-		(__ffb)->rop = rop; \
+		(__ffb)->fbc = __fbc; \
+		(__ffb)->rop = __rop; \
 		(__ffb)->pmask = (__pmask); \
 		(__ffb)->drawop = FFB_DRAWOP_VSCROLL; \
 	} \
diff --git a/src/ffb_regs.h b/src/ffb_regs.h
index 7f383d3..efb5cce 100644
--- a/src/ffb_regs.h
+++ b/src/ffb_regs.h
@@ -24,7 +24,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  */
-/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_regs.h,v 1.1 2000/05/18 23:21:37 dawes Exp $ */
+/* $XFree86$ */
 
 #ifndef FFBREGS_H
 #define FFBREGS_H
@@ -432,6 +432,19 @@ typedef struct _ffb_fbc {
 #define FFB_MER_EDRA		0x000000c0 /* Enable read-ahead, decreasing */
 #define FFB_MER_DRA		0x00000040 /* No read-ahead */
 
+/* Alpha Blend Control */
+#define FFB_BLENDC_FORCE_ONE	0x00000010 /* Defines 0xff as 1.0 */
+#define FFB_BLENDC_DF_MASK	0x0000000c /* Destination Frac Mask */
+#define FFB_BLENDC_DF_ZERO	0x00000000 /* Destination Frac: 0.00 */
+#define FFB_BLENDC_DF_ONE	0x00000004 /* Destination Frac: 1.00 */
+#define FFB_BLENDC_DF_ONE_M_A	0x00000008 /* Destination Frac: 1.00 - Xsrc */
+#define FFB_BLENDC_DF_A		0x0000000c /* Destination Frac: Xsrc */
+#define FFB_BLENDC_SF_MASK	0x00000003 /* Source Frac Mask */
+#define FFB_BLENDC_SF_ZERO	0x00000000 /* Source Frac: 0.00 */
+#define FFB_BLENDC_SF_ONE	0x00000001 /* Source Frac: 1.00 */
+#define FFB_BLENDC_SF_ONE_M_A	0x00000002 /* Source Frac: 1.00 - Xsrc */
+#define FFB_BLENDC_SF_A		0x00000003 /* Source Frac: Xsrc */
+
 /* FBram Config 0 */
 #define FFB_FBCFG0_RFTIME	0xff800000
 #define FFB_FBCFG0_XMAX		0x007c0000