Initial revisionXORG-STABLE

1 files changed, 753 insertions, 0 deletions

diff --git a/src/apm_accel.c b/src/apm_accel.c
new file mode 100644
index 0000000..72b0cee
--- /dev/null
+++ b/src/apm_accel.c
@@ -0,0 +1,753 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/apm/apm_accel.c,v 1.21 2002/10/08 22:14:03 tsi Exp $ */
+
+#include "apm.h"
+#include "miline.h"
+
+/* Defines */
+#define MAXLOOP 1000000
+
+/* Translation from X ROP's to APM ROP's. */
+static unsigned char apmROP[] = {
+  0,
+  0x88,
+  0x44,
+  0xCC,
+  0x22,
+  0xAA,
+  0x66,
+  0xEE,
+  0x11,
+  0x99,
+  0x55,
+  0xDD,
+  0x33,
+  0xBB,
+  0x77,
+  0xFF
+};
+
+
+#include "apm_funcs.c"
+
+#define IOP_ACCESS
+#include "apm_funcs.c"
+
+#define PSZ	24
+#include "apm_funcs.c"
+
+#define PSZ	24
+#define IOP_ACCESS
+#include "apm_funcs.c"
+
+static void
+ApmRemoveStipple(FBAreaPtr area)
+{
+    ((struct ApmStippleCacheRec *)area->devPrivate.ptr)->apmStippleCached = FALSE;
+}
+
+static void
+ApmMoveStipple(FBAreaPtr from, FBAreaPtr to)
+{
+    struct ApmStippleCacheRec *pApm = (struct ApmStippleCacheRec *)to->devPrivate.ptr;
+
+    pApm->apmStippleCache.x = to->box.x1;
+    pApm->apmStippleCache.y += to->box.y1 - from->box.y1;
+    /* TODO : move data */
+}
+
+/*
+ * ApmCacheMonoStipple
+ * because my poor AT3D needs stipples stored linearly in memory.
+ */
+static XAACacheInfoPtr
+ApmCacheMonoStipple(ScrnInfoPtr pScrn, PixmapPtr pPix)
+{
+    APMDECL(pScrn);
+    int		w = pPix->drawable.width, W = (w + 31) & ~31;
+    int		h = pPix->drawable.height;
+    int		i, j, dwords, mem, width, funcNo;
+    FBAreaPtr	draw;
+    struct ApmStippleCacheRec	*pCache;
+    unsigned char	*srcPtr;
+    CARD32		*dstPtr;
+
+    for (i = 0; i < APM_CACHE_NUMBER; i++)
+	if ((pApm->apmCache[i].apmStippleCache.serialNumber == pPix->drawable.serialNumber)
+		&& pApm->apmCache[i].apmStippleCached &&
+		(pApm->apmCache[i].apmStippleCache.fg == -1) &&
+		(pApm->apmCache[i].apmStippleCache.bg == -1)) {
+	    pApm->apmCache[i].apmStippleCache.trans_color = -1;
+	    return &pApm->apmCache[i].apmStippleCache;
+	}
+    if ((i = ++pApm->apmCachePtr) >= APM_CACHE_NUMBER)
+	i = pApm->apmCachePtr = 0;
+    pCache = &pApm->apmCache[i];
+    if (pCache->apmStippleCached) {
+	pCache->apmStippleCached = FALSE;
+	xf86FreeOffscreenArea(pCache->area);
+    }
+
+    draw = xf86AllocateLinearOffscreenArea(pApm->pScreen, (W * h + 7) / 8,
+				    (pApm->CurrentLayout.mask32 + 1) << 1,
+				    ApmMoveStipple, ApmRemoveStipple, pCache);
+    if (!draw)
+	return NULL;	/* Let's hope this will never happen... */
+
+    pCache->area = draw;
+    pCache->apmStippleCache.serialNumber = pPix->drawable.serialNumber;
+    pCache->apmStippleCache.trans_color =
+	pCache->apmStippleCache.bg =
+	pCache->apmStippleCache.fg = -1;
+    pCache->apmStippleCache.orig_w = w;
+    pCache->apmStippleCache.orig_h = h;
+    pCache->apmStippleCache.x = draw->box.x1;
+    pCache->apmStippleCache.y = draw->box.y1 + ((pCache - pApm->apmCache) + 1) * pApm->CurrentLayout.Scanlines;
+    mem = ((draw->box.x2 - draw->box.x1) * (draw->box.y2 - draw->box.y1) *
+			pScrn->bitsPerPixel) / (W * h);
+    width = 2;
+    while (width * width <= mem)
+	width++;
+    width--;
+    pCache->apmStippleCache.w = (width * W + pScrn->bitsPerPixel - 1) /
+			pScrn->bitsPerPixel;
+    pCache->apmStippleCache.h = ((draw->box.x2 - draw->box.x1) *
+			(draw->box.y2 - draw->box.y1)) /
+			pCache->apmStippleCache.w;
+    pCache->apmStippleCached = TRUE;
+
+    if (w < 32) {
+	if (w & (w - 1))	funcNo = 1;
+	else			funcNo = 0;
+    } else			funcNo = 2;
+
+    dstPtr = ((CARD32 *)pApm->FbBase) + (draw->box.x1 +
+			draw->box.y1*pApm->CurrentLayout.bytesPerScanline) / 4;
+    j = 0;
+    dwords = (pCache->apmStippleCache.w * pScrn->bitsPerPixel) / 32;
+    while (j + h <= pCache->apmStippleCache.h) {
+	srcPtr = (unsigned char *)pPix->devPrivate.ptr;
+	for (i = h; --i >= 0; ) {
+	    (*XAAStippleScanlineFuncMSBFirst[funcNo])(dstPtr, (CARD32 *)srcPtr, 0, w, dwords);
+	    srcPtr += pPix->devKind;
+	    dstPtr += dwords;
+	}
+	j += h;
+    }
+    srcPtr = (unsigned char *)pPix->devPrivate.ptr;
+    for (i = pCache->apmStippleCache.h - j ; --i >= 0; ) {
+	(*XAAStippleScanlineFuncMSBFirst[funcNo])(dstPtr, (CARD32 *)srcPtr, 0, w, dwords);
+	srcPtr += pPix->devKind;
+	dstPtr += dwords;
+    }
+
+    return &pCache->apmStippleCache;
+}
+
+#if 0
+extern GCOps XAAPixmapOps;
+static RegionPtr (*SaveCopyAreaPixmap)(DrawablePtr, DrawablePtr, GC *, int, int, int, int, int, int);
+
+static RegionPtr
+ApmCopyAreaPixmap(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GC *pGC,
+		int srcx, int srcy,
+		int width, int height,
+		int dstx, int dsty )
+{
+    register int Scanlines;
+    int is;
+    int id;
+    int sx = 0, sy = 0, dx = 0, dy = 0, pitch;
+    RegionPtr pReg;
+
+    if (APMPTR(xf86Screens[(pGC)->pScreen->myNum])->Chipset == AT3D) {
+	Scanlines = APMPTR(xf86Screens[(pGC)->pScreen->myNum])->CurrentLayout.Scanlines;
+	is = (pSrcDrawable->type == DRAWABLE_PIXMAP) ? APM_GET_PIXMAP_PRIVATE(pSrcDrawable)->num : 0;
+	id = (pDstDrawable->type == DRAWABLE_PIXMAP) ? APM_GET_PIXMAP_PRIVATE(pDstDrawable)->num : 0;
+	if (is) {
+	    sx = pSrcDrawable->x;
+	    sy = pSrcDrawable->y % Scanlines;
+	    pitch = 2 * pSrcDrawable->width;
+	    pSrcDrawable->x = (sx + ((PixmapPtr)pSrcDrawable)->devKind * sy) % pitch;
+	    pSrcDrawable->y = (sx + ((PixmapPtr)pSrcDrawable)->devKind * sy) / pitch;
+	    ((PixmapPtr)pSrcDrawable)->devKind = pitch;
+	    pSrcDrawable->depth = 16;
+	}
+	if (id) {
+	    dx = pDstDrawable->x;
+	    dy = pDstDrawable->y % Scanlines;
+	    pitch = 2 * pDstDrawable->width;
+	    pDstDrawable->x = (dx + ((PixmapPtr)pDstDrawable)->devKind * dy) % pitch;
+	    pDstDrawable->y = (dx + ((PixmapPtr)pDstDrawable)->devKind * dy) / pitch;
+	    ((PixmapPtr)pDstDrawable)->devKind = pitch;
+	    pDstDrawable->depth = 16;
+	}
+	pReg = (*SaveCopyAreaPixmap)(pSrcDrawable, pDstDrawable, pGC,
+					    srcx, srcy % Scanlines,
+					    width, height,
+					    dstx, dsty % Scanlines);
+	if (is) {
+	    pSrcDrawable->x = sx;
+	    pSrcDrawable->y = sy + is * Scanlines;
+	}
+	if (id) {
+	    pDstDrawable->x = dx;
+	    pDstDrawable->y = dy + id * Scanlines;
+	}
+	return pReg;
+    }
+    return (*SaveCopyAreaPixmap)(pSrcDrawable, pDstDrawable, pGC,
+					srcx, srcy,
+					width, height,
+					dstx, dsty);
+}
+#endif
+
+void ApmAccelReserveSpace(ApmPtr pApm)
+{
+    memType	mem, ScratchMemOffset;
+
+    mem			= xf86Screens[pApm->pScreen->myNum]->videoRam << 10;
+    /*
+     * Reserve at least four lines for mono to color expansion
+     */
+    ScratchMemOffset	= ((mem - pApm->OffscreenReserved) /
+			pApm->CurrentLayout.bytesPerScanline - 4) *
+			pApm->CurrentLayout.bytesPerScanline;
+    pApm->ScratchMemSize= mem - ScratchMemOffset - pApm->OffscreenReserved;
+    pApm->ScratchMemPtr	= pApm->ScratchMemOffset
+			= (memType)pApm->FbBase + ScratchMemOffset;
+    pApm->ScratchMemEnd	= (memType)pApm->FbBase + mem - pApm->OffscreenReserved;
+}
+
+/*********************************************************************************************/
+
+int
+ApmAccelInit(ScreenPtr pScreen)
+{
+    ScrnInfoPtr		pScrn = xf86Screens[pScreen->myNum];
+    APMDECL(pScrn);
+    XAAInfoRecPtr	pXAAinfo;
+    BoxRec		AvailFBArea;
+    memType		mem, ScratchMemOffset;
+    int			i, stat;
+
+    pApm->AccelInfoRec	= pXAAinfo = XAACreateInfoRec();
+    if (!pXAAinfo)
+	return FALSE;
+
+    mem			= pScrn->videoRam << 10;
+    ScratchMemOffset	= pApm->ScratchMemOffset - (memType)pApm->FbBase;
+    switch (pApm->CurrentLayout.bitsPerPixel) {
+    case 8:
+    case 24:
+	pApm->ScratchMemWidth =
+		(mem - ScratchMemOffset - pApm->OffscreenReserved) / 1;
+	pApm->ScratchMem =
+		((ScratchMemOffset & 0xFFF000) << 4) |
+		    (ScratchMemOffset & 0xFFF);
+	break;
+
+    case 16:
+	pApm->ScratchMemWidth =
+		(mem - ScratchMemOffset - pApm->OffscreenReserved) / 2;
+	pApm->ScratchMem =
+		((ScratchMemOffset & 0xFFE000) << 3) |
+		    ((ScratchMemOffset & 0x1FFE) >> 1);
+	break;
+
+    case 32:
+	pApm->ScratchMemWidth =
+		(mem - ScratchMemOffset - pApm->OffscreenReserved) / 4;
+	pApm->ScratchMem =
+		((ScratchMemOffset & 0xFFC000) << 2) |
+		    ((ScratchMemOffset & 0x3FFC) >> 2);
+	break;
+    }
+    pApm->OffscreenReserved = mem - ScratchMemOffset;
+
+    /*
+     * Abort
+     */
+    if (pApm->Chipset == AP6422)
+	i = 4;
+    else
+	i = 8;
+    if (pApm->noLinear) {
+	stat = RDXL_IOP(0x1FC);
+	while ((stat & (STATUS_HOSTBLTBUSY | STATUS_ENGINEBUSY)) ||
+		((stat & STATUS_FIFO) < i)) {
+	    WRXB_IOP(0x1FC, 0);
+	    stat = RDXL_IOP(0x1FC);
+	}
+    }
+    else {
+	stat = RDXL_M(0x1FC);
+	while ((stat & (STATUS_HOSTBLTBUSY | STATUS_ENGINEBUSY)) ||
+		((stat & STATUS_FIFO) < i)) {
+	    WRXB_M(0x1FC, 0);
+	    stat = RDXL_M(0x1FC);
+	}
+    }
+
+    /* Setup current register values */
+    for (i = 0; i < sizeof(pApm->regcurr) / 4; i++)
+	((CARD32 *)curr)[i] = RDXL(0x30 + 4*i);
+
+    SETCLIP_CTRL(1);
+    SETCLIP_CTRL(0);
+    SETBYTEMASK(0x00);
+    SETBYTEMASK(0xFF);
+    SETROP(ROP_S_xor_D);
+    SETROP(ROP_S);
+
+#if 0
+    if (XAAPixmapOps.CopyArea != ApmCopyAreaPixmap) {
+	SaveCopyAreaPixmap = XAAPixmapOps.CopyArea;
+	XAAPixmapOps.CopyArea = ApmCopyAreaPixmap;
+    }
+#endif
+
+    ApmSetupXAAInfo(pApm, pXAAinfo);
+
+    if (!pApm->noLinear) {
+	pApm->SetupForSolidFill			= ApmSetupForSolidFill;
+	pApm->SubsequentSolidFillRect		= ApmSubsequentSolidFillRect;
+	pApm->SetupForSolidFill24		= ApmSetupForSolidFill24;
+	pApm->SubsequentSolidFillRect24		= ApmSubsequentSolidFillRect24;
+	pApm->SetupForScreenToScreenCopy	= ApmSetupForScreenToScreenCopy;
+	pApm->SubsequentScreenToScreenCopy	= ApmSubsequentScreenToScreenCopy;
+	pApm->SetupForScreenToScreenCopy24	= ApmSetupForScreenToScreenCopy24;
+	pApm->SubsequentScreenToScreenCopy24	= ApmSubsequentScreenToScreenCopy24;
+    }
+    else {
+	pApm->SetupForSolidFill			= ApmSetupForSolidFill_IOP;
+	pApm->SubsequentSolidFillRect		= ApmSubsequentSolidFillRect_IOP;
+	pApm->SetupForSolidFill24		= ApmSetupForSolidFill24_IOP;
+	pApm->SubsequentSolidFillRect24		= ApmSubsequentSolidFillRect24_IOP;
+	pApm->SetupForScreenToScreenCopy	= ApmSetupForScreenToScreenCopy_IOP;
+	pApm->SubsequentScreenToScreenCopy	= ApmSubsequentScreenToScreenCopy_IOP;
+	pApm->SetupForScreenToScreenCopy24	= ApmSetupForScreenToScreenCopy24_IOP;
+	pApm->SubsequentScreenToScreenCopy24	= ApmSubsequentScreenToScreenCopy24_IOP;
+    }
+
+    /*
+     * Init Rush extension.
+     * Must be initialized once per generation.
+     */
+#ifdef XF86RUSH_EXT
+    if (!pApm->CreatePixmap) {
+	pApm->CreatePixmap	= pScreen->CreatePixmap;
+	pApm->DestroyPixmap	= pScreen->DestroyPixmap;
+    }
+    XFree86RushExtensionInit(pScreen);
+#endif
+
+    /* Pixmap cache setup */
+    pXAAinfo->CachePixelGranularity = (pApm->CurrentLayout.mask32 + 1) << 1;
+    AvailFBArea.x1 = 0;
+    AvailFBArea.y1 = 0;
+    AvailFBArea.x2 = pScrn->displayWidth;
+    AvailFBArea.y2 = (pScrn->videoRam * 1024 - pApm->OffscreenReserved) /
+	(pScrn->displayWidth * ((pScrn->bitsPerPixel + 7) >> 3));
+
+    xf86InitFBManager(pScreen, &AvailFBArea);
+
+    bzero(pApm->apmCache, sizeof pApm->apmCache);
+
+    return XAAInit(pScreen, pXAAinfo);
+}
+
+void ApmSetupXAAInfo(ApmPtr pApm, XAAInfoRecPtr pXAAinfo)
+{
+    pApm->CurrentLayout.Setup_DEC = 0;
+    switch(pApm->CurrentLayout.bitsPerPixel)
+    {
+      case 8:
+           pApm->CurrentLayout.Setup_DEC |= DEC_BITDEPTH_8;
+           break;
+      case 16:
+           pApm->CurrentLayout.Setup_DEC |= DEC_BITDEPTH_16;
+           break;
+      case 24:
+	   /* Note : in 24 bpp, the accelerator wants linear coordinates */
+           pApm->CurrentLayout.Setup_DEC |= DEC_BITDEPTH_24 | DEC_SOURCE_LINEAR |
+				   DEC_DEST_LINEAR;
+           break;
+      case 32:
+           pApm->CurrentLayout.Setup_DEC |= DEC_BITDEPTH_32;
+           break;
+      default:
+           xf86DrvMsg(xf86Screens[pApm->pScreen->myNum]->scrnIndex, X_WARNING,
+		    "Cannot set up drawing engine control for bpp = %d\n",
+		    pApm->CurrentLayout.bitsPerPixel);
+           break;
+    }
+
+    switch(pApm->CurrentLayout.displayWidth)
+    {
+      case 640:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_640;
+           break;
+      case 800:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_800;
+           break;
+      case 1024:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_1024;
+           break;
+      case 1152:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_1152;
+           break;
+      case 1280:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_1280;
+           break;
+      case 1600:
+           pApm->CurrentLayout.Setup_DEC |= DEC_WIDTH_1600;
+           break;
+      default:
+           xf86DrvMsg(xf86Screens[pApm->pScreen->myNum]->scrnIndex, X_WARNING,
+		       "Cannot set up drawing engine control "
+		       "for screen width = %d\n", pApm->CurrentLayout.displayWidth);
+           break;
+    }
+
+    if (!pXAAinfo)
+	return;
+
+    /*
+     * Set up the main acceleration flags.
+     */
+    pXAAinfo->Flags = PIXMAP_CACHE | LINEAR_FRAMEBUFFER | OFFSCREEN_PIXMAPS;
+    pXAAinfo->CacheMonoStipple = ApmCacheMonoStipple;
+
+    if (pApm->CurrentLayout.bitsPerPixel != 24) {
+	if (!pApm->noLinear) {
+#define	XAA(s)		pXAAinfo->s = Apm##s
+	    if (pApm->Chipset < AT24)
+		pXAAinfo->Sync = ApmSync6422;
+	    else
+		XAA(Sync);
+
+	    /* Accelerated filled rectangles */
+	    pXAAinfo->SolidFillFlags = NO_PLANEMASK;
+	    XAA(SetupForSolidFill);
+	    XAA(SubsequentSolidFillRect);
+
+	    /* Accelerated screen to screen color expansion */
+	    pXAAinfo->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenColorExpandFill);
+	    XAA(SubsequentScreenToScreenColorExpandFill);
+
+#if 0
+	    The constraints of the transfer range are incompatible with the
+	    XAA architecture. I rewrote the XAA functions using ImageWrite
+	    /* Accelerated CPU to screen color expansion */
+	    if ((pApm->Chipset == AT24 && pApm->ChipRev >= 4) ||
+		    pApm->Chipset == AT3D) {
+		pXAAinfo->CPUToScreenColorExpandFillFlags =
+		  NO_PLANEMASK | SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD
+		  | BIT_ORDER_IN_BYTE_MSBFIRST | LEFT_EDGE_CLIPPING |
+		  LEFT_EDGE_CLIPPING_NEGATIVE_X | SYNC_AFTER_COLOR_EXPAND;
+		XAA(SetupForCPUToScreenColorExpandFill);
+		XAA(SubsequentCPUToScreenColorExpandFill);
+		pXAAinfo->ColorExpandBase	= pApm->BltMap;
+		pXAAinfo->ColorExpandRange	= (pApm->Chipset >= AT3D) ? 32*1024 : 30*1024;
+	    }
+
+	    /* Accelerated image transfers */
+	    pXAAinfo->ImageWriteFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X |
+			    SYNC_AFTER_IMAGE_WRITE;
+	    pXAAinfo->ImageWriteBase	= pApm->BltMap;
+	    pXAAinfo->ImageWriteRange	= (pApm->Chipset >= AT3D) ? 32*1024 : 30*1024;
+	    XAA(SetupForImageWrite);
+	    XAA(SubsequentImageWriteRect);
+#endif
+	    pXAAinfo->WritePixmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(WritePixmap);
+	    pXAAinfo->FillImageWriteRectsFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(FillImageWriteRects);
+	    pXAAinfo->WriteBitmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X |
+			    BIT_ORDER_IN_BYTE_LSBFIRST;
+	    XAA(WriteBitmap);
+	    pXAAinfo->TEGlyphRendererFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(TEGlyphRenderer);
+
+	    /* Accelerated screen-screen bitblts */
+	    pXAAinfo->ScreenToScreenCopyFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenCopy);
+	    XAA(SubsequentScreenToScreenCopy);
+
+	    /* Accelerated Line drawing */
+	    pXAAinfo->SolidLineFlags = NO_PLANEMASK | HARDWARE_CLIP_LINE;
+	    XAA(SetClippingRectangle);
+	    pXAAinfo->SolidBresenhamLineErrorTermBits = 15;
+
+	    if (pApm->Chipset >= AT24) {
+		XAA(SubsequentSolidBresenhamLine);
+
+		/* Pattern fill */
+		pXAAinfo->Mono8x8PatternFillFlags = NO_PLANEMASK |
+				HARDWARE_PATTERN_PROGRAMMED_BITS |
+				HARDWARE_PATTERN_SCREEN_ORIGIN;
+		XAA(SetupForMono8x8PatternFill);
+		XAA(SubsequentMono8x8PatternFillRect);
+		if (pApm->CurrentLayout.bitsPerPixel == 8) {
+		    pXAAinfo->Color8x8PatternFillFlags = NO_PLANEMASK |
+				    HARDWARE_PATTERN_SCREEN_ORIGIN;
+		    XAA(SetupForColor8x8PatternFill);
+		    XAA(SubsequentColor8x8PatternFillRect);
+		}
+	    }
+	    else
+		pXAAinfo->SubsequentSolidBresenhamLine =
+		    ApmSubsequentSolidBresenhamLine6422;
+#undef XAA
+	}
+	else {
+#define	XAA(s)		pXAAinfo->s = Apm##s##_IOP
+	    if (pApm->Chipset < AT24)
+		pXAAinfo->Sync = ApmSync6422_IOP;
+	    else
+		XAA(Sync);
+
+	    /* Accelerated filled rectangles */
+	    pXAAinfo->SolidFillFlags = NO_PLANEMASK;
+	    XAA(SetupForSolidFill);
+	    XAA(SubsequentSolidFillRect);
+
+	    /* Accelerated screen to screen color expansion */
+	    pXAAinfo->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenColorExpandFill);
+	    XAA(SubsequentScreenToScreenColorExpandFill);
+
+#if 0
+	    The constraints of the transfer range are incompatible with the
+	    XAA architecture. I rewrote the XAA functions using ImageWrite
+	    /* Accelerated CPU to screen color expansion */
+	    if ((pApm->Chipset == AT24 && pApm->ChipRev >= 4) ||
+		    pApm->Chipset == AT3D) {
+		pXAAinfo->CPUToScreenColorExpandFillFlags =
+		  NO_PLANEMASK | SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD
+		  | BIT_ORDER_IN_BYTE_MSBFIRST | LEFT_EDGE_CLIPPING |
+		  LEFT_EDGE_CLIPPING_NEGATIVE_X | SYNC_AFTER_COLOR_EXPAND;
+		XAA(SetupForCPUToScreenColorExpandFill);
+		XAA(SubsequentCPUToScreenColorExpandFill);
+		pXAAinfo->ColorExpandBase	= pApm->BltMap;
+		pXAAinfo->ColorExpandRange	= (pApm->Chipset >= AT3D) ? 32*1024 : 30*1024;
+	    }
+
+	    /* Accelerated image transfers */
+	    pXAAinfo->ImageWriteFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD;
+	    pXAAinfo->ImageWriteBase	= pApm->BltMap;
+	    pXAAinfo->ImageWriteRange	= (pApm->Chipset >= AT3D) ? 32*1024 : 30*1024;
+	    XAA(SetupForImageWrite);
+	    XAA(SubsequentImageWriteRect);
+#endif
+	    pXAAinfo->WritePixmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(WritePixmap);
+	    pXAAinfo->FillImageWriteRectsFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(FillImageWriteRects);
+	    pXAAinfo->WriteBitmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X |
+			    BIT_ORDER_IN_BYTE_LSBFIRST;
+	    XAA(WriteBitmap);
+	    pXAAinfo->TEGlyphRendererFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(TEGlyphRenderer);
+
+	    /* Accelerated screen-screen bitblts */
+	    pXAAinfo->ScreenToScreenCopyFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenCopy);
+	    XAA(SubsequentScreenToScreenCopy);
+
+	    /* Accelerated Line drawing */
+	    pXAAinfo->SolidLineFlags = NO_PLANEMASK | HARDWARE_CLIP_LINE;
+	    XAA(SetClippingRectangle);
+	    pXAAinfo->SolidBresenhamLineErrorTermBits = 15;
+
+	    if (pApm->Chipset >= AT24) {
+		XAA(SubsequentSolidBresenhamLine);
+
+		/* Pattern fill */
+		pXAAinfo->Mono8x8PatternFillFlags = NO_PLANEMASK |
+				HARDWARE_PATTERN_PROGRAMMED_BITS |
+				HARDWARE_PATTERN_SCREEN_ORIGIN;
+		XAA(SetupForMono8x8PatternFill);
+		XAA(SubsequentMono8x8PatternFillRect);
+		if (pApm->CurrentLayout.bitsPerPixel == 8) {
+		    pXAAinfo->Color8x8PatternFillFlags = NO_PLANEMASK |
+				    HARDWARE_PATTERN_SCREEN_ORIGIN;
+		    XAA(SetupForColor8x8PatternFill);
+		    XAA(SubsequentColor8x8PatternFillRect);
+		}
+	    }
+	    else
+		pXAAinfo->SubsequentSolidBresenhamLine =
+		    ApmSubsequentSolidBresenhamLine6422_IOP;
+#undef XAA
+	}
+    }
+    else {
+	if (!pApm->noLinear) {
+#define	XAA(s)		pXAAinfo->s = Apm##s##24
+	    XAA(Sync);
+
+	    /* Accelerated filled rectangles */
+	    pXAAinfo->SolidFillFlags = NO_PLANEMASK;
+	    XAA(SetupForSolidFill);
+	    XAA(SubsequentSolidFillRect);
+
+#if 0
+	    /* Accelerated screen to screen color expansion */
+	    pXAAinfo->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenColorExpandFill);
+	    XAA(SubsequentScreenToScreenColorExpandFill);
+
+#if 0
+	    The constraints of the transfer range are incompatible with the
+	    XAA architecture. I rewrote the XAA functions using ImageWrite
+	    /* Accelerated CPU to screen color expansion */
+	    if (pApm->Chipset == AT3D && pApm->ChipRev >= 4) {
+		pXAAinfo->CPUToScreenColorExpandFillFlags =
+		  NO_PLANEMASK | SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD
+		  | BIT_ORDER_IN_BYTE_MSBFIRST | LEFT_EDGE_CLIPPING |
+		  LEFT_EDGE_CLIPPING_NEGATIVE_X | SYNC_AFTER_COLOR_EXPAND;
+		XAA(SetupForCPUToScreenColorExpandFill);
+		XAA(SubsequentCPUToScreenColorExpandFill);
+		pXAAinfo->ColorExpandBase	= pApm->BltMap;
+		pXAAinfo->ColorExpandRange	= 32*1024;
+	    }
+
+	    /* Accelerated image transfers */
+	    pXAAinfo->ImageWriteFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD |
+			    SYNC_AFTER_IMAGE_WRITE;
+	    pXAAinfo->ImageWriteBase	= pApm->BltMap;
+	    pXAAinfo->ImageWriteRange	= 32*1024;
+	    XAA(SetupForImageWrite);
+	    XAA(SubsequentImageWriteRect);
+#endif
+	    pXAAinfo->WritePixmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(WritePixmap);
+	    pXAAinfo->FillImageWriteRectsFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(FillImageWriteRects);
+	    pXAAinfo->WriteBitmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X |
+			    BIT_ORDER_IN_BYTE_LSBFIRST;
+	    XAA(WriteBitmap);
+	    pXAAinfo->TEGlyphRendererFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(TEGlyphRenderer);
+
+	    /* Accelerated Line drawing */
+	    pXAAinfo->SolidLineFlags = NO_PLANEMASK | HARDWARE_CLIP_LINE;
+	    XAA(SubsequentSolidBresenhamLine);
+	    XAA(SetClippingRectangle);
+	    pXAAinfo->SolidBresenhamLineErrorTermBits = 15;
+
+	    /* Pattern fill */
+	    pXAAinfo->Mono8x8PatternFillFlags = NO_PLANEMASK | NO_TRANSPARENCY |
+			    HARDWARE_PATTERN_PROGRAMMED_BITS |
+			    HARDWARE_PATTERN_SCREEN_ORIGIN;
+	    XAA(SetupForMono8x8PatternFill);
+	    XAA(SubsequentMono8x8PatternFillRect);
+#endif
+
+	    /* Accelerated screen-screen bitblts */
+	    pXAAinfo->ScreenToScreenCopyFlags = NO_PLANEMASK | NO_TRANSPARENCY;
+	    XAA(SetupForScreenToScreenCopy);
+	    XAA(SubsequentScreenToScreenCopy);
+#undef XAA
+	}
+	else {
+#define	XAA(s)		pXAAinfo->s = Apm##s##24##_IOP
+	    XAA(Sync);
+
+	    /* Accelerated filled rectangles */
+	    pXAAinfo->SolidFillFlags = NO_PLANEMASK;
+	    XAA(SetupForSolidFill);
+	    XAA(SubsequentSolidFillRect);
+
+#if 0
+	    /* Accelerated screen to screen color expansion */
+	    pXAAinfo->ScreenToScreenColorExpandFillFlags = NO_PLANEMASK;
+	    XAA(SetupForScreenToScreenColorExpandFill);
+	    XAA(SubsequentScreenToScreenColorExpandFill);
+
+#if 0
+	    The constraints of the transfer range are incompatible with the
+	    XAA architecture. I rewrote the XAA functions using ImageWrite
+	    /* Accelerated CPU to screen color expansion */
+	    if (pApm->Chipset == AT3D && pApm->ChipRev >= 4) {
+		pXAAinfo->CPUToScreenColorExpandFillFlags =
+		  NO_PLANEMASK | SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD
+		  | BIT_ORDER_IN_BYTE_MSBFIRST | LEFT_EDGE_CLIPPING |
+		  LEFT_EDGE_CLIPPING_NEGATIVE_X | SYNC_AFTER_COLOR_EXPAND;
+		XAA(SetupForCPUToScreenColorExpandFill);
+		XAA(SubsequentCPUToScreenColorExpandFill);
+		pXAAinfo->ColorExpandBase	= pApm->BltMap;
+		pXAAinfo->ColorExpandRange	= 32*1024;
+	    }
+
+	    /* Accelerated image transfers */
+	    pXAAinfo->ImageWriteFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    SCANLINE_PAD_DWORD | CPU_TRANSFER_PAD_QWORD;
+	    pXAAinfo->ImageWriteBase	= pApm->BltMap;
+	    pXAAinfo->ImageWriteRange	= 32*1024;
+	    XAA(SetupForImageWrite);
+	    XAA(SubsequentImageWriteRect);
+#endif
+	    pXAAinfo->WritePixmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(WritePixmap);
+	    pXAAinfo->FillImageWriteRectsFlags	=
+			    LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(FillImageWriteRects);
+	    pXAAinfo->WriteBitmapFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X |
+			    BIT_ORDER_IN_BYTE_LSBFIRST;
+	    XAA(WriteBitmap);
+	    pXAAinfo->TEGlyphRendererFlags = LEFT_EDGE_CLIPPING | NO_PLANEMASK |
+			    LEFT_EDGE_CLIPPING_NEGATIVE_X;
+	    XAA(TEGlyphRenderer);
+
+	    /* Accelerated Line drawing */
+	    pXAAinfo->SolidLineFlags = NO_PLANEMASK | HARDWARE_CLIP_LINE;
+	    XAA(SubsequentSolidBresenhamLine);
+	    XAA(SetClippingRectangle);
+	    pXAAinfo->SolidBresenhamLineErrorTermBits = 15;
+
+	    /* Pattern fill */
+	    pXAAinfo->Mono8x8PatternFillFlags = NO_PLANEMASK | NO_TRANSPARENCY |
+			    HARDWARE_PATTERN_PROGRAMMED_BITS |
+			    HARDWARE_PATTERN_SCREEN_ORIGIN;
+	    XAA(SetupForMono8x8PatternFill);
+	    XAA(SubsequentMono8x8PatternFillRect);
+#endif
+
+	    /* Accelerated screen-screen bitblts */
+	    pXAAinfo->ScreenToScreenCopyFlags = NO_PLANEMASK | NO_TRANSPARENCY;
+	    XAA(SetupForScreenToScreenCopy);
+	    XAA(SubsequentScreenToScreenCopy);
+#undef XAA
+	}
+    }
+}