Initial revisionXORG-STABLE

1 files changed, 1558 insertions, 0 deletions

diff --git a/src/apm_funcs.c b/src/apm_funcs.c
new file mode 100644
index 0000000..71f0fe8
--- /dev/null
+++ b/src/apm_funcs.c
@@ -0,0 +1,1558 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/apm/apm_funcs.c,v 1.17 2002/05/07 12:53:49 alanh Exp $ */
+
+#define FASTER
+#ifndef PSZ
+#define PSZ	8
+#endif
+#ifdef IOP_ACCESS
+#  define APM_SUFF_IOP	"_IOP"
+#  undef	RDXB
+#  undef	RDXW
+#  undef	RDXL
+#  undef	WRXB
+#  undef	WRXW
+#  undef	WRXL
+#  undef	ApmWriteSeq
+#  define RDXB	RDXB_IOP
+#  define RDXW	RDXW_IOP
+#  define RDXL	RDXL_IOP
+#  define WRXB	WRXB_IOP
+#  define WRXW	WRXW_IOP
+#  define WRXL	WRXL_IOP
+#  define ApmWriteSeq(i, v)	wrinx(pApm->xport, i, v)
+#else
+#  define APM_SUFF_IOP	""
+#endif
+#if PSZ == 24
+#  define APM_SUFF_24	"24"
+#  ifdef IOP_ACCESS
+#    define A(s)		Apm##s##24##_IOP
+#  else
+#    define A(s)		Apm##s##24
+#  endif
+#else
+#  define APM_SUFF_24	""
+#  ifdef IOP_ACCESS
+#    define A(s)		Apm##s##_IOP
+#  else
+#    define A(s)		Apm##s
+#  endif
+#endif
+#define	DPRINTNAME(s)	do { xf86DrvMsgVerb(pScrn->pScreen->myNum, X_NOTICE, 4, "Apm" #s APM_SUFF_24 APM_SUFF_IOP "\n"); } while (0)
+
+#if PSZ == 24
+#undef SETSOURCEXY
+#undef SETDESTXY
+#undef SETWIDTH
+#undef SETWIDTHHEIGHT
+#undef UPDATEDEST
+#define SETSOURCEXY(x,y)	do { int off = ((((y) & 0xFFFF) * pApm->CurrentLayout.displayWidth + ((x) & 0x3FFF)) * 3); SETSOURCEOFF(((off & 0xFFF000) << 4) | (off & 0xFFF)); break;} while(1)
+#define SETDESTXY(x,y)	do { int off = ((((y) & 0xFFFF) * pApm->CurrentLayout.displayWidth + ((x) & 0x3FFF)) * 3); SETDESTOFF(((off & 0xFFF000) << 4) | (off & 0xFFF)); break;} while(1)
+#define SETWIDTH(w)		WRXW(0x58, ((w) & 0x3FFF) * 3)
+#define SETWIDTHHEIGHT(w,h)	WRXL(0x58, ((h) << 16) | (((w) & 0x3FFF) * 3))
+#define UPDATEDEST(x,y)		(void)(curr32[0x54 / 4] = ((((y) & 0xFFFF) * pApm->CurrentLayout.displayWidth + ((x) & 0xFFFF)) * 3))
+#endif
+
+/* Defines */
+#define MAXLOOP 1000000
+
+
+/* Local functions */
+static void A(Sync)(ScrnInfoPtr pScrn);
+static void A(SetupForSolidFill)(ScrnInfoPtr pScrn, int color, int rop,
+					unsigned int planemask);
+static void A(SubsequentSolidFillRect)(ScrnInfoPtr pScrn, int x, int y,
+				       int w, int h);
+static void A(SetupForScreenToScreenCopy)(ScrnInfoPtr pScrn, int xdir, int ydir,
+					  int rop, unsigned int planemask,
+                                          int transparency_color);
+static void A(SubsequentScreenToScreenCopy)(ScrnInfoPtr pScrn, int x1, int y1,
+					    int x2, int y2, int w, int h);
+#if PSZ != 24
+static void A(Sync6422)(ScrnInfoPtr pScrn);
+static void A(WriteBitmap)(ScrnInfoPtr pScrn, int x, int y, int w, int h,
+			    unsigned char *src, int srcwidth, int skipleft,
+			    int fg, int bg, int rop, unsigned int planemask);
+static void A(TEGlyphRenderer)(ScrnInfoPtr pScrn, int x, int y, int w, int h,
+				int skipleft, int startline, 
+				unsigned int **glyphs, int glyphWidth,
+				int fg, int bg, int rop, unsigned planemask);
+static void A(SetupForMono8x8PatternFill)(ScrnInfoPtr pScrn, int patx, int paty,
+				          int fg, int bg, int rop,
+				          unsigned int planemask);
+static void A(SubsequentMono8x8PatternFillRect)(ScrnInfoPtr pScrn, int patx,
+					        int paty, int x, int y,
+					        int w, int h);
+#if 0
+static void A(SetupForCPUToScreenColorExpandFill)(ScrnInfoPtr pScrn, int bg, int fg, int rop, unsigned int planemask);
+static void A(SubsequentCPUToScreenColorExpandFill)(ScrnInfoPtr pScrn, int x, int y, int w, int h, int skipleft);
+#endif
+static void A(SetupForScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn,
+						     int fg, int bg, int rop,
+						     unsigned int planemask);
+static void A(SetupForImageWrite)(ScrnInfoPtr pScrn, int rop,
+				  unsigned int planemask, int trans_color,
+				  int bpp, int depth);
+static void A(SubsequentImageWriteRect)(ScrnInfoPtr pScrn, int x, int y,
+					int w, int h, int skipleft);
+static void A(SubsequentScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn,
+						       int x, int y,
+						       int w, int h,
+						       int srcx, int srcy,
+						       int offset);
+static void A(SubsequentSolidBresenhamLine)(ScrnInfoPtr pScrn, int x1, int y1, int octant, int err, int e1, int e2, int length);
+static void A(SubsequentSolidBresenhamLine6422)(ScrnInfoPtr pScrn, int x1, int y1, int octant, int err, int e1, int e2, int length);
+static void A(SetClippingRectangle)(ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2);
+static void A(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);
+static void A(FillImageWriteRects)(ScrnInfoPtr pScrn, int rop,
+				    unsigned int planemask,
+				    int nBox, BoxPtr pBox, int xorg, int yorg,
+				    PixmapPtr pPix);
+static void A(SetupForColor8x8PatternFill)(ScrnInfoPtr pScrn,int patx,int paty,
+				           int rop, unsigned int planemask,
+					   int transparency_color);
+static void A(SubsequentColor8x8PatternFillRect)(ScrnInfoPtr pScrn, int patx,
+					         int paty, int x, int y,
+					         int w, int h);
+#endif
+
+/* Inline functions */
+static __inline__ void
+A(WaitForFifo)(ApmPtr pApm, int slots)
+{
+  if (!pApm->UsePCIRetry) {
+    volatile int i;
+
+    for(i = 0; i < MAXLOOP; i++) {
+      if ((STATUS() & STATUS_FIFO) >= slots)
+	break;
+    }
+    if (i == MAXLOOP) {
+      unsigned int status = STATUS();
+
+      WRXB(0x1FF, 0);
+      if (!xf86ServerIsExiting())
+	  FatalError("Hung in WaitForFifo() (Status = 0x%08X)\n", status);
+    }
+  }
+}
+
+
+static void
+A(SetupForSolidFill)(ScrnInfoPtr pScrn, int color, int rop,
+			unsigned int planemask)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetupForSolidFill);
+#ifdef FASTER
+  A(WaitForFifo)(pApm, 3 + pApm->apmClip);
+  SETDEC(DEC_QUICKSTART_ONDIMX | DEC_OP_RECT | DEC_DEST_UPD_TRCORNER |
+	  pApm->CurrentLayout.Setup_DEC);
+#else
+  A(WaitForFifo)(pApm, 2 + pApm->apmClip);
+#endif
+#if PSZ == 2
+  pApm->color = ((color & 0xFF0000) << 8) | ((color & 0xFF0000) >> 16) |
+		  ((color & 0xFF00) << 8) | ((color & 0xFF) << 16);
+#else
+  SETFOREGROUNDCOLOR(color);
+#endif
+
+  if (pApm->apmClip)  {
+    SETCLIP_CTRL(0);
+    pApm->apmClip = FALSE;
+  }
+
+  SETROP(apmROP[rop]);
+}
+
+static void
+A(SubsequentSolidFillRect)(ScrnInfoPtr pScrn, int x, int y, int w, int h)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SubsequentSolidFillRect);
+#if PSZ == 24
+#  ifndef FASTER
+  A(WaitForFifo)(pApm, 5);
+#  else
+  A(WaitForFifo)(pApm, 4);
+#  endif
+  SETOFFSET(3*(pApm->CurrentLayout.displayWidth - w));
+#if 0
+  switch ((((y * pApm->CurrentLayout.displayWidth + x)* 3) / 8) % 3) {
+  case 0:
+      SETFOREGROUNDCOLOR(pApm->color);
+      break;
+  case 1:
+      SETFOREGROUNDCOLOR((pApm->color << 8) | (pApm->color >> 16));
+      break;
+  case 2:
+      SETFOREGROUNDCOLOR(pApm->color >> 8);
+      break;
+  }
+#endif
+#else
+#  ifndef FASTER
+  A(WaitForFifo)(pApm, 3);
+#  else
+  A(WaitForFifo)(pApm, 2);
+#  endif
+#endif
+  SETDESTXY(x, y);
+  SETWIDTHHEIGHT(w, h);
+  UPDATEDEST(x + w + 1, y);
+#ifndef FASTER
+  SETDEC(DEC_START | DEC_OP_RECT | DEC_DEST_UPD_TRCORNER | pApm->CurrentLayout.Setup_DEC);
+#endif
+}
+
+static void
+A(SetupForScreenToScreenCopy)(ScrnInfoPtr pScrn, int xdir, int ydir, int rop,
+				unsigned int planemask, int transparency_color)
+{
+  unsigned char tmp;
+
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetupForScreenToScreenCopy);
+
+  if (pApm->apmLock) {
+    /*
+     * This is just an attempt, because Daryll is tampering with MY registers.
+     */
+    tmp = (RDXB(0xDB) & 0xF4) |  0x0A;
+    WRXB(0xDB, tmp);
+    ApmWriteSeq(0x1B, 0x20);
+    ApmWriteSeq(0x1C, 0x2F);
+    pApm->apmLock = FALSE;
+  }
+
+  pApm->blitxdir = xdir;
+  pApm->blitydir = ydir;
+
+  pApm->apmTransparency = (transparency_color != -1);
+
+#ifdef FASTER
+  A(WaitForFifo)(pApm, 2 + (transparency_color != -1));
+  SETDEC(DEC_QUICKSTART_ONDIMX | DEC_OP_BLT | DEC_DEST_UPD_TRCORNER |
+	  (pApm->apmTransparency ? DEC_SOURCE_TRANSPARENCY : 0) | pApm->CurrentLayout.Setup_DEC |
+	  ((xdir < 0) ? DEC_DIR_X_NEG : DEC_DIR_X_POS) |
+	  ((ydir < 0) ? DEC_DIR_Y_NEG : DEC_DIR_Y_POS));
+#else
+  A(WaitForFifo)(pApm, 1 + (transparency_color != -1));
+#endif
+
+  if (transparency_color != -1)
+    SETBACKGROUNDCOLOR(transparency_color);
+
+  SETROP(apmROP[rop]);
+}
+
+static void
+A(SubsequentScreenToScreenCopy)(ScrnInfoPtr pScrn, int x1, int y1,
+				    int x2, int y2, int w, int h)
+{
+  APMDECL(pScrn);
+#ifndef FASTER
+  u32		c = pApm->apmTransparency ? DEC_SOURCE_TRANSPARENCY : 0;
+#endif
+  u32		sx, dx, sy, dy;
+  int		i = y1 / pApm->CurrentLayout.Scanlines;
+
+  DPRINTNAME(SubsequentScreenToScreenCopy);
+  if (i && pApm->pixelStride) {
+#ifdef FASTER
+    A(WaitForFifo)(pApm, 1);
+    SETDEC(curr32[0x40 / 4] | (DEC_SOURCE_CONTIG | DEC_SOURCE_LINEAR));
+#else
+    c |= DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG;
+#endif
+    pApm->apmClip = TRUE;
+    A(WaitForFifo)(pApm, 3);
+    SETCLIP_LEFTTOP(x2, y2);
+    SETCLIP_RIGHTBOT(x2 + w - 1, y2 + h - 1);
+    SETCLIP_CTRL(1);
+    w = (pApm->pixelStride * 8) / pApm->CurrentLayout.bitsPerPixel;
+  }
+  else {
+#ifdef FASTER
+    A(WaitForFifo)(pApm, 1 + pApm->apmClip);
+    SETDEC(curr32[0x40 / 4] & ~(DEC_SOURCE_CONTIG | DEC_SOURCE_LINEAR));
+    if (pApm->apmClip)
+	SETCLIP_CTRL(0);
+    pApm->apmClip = FALSE;
+#else
+    if (pApm->apmClip) {
+	A(WaitForFifo)(pApm, 1);
+	SETCLIP_CTRL(0);
+	pApm->apmClip = FALSE;
+    }
+#endif
+  }
+  if (i) {
+      if (pApm->pixelStride) {
+	  x1 += (((y1 % pApm->CurrentLayout.Scanlines) - pApm->RushY[i - 1]) * pApm->pixelStride * 8) / pApm->CurrentLayout.bitsPerPixel;
+	  y1 = pApm->RushY[i - 1];
+      }
+      else
+	  y1 -= i * pApm->CurrentLayout.Scanlines;
+  }
+  if (pApm->blitxdir < 0)
+  {
+#ifndef FASTER
+    c |= DEC_DIR_X_NEG;
+#endif
+    sx = x1+w-1;
+    dx = x2+w-1;
+  }
+  else
+  {
+#ifndef FASTER
+    c |= DEC_DIR_X_POS;
+#endif
+    sx = x1;
+    dx = x2;
+  }
+
+  if (pApm->blitydir < 0)
+  {
+#ifndef FASTER
+    c |= DEC_DIR_Y_NEG | DEC_START | DEC_OP_BLT | DEC_DEST_UPD_TRCORNER |
+	    pApm->CurrentLayout.Setup_DEC;
+#endif
+    sy = y1+h-1;
+    dy = y2+h-1;
+  }
+  else
+  {
+#ifndef FASTER
+    c |= DEC_DIR_Y_POS | DEC_START | DEC_OP_BLT | DEC_DEST_UPD_TRCORNER |
+	    pApm->CurrentLayout.Setup_DEC;
+#endif
+    sy = y1;
+    dy = y2;
+  }
+
+#if PSZ == 24
+#  ifndef FASTER
+  A(WaitForFifo)(pApm, 5);
+#  else
+  A(WaitForFifo)(pApm, 4);
+#  endif
+  if (pApm->blitxdir == pApm->blitydir)
+    SETOFFSET(3 * (pApm->CurrentLayout.displayWidth - w));
+  else
+    SETOFFSET(3 * (pApm->CurrentLayout.displayWidth + w));
+#else
+#  ifndef FASTER
+  A(WaitForFifo)(pApm, 4);
+#  else
+  A(WaitForFifo)(pApm, 3);
+#  endif
+#endif
+
+  if (i && pApm->pixelStride) {
+    register unsigned int off = sx + sy * pApm->CurrentLayout.displayWidth;
+
+    SETSOURCEOFF(((off & 0xFFF000) << 4) | (off & 0xFFF));
+  }
+  else
+    SETSOURCEXY(sx,sy);
+  SETDESTXY(dx,dy);
+  SETWIDTHHEIGHT(w,h);
+  UPDATEDEST(dx + (w + 1)*pApm->blitxdir, dy);
+
+#ifndef FASTER
+  SETDEC(c);
+#endif
+  if (i) A(Sync)(pScrn);	/* Only for AT3D */
+}
+
+
+#if PSZ != 24
+static void
+A(SetupForScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn, int fg, int bg,
+					 int rop, unsigned int planemask)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetupForScreenToScreenColorExpandFill);
+  A(WaitForFifo)(pApm, 3 + pApm->apmClip);
+  if (bg == -1)
+  {
+    SETFOREGROUNDCOLOR(fg);
+    SETBACKGROUNDCOLOR(fg+1);
+    pApm->apmTransparency = TRUE;
+  }
+  else
+  {
+    SETFOREGROUNDCOLOR(fg);
+    SETBACKGROUNDCOLOR(bg);
+    pApm->apmTransparency = FALSE;
+  }
+
+  SETROP(apmROP[rop]);
+}
+
+static void
+A(WriteBitmap)(ScrnInfoPtr pScrn, int x, int y, int w, int h,
+		unsigned char *src, int srcwidth, int skipleft,
+		int fg, int bg, int rop, unsigned int planemask)
+{
+    APMDECL(pScrn);
+    Bool	beCareful, apmClip = FALSE;
+    int		wc, n, nc, wr, wrd;
+    CARD32	*dstPtr;
+#ifndef FASTER
+    int		c;
+#endif
+
+    DPRINTNAME(WriteBitmap);
+
+    if (w <= 0 && h <= 0)
+	return;
+
+    /*
+     * The function is a bit long, but the spirit is simple : put the monochrome
+     * data in scratch memory and color-expand it using the
+     * ScreenToScreenColorExpand techniques.
+     */
+
+    w += skipleft;
+    x -= skipleft;
+    wc = pApm->ScratchMemSize * 8;
+    wrd = (w + 31) >> 5;
+    wr = wrd << 5;
+    nc = wc / wr;
+    if (nc > h)
+	nc = h;
+    if (wr / 8 > srcwidth)
+	beCareful = TRUE;
+    else
+	beCareful = FALSE;
+    srcwidth -= wr / 8;
+
+    if (skipleft || w != wr) {
+	apmClip = TRUE;
+	A(WaitForFifo)(pApm, 3);
+	SETCLIP_LEFTTOP(x + skipleft, y);
+	SETCLIP_RIGHTBOT(x + w - 1, y + h - 1);
+	SETCLIP_CTRL(1);
+    }
+    else if (pApm->apmClip) {
+	A(WaitForFifo)(pApm, 1);
+	SETCLIP_CTRL(0);
+    }
+    pApm->apmClip = FALSE;
+
+    A(SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, planemask);
+#ifdef FASTER
+    A(WaitForFifo)(pApm, 2);
+    if (pApm->apmTransparency)
+    SETDEC(DEC_OP_BLT | DEC_DIR_X_POS | DEC_DIR_Y_POS | DEC_SOURCE_MONOCHROME |
+        DEC_QUICKSTART_ONDIMX | DEC_DEST_UPD_BLCORNER | DEC_SOURCE_LINEAR |
+        DEC_SOURCE_CONTIG | DEC_SOURCE_TRANSPARENCY | pApm->CurrentLayout.Setup_DEC);
+    else
+    SETDEC(DEC_OP_BLT | DEC_DIR_X_POS | DEC_DIR_Y_POS | DEC_SOURCE_MONOCHROME |
+        DEC_QUICKSTART_ONDIMX | DEC_DEST_UPD_BLCORNER | DEC_SOURCE_LINEAR |
+        DEC_SOURCE_CONTIG | pApm->CurrentLayout.Setup_DEC);
+#else
+    A(WaitForFifo)(pApm, 1);
+    c = DEC_OP_BLT | DEC_DIR_X_POS | DEC_DIR_Y_POS | DEC_SOURCE_MONOCHROME |
+        DEC_START | DEC_DEST_UPD_BLCORNER | DEC_SOURCE_LINEAR |
+        DEC_SOURCE_CONTIG | pApm->CurrentLayout.Setup_DEC;
+    if (pApm->apmTransparency)
+      c |= DEC_SOURCE_TRANSPARENCY;
+#endif
+
+    SETDESTXY(x, y);
+
+    if (!beCareful || h % nc > 3 || (w > 16 && h % nc)) {
+#ifndef FASTER
+	if (h / nc)
+	    SETWIDTHHEIGHT(wr, nc);
+#endif
+	for (n = h / nc; n-- > 0; ) {
+	    int i, j;
+
+	    if (pApm->ScratchMemPtr + nc * wrd * 4 < pApm->ScratchMemEnd) {
+#define		d	((memType)dstPtr - (memType)pApm->FbBase)
+		A(WaitForFifo)(pApm, 1);
+		dstPtr = (CARD32 *)pApm->ScratchMemPtr;
+		switch(pApm->CurrentLayout.bitsPerPixel) {
+		case 8: case 24:
+		    SETSOURCEOFF((d & 0xFFF000) << 4 |
+				(d & 0xFFF));
+		    break;
+		case 16:
+		    SETSOURCEOFF((d & 0xFFE000) << 3 |
+				((d & 0x1FFE) >> 1));
+		    break;
+		case 32:
+		    SETSOURCEOFF((d & 0xFFC000) << 2 |
+				((d & 0x3FFC) >> 2));
+		    break;
+		}
+#undef		d
+	    }
+	    else {
+		(*pApm->AccelInfoRec->Sync)(pScrn);
+		dstPtr = (CARD32 *)pApm->ScratchMemOffset;
+		SETSOURCEOFF(pApm->ScratchMem);
+	    }
+	    pApm->ScratchMemPtr = ((memType)(dstPtr + wrd * nc) + 4) 
+	      & ~(memType)7;
+	    for (i = nc; i-- > 0; ) {
+		for (j = wrd; j-- > 0; ) {
+		    *dstPtr++ = XAAReverseBitOrder(*(CARD32 *)src);
+		    src += 4;
+		}
+		src += srcwidth;
+	    }
+	    A(WaitForFifo)(pApm, 1);
+#ifdef FASTER
+	    SETWIDTHHEIGHT(wr, nc);
+#else
+	    SETDEC(c);
+#endif
+	}
+    }
+    else {
+#ifndef FASTER
+	if (h / nc)
+	    SETWIDTHHEIGHT(wr, nc);
+#endif
+	for (n = h / nc; n-- > 0; ) {
+	    int i, j;
+
+	    if (pApm->ScratchMemPtr + nc * wrd * 4 < pApm->ScratchMemEnd) {
+#define		d	((memType)dstPtr - (memType)pApm->FbBase)
+		A(WaitForFifo)(pApm, 1);
+		dstPtr = (CARD32 *)pApm->ScratchMemPtr;
+		switch(pApm->CurrentLayout.bitsPerPixel) {
+		case 8: case 24:
+		    SETSOURCEOFF((d & 0xFFF000) << 4 |
+				(d & 0xFFF));
+		    break;
+		case 16:
+		    SETSOURCEOFF((d & 0xFFE000) << 3 |
+				((d & 0x1FFE) >> 1));
+		    break;
+		case 32:
+		    SETSOURCEOFF((d & 0xFFC000) << 2 |
+				((d & 0x3FFC) >> 2));
+		    break;
+		}
+#undef		d
+	    }
+	    else {
+		(*pApm->AccelInfoRec->Sync)(pScrn);
+		dstPtr = (CARD32 *)pApm->ScratchMemOffset;
+		SETSOURCEOFF(pApm->ScratchMem);
+	    }
+	    pApm->ScratchMemPtr = ((memType)(dstPtr + wrd * nc * 4) + 4) & ~7;
+	    for (i = nc; i-- > 0; ) {
+		for (j = wrd; j-- > 0; ) {
+		    if (i || j || n)
+			*dstPtr++ = XAAReverseBitOrder(*(CARD32 *)src);
+		    else if (srcwidth > -8) {
+			((CARD8 *)dstPtr)[0] = byte_reversed[((CARD8 *)src)[2]];
+			((CARD8 *)dstPtr)[1] = byte_reversed[((CARD8 *)src)[1]];
+			((CARD8 *)dstPtr)[2] = byte_reversed[((CARD8 *)src)[0]];
+			dstPtr = (CARD32 *)(3 + (CARD8 *)dstPtr);
+		    }
+		    else if (srcwidth > -16) {
+			((CARD8 *)dstPtr)[0] = byte_reversed[((CARD8 *)src)[1]];
+			((CARD8 *)dstPtr)[1] = byte_reversed[((CARD8 *)src)[0]];
+			dstPtr = (CARD32 *)(2 + (CARD8 *)dstPtr);
+		    }
+		    else {
+			*(CARD8 *)dstPtr = byte_reversed[*(CARD8 *)src];
+			dstPtr = (CARD32 *)(1 + (CARD8 *)dstPtr);
+		    }
+		    src += 4;
+		}
+		src += srcwidth;
+	    }
+	    A(WaitForFifo)(pApm, 1);
+#ifdef FASTER
+	    SETWIDTHHEIGHT(wr, nc);
+#else
+	    SETDEC(c);
+#endif
+	}
+    }
+
+    /*
+     * Same thing for the remnant
+     */
+    UPDATEDEST(x, y + h + 1);
+    h %= nc;
+    if (h) {
+	if (!beCareful) {
+	    int i, j;
+
+#ifndef FASTER
+	    SETWIDTHHEIGHT(wr, h);
+#endif
+	    if (pApm->ScratchMemPtr + h * wrd * 4 < pApm->ScratchMemEnd) {
+#define		d	((memType)dstPtr - (memType)pApm->FbBase)
+		A(WaitForFifo)(pApm, 1);
+		dstPtr = (CARD32 *)pApm->ScratchMemPtr;
+		switch(pApm->CurrentLayout.bitsPerPixel) {
+		case 8: case 24:
+		    SETSOURCEOFF((d & 0xFFF000) << 4 |
+				(d & 0xFFF));
+		    break;
+		case 16:
+		    SETSOURCEOFF((d & 0xFFE000) << 3 |
+				((d & 0x1FFE) >> 1));
+		    break;
+		case 32:
+		    SETSOURCEOFF((d & 0xFFC000) << 2 |
+				((d & 0x3FFC) >> 2));
+		    break;
+		}
+#undef		d
+	    }
+	    else {
+		(*pApm->AccelInfoRec->Sync)(pScrn);
+		dstPtr = (CARD32 *)pApm->ScratchMemOffset;
+		SETSOURCEOFF(pApm->ScratchMem);
+	    }
+	    pApm->ScratchMemPtr = ((memType)(dstPtr + wrd * h) + 4) & ~7;
+	    for (i = h; i-- > 0; ) {
+		for (j = wrd; j-- > 0; ) {
+		    *dstPtr++ = XAAReverseBitOrder(*(CARD32 *)src);
+		    src += 4;
+		}
+		src += srcwidth;
+	    }
+	    A(WaitForFifo)(pApm, 1);
+#ifdef FASTER
+	    SETWIDTHHEIGHT(wr, h);
+#else
+	    SETDEC(c);
+#endif
+	}
+	else {
+	    int i, j;
+
+#ifndef FASTER
+	    SETWIDTHHEIGHT(w, h);
+#endif
+	    if (pApm->ScratchMemPtr + h * wrd * 4 < pApm->ScratchMemEnd) {
+#define		d	((memType)dstPtr - (memType)pApm->FbBase)
+		A(WaitForFifo)(pApm, 1);
+		dstPtr = (CARD32 *)pApm->ScratchMemPtr;
+		switch(pApm->CurrentLayout.bitsPerPixel) {
+		case 8: case 24:
+		    SETSOURCEOFF((d & 0xFFF000) << 4 |
+				(d & 0xFFF));
+		    break;
+		case 16:
+		    SETSOURCEOFF((d & 0xFFE000) << 3 |
+				((d & 0x1FFE) >> 1));
+		    break;
+		case 32:
+		    SETSOURCEOFF((d & 0xFFC000) << 2 |
+				((d & 0x3FFC) >> 2));
+		    break;
+		}
+#undef		d
+	    }
+	    else {
+		(*pApm->AccelInfoRec->Sync)(pScrn);
+		dstPtr = (CARD32 *)pApm->ScratchMemOffset;
+		SETSOURCEOFF(pApm->ScratchMem);
+	    }
+	    pApm->ScratchMemPtr = ((memType)(dstPtr + wrd * h) + 4) & ~7;
+	    for (i = h; i-- > 0; ) {
+		for (j = wrd; j-- > 0; ) {
+		    if (i || j)
+			*dstPtr++ = XAAReverseBitOrder(*(CARD32 *)src);
+		    else if (srcwidth > -8) {
+			((CARD8 *)dstPtr)[0] = byte_reversed[((CARD8 *)src)[2]];
+			((CARD8 *)dstPtr)[1] = byte_reversed[((CARD8 *)src)[1]];
+			((CARD8 *)dstPtr)[2] = byte_reversed[((CARD8 *)src)[0]];
+			dstPtr = (CARD32 *)(3 + (CARD8 *)dstPtr);
+		    }
+		    else if (srcwidth > -16) {
+			((CARD8 *)dstPtr)[0] = byte_reversed[((CARD8 *)src)[1]];
+			((CARD8 *)dstPtr)[1] = byte_reversed[((CARD8 *)src)[0]];
+			dstPtr = (CARD32 *)(2 + (CARD8 *)dstPtr);
+		    }
+		    else {
+			*(CARD8 *)dstPtr = byte_reversed[*(CARD8 *)src];
+			dstPtr = (CARD32 *)(1 + (CARD8 *)dstPtr);
+		    }
+		    src += 4;
+		}
+		src += srcwidth;
+	    }
+	    A(WaitForFifo)(pApm, 1);
+#ifdef FASTER
+	    SETWIDTHHEIGHT(w, h);
+#else
+	    SETDEC(c);
+#endif
+	}
+    }
+    pApm->apmClip = apmClip;
+}
+
+static void
+A(TEGlyphRenderer)(ScrnInfoPtr pScrn, int x, int y, int w, int h,
+		    int skipleft, int startline, 
+		    unsigned int **glyphs, int glyphWidth,
+		    int fg, int bg, int rop, unsigned planemask)
+{
+    CARD32 *base, *base0;
+    GlyphScanlineFuncPtr GlyphFunc = XAAGlyphScanlineFuncLSBFirst[glyphWidth - 1];
+    int w2, h2, dwords;
+
+    w2 = w + skipleft;
+    h2 = h;
+    dwords = (w2 + 31) >> 5;
+    dwords <<= 2;
+
+    base0 = base = (CARD32*)xalloc(dwords * h);
+    if (!base)
+	return;		/* Should not happen : it's rather small... */
+
+    while(h--) {
+	base = (*GlyphFunc)(base, glyphs, startline++, w2, glyphWidth);
+    }
+
+    A(WriteBitmap)(pScrn, x, y, w, h2, (unsigned char *)base0, dwords,
+		    skipleft, fg, bg, rop, planemask);
+
+    xfree(base0);
+}
+
+static void A(SetupForMono8x8PatternFill)(ScrnInfoPtr pScrn, int patx, int paty,
+				          int fg, int bg, int rop,
+				          unsigned int planemask)
+{
+    APMDECL(pScrn);
+
+    DPRINTNAME(SetupForMono8x8PatternFill);
+    pApm->apmTransparency = (pApm->Chipset >= AT3D) && (bg == -1);
+    pApm->Bg8x8 = bg;
+    pApm->Fg8x8 = fg;
+    pApm->rop = apmROP[rop];
+    A(WaitForFifo)(pApm, 3 + pApm->apmClip);
+    if (bg == -1)
+	SETBACKGROUNDCOLOR(fg + 1);
+    else
+	SETBACKGROUNDCOLOR(bg);
+    SETFOREGROUNDCOLOR(fg);
+    if (pApm->Chipset >= AT3D)
+	SETROP(apmROP[rop] & 0xF0);
+    else
+	SETROP((apmROP[rop] & 0xF0) | 0x0A);
+    if (pApm->apmClip) {
+	SETCLIP_CTRL(0);
+	pApm->apmClip = FALSE;
+    }
+}
+
+static void A(SubsequentMono8x8PatternFillRect)(ScrnInfoPtr pScrn, int patx,
+					        int paty, int x, int y,
+					        int w, int h)
+{
+    APMDECL(pScrn);
+
+    DPRINTNAME(SubsequentMono8x8PatternFillRect);
+    SETDESTXY(x, y);
+    UPDATEDEST(x, y + h + 1);
+    A(WaitForFifo)(pApm, 6);
+    if (pApm->Chipset == AT24 && pApm->Bg8x8 != -1) {
+	SETROP(pApm->rop);
+	SETFOREGROUNDCOLOR(pApm->Bg8x8);
+#ifdef FASTER
+	SETDEC(pApm->CurrentLayout.Setup_DEC | ((h == 1) ? DEC_OP_STRIP : DEC_OP_RECT) |
+		DEC_DEST_XY | DEC_QUICKSTART_ONDIMX);
+	SETWIDTHHEIGHT(w, h);
+#else
+	SETWIDTHHEIGHT(w, h);
+	SETDEC(pApm->CurrentLayout.Setup_DEC | ((h == 1) ? DEC_OP_STRIP : DEC_OP_RECT) |
+		DEC_DEST_XY | DEC_START);
+#endif
+	A(WaitForFifo)(pApm, 6);
+	SETROP((pApm->rop & 0xF0) | 0x0A);
+	SETFOREGROUNDCOLOR(pApm->Fg8x8);
+    }
+    SETPATTERN(patx, paty);
+#ifdef FASTER
+    SETDEC(pApm->CurrentLayout.Setup_DEC | ((h == 1) ? DEC_OP_STRIP : DEC_OP_RECT) |
+	    DEC_DEST_XY | DEC_PATTERN_88_1bMONO | DEC_DEST_UPD_TRCORNER |
+	    (pApm->apmTransparency ? DEC_SOURCE_TRANSPARENCY : 0) |
+	    DEC_QUICKSTART_ONDIMX);
+    SETWIDTHHEIGHT(w, h);
+#else
+    SETWIDTHHEIGHT(w, h);
+    SETDEC(pApm->CurrentLayout.Setup_DEC | ((h == 1) ? DEC_OP_STRIP : DEC_OP_RECT) |
+	    DEC_DEST_XY | DEC_PATTERN_88_1bMONO | DEC_DEST_UPD_TRCORNER |
+	    (pApm->apmTransparency ? DEC_SOURCE_TRANSPARENCY : 0) |
+	    DEC_START);
+#endif
+}
+
+#if 0
+static void
+A(SetupForCPUToScreenColorExpandFill)(ScrnInfoPtr pScrn, int fg, int bg,
+					int rop, unsigned int planemask)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetupForCPUToScreenColorExpandFill);
+  if (bg == -1)
+  {
+#ifndef FASTER
+    pApm->apmTransparency = TRUE;
+    A(WaitForFifo)(pApm, 3);
+#else
+    A(WaitForFifo)(pApm, 4);
+    SETDEC(DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+      DEC_SOURCE_TRANSPARENCY | DEC_SOURCE_MONOCHROME | DEC_QUICKSTART_ONDIMX |
+      DEC_DEST_UPD_TRCORNER | pApm->CurrentLayout.Setup_DEC);
+#endif
+    SETFOREGROUNDCOLOR(fg);
+    SETBACKGROUNDCOLOR(fg+1);
+  }
+  else
+  {
+#ifndef FASTER
+    pApm->apmTransparency = FALSE;
+    A(WaitForFifo)(pApm, 3);
+#else
+    A(WaitForFifo)(pApm, 4);
+    SETDEC(DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+	   DEC_DEST_UPD_TRCORNER | DEC_SOURCE_MONOCHROME |
+	   DEC_QUICKSTART_ONDIMX | pApm->CurrentLayout.Setup_DEC);
+#endif
+    SETFOREGROUNDCOLOR(fg);
+    SETBACKGROUNDCOLOR(bg);
+  }
+  SETROP(apmROP[rop]);
+}
+
+static void
+A(SubsequentCPUToScreenColorExpandFill)(ScrnInfoPtr pScrn, int x, int y,
+					int w, int h, int skipleft)
+{
+  APMDECL(pScrn);
+#ifndef FASTER
+  u32 c;
+#endif
+
+  DPRINTNAME(SubsequentCPUToScreenColorExpandFill);
+#ifndef FASTER
+  c = DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+      DEC_SOURCE_MONOCHROME | DEC_START | DEC_DEST_UPD_TRCORNER |
+      pApm->CurrentLayout.Setup_DEC;
+
+  if (pApm->apmTransparency)
+    c |= DEC_SOURCE_TRANSPARENCY;
+
+  A(WaitForFifo)(pApm, 7);
+#else
+  A(WaitForFifo)(pApm, 6);
+#endif
+
+  SETCLIP_LEFTTOP(x+skipleft, y);
+  SETCLIP_RIGHTBOT(x+w-1, y+h-1);
+  SETCLIP_CTRL(0x01);
+  pApm->apmClip = TRUE;
+  SETSOURCEX(0); /* According to manual, it just has to be zero */
+  SETDESTXY(x, y);
+  SETWIDTHHEIGHT((w + 31) & ~31, h);
+  UPDATEDEST(x + ((w + 31) & ~31), y);
+
+#ifndef FASTER
+  SETDEC(c);
+#endif
+}
+#endif
+
+static void
+A(SetupForImageWrite)(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
+		      int trans_color, int bpp, int depth)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetupForImageWrite);
+  if (trans_color != -1)
+  {
+#ifndef FASTER
+    pApm->apmTransparency = TRUE;
+    A(WaitForFifo)(pApm, 3);
+#else
+    A(WaitForFifo)(pApm, 4);
+    SETDEC(DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+	  DEC_SOURCE_TRANSPARENCY | DEC_QUICKSTART_ONDIMX | pApm->CurrentLayout.Setup_DEC);
+#endif
+    SETBACKGROUNDCOLOR(trans_color);
+  }
+  else {
+#ifndef FASTER
+    pApm->apmTransparency = FALSE;
+    A(WaitForFifo)(pApm, 2);
+#else
+    A(WaitForFifo)(pApm, 3);
+    SETDEC(DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+	  DEC_QUICKSTART_ONDIMX | pApm->CurrentLayout.Setup_DEC);
+#endif
+  }
+
+  SETROP(apmROP[rop]);
+}
+
+static void
+A(SubsequentImageWriteRect)(ScrnInfoPtr pScrn, int x, int y, int w, int h,
+			    int skipleft)
+{
+  APMDECL(pScrn);
+#ifndef FASTER
+  u32 c;
+#endif
+
+  DPRINTNAME(SubsequentImageWriteRect);
+#ifndef FASTER
+  c = DEC_OP_HOSTBLT_HOST2SCREEN | DEC_SOURCE_LINEAR | DEC_SOURCE_CONTIG |
+      DEC_START | pApm->CurrentLayout.Setup_DEC;
+
+  if (pApm->apmTransparency)
+    c |= DEC_SOURCE_TRANSPARENCY;
+
+  if (pApm->Chipset >= AT24)
+      A(WaitForFifo)(pApm, 7);
+  else
+      A(WaitForFifo)(pApm, 3);
+#else
+  if (pApm->Chipset >= AT24)
+      A(WaitForFifo)(pApm, 6);
+  else
+      A(WaitForFifo)(pApm, 3);
+#endif
+
+  SETCLIP_LEFTTOP(x+skipleft, y);
+  SETCLIP_RIGHTBOT(x+w-1, y+h-1);
+  SETCLIP_CTRL(0x01);
+  pApm->apmClip = TRUE;
+  if (pApm->Chipset < AT24)
+      A(WaitForFifo)(pApm, 4);
+  SETSOURCEX(0); /* According to manual, it just has to be zero */
+  SETDESTXY(x, y);
+  SETWIDTHHEIGHT((w + 3) & ~3, h);
+
+#ifndef FASTER
+  SETDEC(c);
+#endif
+}
+
+static void
+A(SubsequentScreenToScreenColorExpandFill)(ScrnInfoPtr pScrn, int x, int y,
+					   int w, int h, int srcx, int srcy,
+					   int offset)
+{
+  APMDECL(pScrn);
+  u32 c;
+
+  DPRINTNAME(SubsequentScreenToScreenColorExpandFill);
+#ifdef FASTER
+  c = DEC_OP_BLT | DEC_DIR_X_POS | DEC_DIR_Y_POS | DEC_SOURCE_MONOCHROME |
+      DEC_QUICKSTART_ONDIMX | DEC_DEST_UPD_TRCORNER | pApm->CurrentLayout.Setup_DEC;
+#else
+  c = DEC_OP_BLT | DEC_DIR_X_POS | DEC_DIR_Y_POS | DEC_SOURCE_MONOCHROME |
+      DEC_START | DEC_DEST_UPD_TRCORNER | pApm->CurrentLayout.Setup_DEC;
+#endif
+
+  if (pApm->apmTransparency)
+    c |= DEC_SOURCE_TRANSPARENCY;
+
+  if (srcy >= pApm->CurrentLayout.Scanlines) {
+      struct ApmStippleCacheRec *pCache;
+      CARD32	dist;
+
+      /*
+       * Offscreen linear stipple
+       */
+      pCache = &pApm->apmCache[srcy / pApm->CurrentLayout.Scanlines - 1];
+      if (w != pCache->apmStippleCache.w * pApm->CurrentLayout.bitsPerPixel) {
+	  A(WaitForFifo)(pApm, 3);
+	  SETCLIP_LEFTTOP(x, y);
+	  SETCLIP_RIGHTBOT(x + w - 1, y + h - 1);
+	  SETCLIP_CTRL(0x01);
+	  pApm->apmClip = TRUE;
+	  w = pCache->apmStippleCache.w * pApm->CurrentLayout.bitsPerPixel;
+	  x -= srcx - pCache->apmStippleCache.x + offset;
+	  srcx = (srcy - pCache->apmStippleCache.y) & 7;
+	  srcy -= srcx;
+	  y -= srcx;
+	  h += srcx;
+	  srcx = pCache->apmStippleCache.x;
+      }
+      else if (pApm->apmClip) {
+	  A(WaitForFifo)(pApm, 1);
+	  SETCLIP_CTRL(0x00);
+	  pApm->apmClip = FALSE;
+      }
+      srcx += (srcy - pCache->apmStippleCache.y) * pCache->apmStippleCache.w;
+      srcy = pCache->apmStippleCache.y % pApm->CurrentLayout.Scanlines;
+      dist = srcx + srcy * pApm->CurrentLayout.displayWidth;
+      srcx = dist & 0xFFF;
+      srcy = dist >> 12;
+      c |= DEC_SOURCE_CONTIG | DEC_SOURCE_LINEAR;
+  }
+  else if (offset) {
+      A(WaitForFifo)(pApm, 3);
+      SETCLIP_LEFTTOP(x, y);
+      SETCLIP_RIGHTBOT(x + w, y + h);
+      SETCLIP_CTRL(0x01);
+      pApm->apmClip = TRUE;
+      w += offset;
+      x -= offset;
+  }
+  else if (pApm->apmClip) {
+      A(WaitForFifo)(pApm, 1);
+      SETCLIP_CTRL(0x00);
+      pApm->apmClip = FALSE;
+  }
+
+  A(WaitForFifo)(pApm, 4);
+
+  SETSOURCEXY(srcx, srcy);
+  SETDESTXY(x, y);
+
+#ifdef FASTER
+  SETDEC(c);
+  SETWIDTHHEIGHT(w, h);
+#else
+  SETWIDTHHEIGHT(w, h);
+  SETDEC(c);
+#endif
+  UPDATEDEST(x + w + 1, h);
+}
+
+static void
+A(SubsequentSolidBresenhamLine)(ScrnInfoPtr pScrn, int x1, int y1, int e1,
+				int e2, int err, int length, int octant)
+{
+  APMDECL(pScrn);
+#ifdef FASTER
+  u32 c = DEC_QUICKSTART_ONDIMX | DEC_OP_VECT_ENDP | DEC_DEST_UPD_LASTPIX |
+	  pApm->CurrentLayout.Setup_DEC;
+#else
+  u32 c = DEC_START | DEC_OP_VECT_ENDP | DEC_DEST_UPD_LASTPIX | pApm->CurrentLayout.Setup_DEC;
+#endif
+  int	tmp;
+
+  DPRINTNAME(SubsequentSolidBresenhamLine);
+
+  A(WaitForFifo)(pApm, 5);
+  SETDESTXY(x1,y1);
+  SETDDA_ERRORTERM(err);
+  SETDDA_ADSTEP(e1, e2);
+
+  if (octant & YMAJOR) {
+    c |= DEC_MAJORAXIS_Y;
+    tmp = e1; e1 = e2; e2 = tmp;
+  }
+  else
+    c |= DEC_MAJORAXIS_X;
+
+  if (octant & XDECREASING) {
+    c |= DEC_DIR_X_NEG;
+    e1 = -e1;
+  }
+  else
+    c |= DEC_DIR_X_POS;
+
+  if (octant & YDECREASING) {
+    c |= DEC_DIR_Y_NEG;
+    e2 = -e2;
+  }
+  else
+    c |= DEC_DIR_Y_POS;
+
+#ifdef FASTER
+  SETDEC(c);
+  SETWIDTH(length);
+#else
+  SETWIDTH(length);
+  SETDEC(c);
+#endif
+
+  if (octant & YMAJOR)
+    UPDATEDEST(x1 + e1 / 2, y1 + e2 / 2);
+  else
+    UPDATEDEST(x1 + e2 / 2, y1 + e1 / 2);
+  if (pApm->apmClip)
+  {
+    pApm->apmClip = FALSE;
+    A(WaitForFifo)(pApm, 1);
+    SETCLIP_CTRL(0);
+  }
+}
+
+static void
+A(SubsequentSolidBresenhamLine6422)(ScrnInfoPtr pScrn, int x1, int y1, int e1,
+				int e2, int err, int length, int octant)
+{
+  APMDECL(pScrn);
+#ifdef FASTER
+  u32 c = DEC_QUICKSTART_ONDIMX | DEC_OP_VECT_ENDP | DEC_DEST_UPD_LASTPIX |
+	  pApm->CurrentLayout.Setup_DEC;
+#else
+  u32 c = DEC_START | DEC_OP_VECT_ENDP | DEC_DEST_UPD_LASTPIX | pApm->CurrentLayout.Setup_DEC;
+#endif
+  int	tmp;
+
+  DPRINTNAME(SubsequentSolidBresenhamLine6422);
+
+  A(WaitForFifo)(pApm, 1);
+  SETDESTXY(x1,y1);
+  A(WaitForFifo)(pApm, 4);
+  SETDDA_ERRORTERM(err);
+  SETDDA_ADSTEP(e1, e2);
+
+  if (octant & YMAJOR) {
+    c |= DEC_MAJORAXIS_Y;
+    tmp = e1; e1 = e2; e2 = tmp;
+  }
+  else
+    c |= DEC_MAJORAXIS_X;
+
+  if (octant & XDECREASING) {
+    c |= DEC_DIR_X_NEG;
+    e1 = -e1;
+  }
+  else
+    c |= DEC_DIR_X_POS;
+
+  if (octant & YDECREASING) {
+    c |= DEC_DIR_Y_NEG;
+    e2 = -e2;
+  }
+  else
+    c |= DEC_DIR_Y_POS;
+
+#ifdef FASTER
+  SETDEC(c);
+  SETWIDTH(length);
+#else
+  SETWIDTH(length);
+  SETDEC(c);
+#endif
+
+  if (octant & YMAJOR)
+    UPDATEDEST(x1 + e1 / 2, y1 + e2 / 2);
+  else
+    UPDATEDEST(x1 + e2 / 2, y1 + e1 / 2);
+  if (pApm->apmClip)
+  {
+    pApm->apmClip = FALSE;
+    A(WaitForFifo)(pApm, 1);
+    SETCLIP_CTRL(0);
+  }
+}
+
+static void
+A(SetClippingRectangle)(ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2)
+{
+  APMDECL(pScrn);
+
+  DPRINTNAME(SetClippingRectangle);
+  A(WaitForFifo)(pApm, 3);
+  SETCLIP_LEFTTOP(x1,y1);
+  SETCLIP_RIGHTBOT(x2,y2);
+  SETCLIP_CTRL(0x01);
+  pApm->apmClip = TRUE;
+}
+
+static void
+A(SyncBlt)(ApmPtr pApm)
+{
+    int again = (pApm->Chipset == AP6422);
+
+    do {
+       while (!(STATUS() & STATUS_HOSTBLTBUSY))
+	   ;
+    }
+    while (again--);	/* See remark in Sync6422 */
+}
+static void
+A(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)
+{
+    APMDECL(pScrn);
+    int dwords, skipleft, Bpp = bpp >> 3;
+    Bool beCareful = FALSE;
+    unsigned char *dst = ((unsigned char *)pApm->FbBase) + x * Bpp + y * pApm->CurrentLayout.bytesPerScanline;
+    int PlusOne = 0, mask, count;
+
+    DPRINTNAME(WritePixmap);
+    if (rop == GXnoop)
+	return;
+    /*
+     * The function seems to crash more than it feels good. I hope that a
+     * good sync will help. This sync is anyway needed for direct write.
+     */
+    (*pApm->AccelInfoRec->Sync)(pScrn);
+    /*
+     * First the fast case : source and dest have same alignment. Doc says
+     * it's faster to do it here, which may be true since one has to read
+     * the chip when CPU to screen-ing.
+     */
+    if ((skipleft = (long)src & 3L) == ((long)dst & 3L) && rop == GXcopy) {
+	int skipright;
+
+	if (skipleft)
+	    skipleft = 4 - skipleft;
+	dwords = (skipright = w * Bpp - skipleft) >> 2;
+	skipright %= 4;
+	if (!skipleft && !skipright)
+	    while (h-- > 0) {
+		CARD32 *src2 = (CARD32 *)src;
+		CARD32 *dst2 = (CARD32 *)dst;
+
+		for (count = dwords; count-- > 0; )
+		    *dst2++ = *src2++;
+		src += srcwidth;
+		dst += pApm->CurrentLayout.bytesPerScanline;
+	    }
+	else if (!skipleft)
+	    while (h-- > 0) {
+		CARD32 *src2 = (CARD32 *)src;
+		CARD32 *dst2 = (CARD32 *)dst;
+
+		for (count = dwords; count-- > 0; )
+		    *dst2++ = *src2++;
+		for (count = skipright; count-- > 0; )
+		    ((char *)dst2)[count] = ((char *)src2)[count];
+		src += srcwidth;
+		dst += pApm->CurrentLayout.bytesPerScanline;
+	    }
+	else if (!skipright)
+	    while (h-- > 0) {
+		CARD32 *src2 = (CARD32 *)(src + skipleft);
+		CARD32 *dst2 = (CARD32 *)(dst + skipleft);
+
+		for (count = skipleft; count-- > 0; )
+		    dst[count] = src[count];
+		for (count = dwords; count-- > 0; )
+		    *dst2++ = *src2++;
+		src += srcwidth;
+		dst += pApm->CurrentLayout.bytesPerScanline;
+	    }
+	else
+	    while (h-- > 0) {
+		CARD32 *src2 = (CARD32 *)(src + skipleft);
+		CARD32 *dst2 = (CARD32 *)(dst + skipleft);
+
+		for (count = skipleft; count-- > 0; )
+		    dst[count] = src[count];
+		for (count = dwords; count-- > 0; )
+		    *dst2++ = *src2++;
+		for (count = skipright; count-- > 0; )
+		    ((char *)dst2)[count] = ((char *)src2)[count];
+		src += srcwidth;
+		dst += pApm->CurrentLayout.bytesPerScanline;
+	    }
+
+	return;
+    }
+
+    if (skipleft) {
+	if (Bpp == 3)
+	   skipleft = 4 - skipleft;
+	else
+	   skipleft /= Bpp;
+
+	if (x < skipleft) {
+	   skipleft = 0;
+	   beCareful = TRUE;
+	   goto BAD_ALIGNMENT;
+	}
+
+	x -= skipleft;
+	w += skipleft;
+
+	if (Bpp == 3)
+	   src -= 3 * skipleft;
+	else   /* is this Alpha friendly ? */
+	   src = (unsigned char*)((long)src & ~0x03L);
+    }
+
+BAD_ALIGNMENT:
+
+    dwords = ((w * Bpp) + 3) >> 2;
+    mask = (pApm->CurrentLayout.bitsPerPixel / 8) - 1;
+
+    if (dwords & mask) {
+	/*
+	 * Experimental...
+	 * It seems the AT3D needs a padding of scanline to a multiple of
+	 * 4 pixels, not only bytes.
+	 */
+	PlusOne = mask - (dwords & mask) + 1;
+    }
+
+    A(SetupForImageWrite)(pScrn, rop, planemask, trans, bpp, depth);
+    A(SubsequentImageWriteRect)(pScrn, x, y, w, h, skipleft);
+
+    if (beCareful) {
+	/* in cases with bad alignment we have to be careful not
+	   to read beyond the end of the source */
+	if (((x * Bpp) + (dwords << 2)) > srcwidth) h--;
+	else beCareful = FALSE;
+    }
+
+    srcwidth -= (dwords << 2);
+
+    while (h--) {
+	for (count = dwords; count-- > 0; ) {
+	    A(SyncBlt)(pApm);
+	    *(CARD32*)pApm->BltMap = *(CARD32*)src;
+	    src += 4;
+	}
+	src += srcwidth;
+	for (count = PlusOne; count-- > 0; ) {
+	    int	status;
+
+	    while (!((status = STATUS()) & STATUS_HOSTBLTBUSY))
+		if (!(status & STATUS_ENGINEBUSY))
+		    break;
+	    if (pApm->Chipset == AP6422)	/* See remark in Sync6422 */
+		while (!((status = STATUS()) & STATUS_HOSTBLTBUSY))
+		    if (!(status & STATUS_ENGINEBUSY))
+			break;
+	    if (status & STATUS_ENGINEBUSY)
+		*(CARD32*)pApm->BltMap = 0x00000000;
+	}
+    }
+    if (beCareful) {
+       int shift = ((long)src & 0x03L) << 3;
+
+       if (--dwords) {
+	    for (count = dwords >> 2; count-- > 0; ) {
+		A(SyncBlt)(pApm);
+		*(CARD32*)pApm->BltMap = *(CARD32*)src;
+		src += 4;
+	    }
+       }
+       A(SyncBlt)(pApm);
+       *((CARD32*)pApm->BltMap) = *((CARD32*)src) >> shift;
+    }
+
+    pApm->apmClip = FALSE;
+    A(WaitForFifo)(pApm, 1);
+    SETCLIP_CTRL(0);
+}
+
+static void 
+A(FillImageWriteRects)(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
+			int nBox, BoxPtr pBox, int xorg, int yorg,
+			PixmapPtr pPix)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
+    int x, y, phaseY, phaseX, phaseXB, height, width, blit_w;
+    int pHeight = pPix->drawable.height;
+    int pWidth = pPix->drawable.width;
+    int depth = pPix->drawable.depth;
+    int bpp = pPix->drawable.bitsPerPixel;
+    unsigned char *pSrc;
+    int srcwidth = pPix->devKind;
+
+    while(nBox--) {
+	x = pBox->x1;
+	y = pBox->y1;
+	phaseY = (pBox->y1 - yorg) % pHeight;
+	if(phaseY < 0) phaseY += pHeight;
+	phaseX = (x - xorg) % pWidth;
+	pSrc = (unsigned char *)pPix->devPrivate.ptr +
+				    phaseX * pPix->drawable.bitsPerPixel / 8;
+	if(phaseX < 0) phaseX += pWidth;
+	height = pBox->y2 - pBox->y1;
+	width = pBox->x2 - x;
+	
+	while(1) {
+	    int		ch = height, cp = phaseY, cy = y;
+
+	    blit_w = pWidth - phaseX;
+	    if(blit_w > width) blit_w = width;
+
+	    while (ch > 0) {
+		int	h = MIN(pHeight - cp, ch);
+
+		A(WritePixmap)(pScrn, x, cy, blit_w, h, pSrc + cp * srcwidth,
+				srcwidth, rop, planemask, FALSE, bpp, depth);
+		cy += h;
+		ch -= h;
+		cp = 0;
+	    }
+
+	    width -= blit_w;
+	    if(!width) break;
+	    x += blit_w;
+	    phaseX = (phaseX + blit_w) % pWidth;
+	    phaseXB = phaseX * pPix->drawable.bitsPerPixel / 8;
+	}
+	pBox++;
+    }
+
+    SET_SYNC_FLAG(infoRec);
+}
+
+static void A(SetupForColor8x8PatternFill)(ScrnInfoPtr pScrn,int patx,int paty,
+				           int rop, unsigned int planemask,
+					   int transparency_color)
+{
+    APMDECL(pScrn);
+
+    DPRINTNAME(SetupForColor8x8PatternFillRect);
+    if (transparency_color != -1) {
+#ifndef FASTER
+	pApm->apmTransparency = TRUE;
+	A(WaitForFifo)(pApm, 2 + pApm->apmClip);
+#else
+	A(WaitForFifo)(pApm, 3 + pApm->apmClip);
+	SETDEC(pApm->CurrentLayout.Setup_DEC | DEC_OP_BLT |
+	    DEC_DEST_XY | DEC_PATTERN_88_8bCOLOR | DEC_SOURCE_TRANSPARENCY |
+	    DEC_QUICKSTART_ONDIMX);
+#endif
+	SETBACKGROUNDCOLOR(transparency_color);
+    }
+    else {
+#ifndef FASTER
+	pApm->apmTransparency = FALSE;
+	A(WaitForFifo)(pApm, 1 + pApm->apmClip);
+#else
+	A(WaitForFifo)(pApm, 2 + pApm->apmClip);
+	SETDEC(pApm->CurrentLayout.Setup_DEC | DEC_OP_BLT |
+	    DEC_DEST_XY | DEC_PATTERN_88_8bCOLOR | DEC_QUICKSTART_ONDIMX);
+#endif
+    }
+    if (pApm->apmClip) {
+	SETCLIP_CTRL(0);
+	pApm->apmClip = FALSE;
+    }
+    SETROP(apmROP[rop]);
+}
+
+static void A(SubsequentColor8x8PatternFillRect)(ScrnInfoPtr pScrn, int patx,
+					         int paty, int x, int y,
+					         int w, int h)
+{
+    APMDECL(pScrn);
+
+    DPRINTNAME(SubsequentColor8x8PatternFillRect);
+#ifndef FASTER
+    A(WaitForFifo)(pApm, 5);
+#else
+    A(WaitForFifo)(pApm, 4);
+#endif
+    SETSOURCEXY(patx, paty);
+    SETDESTXY(x, y);
+    SETWIDTHHEIGHT(w, h);
+    UPDATEDEST(x + w + 1, y);
+#ifndef FASTER
+    SETDEC(pApm->CurrentLayout.Setup_DEC | DEC_OP_BLT |
+	    DEC_DEST_XY | (pApm->apmTransparency * DEC_SOURCE_TRANSPARENCY) |
+	    DEC_PATTERN_88_8bCOLOR | DEC_START);
+#endif
+}
+#endif
+
+static void
+A(Sync)(ScrnInfoPtr pScrn)
+{
+  APMDECL(pScrn);
+  volatile u32 i, stat;
+
+  for(i = 0; i < MAXLOOP; i++) {
+    stat = STATUS();
+    if ((!(stat & (STATUS_HOSTBLTBUSY | STATUS_ENGINEBUSY))) &&
+        ((stat & STATUS_FIFO) >= 8))
+      break;
+  }
+  if (i == MAXLOOP) {
+    unsigned int status = STATUS();
+
+    WRXB(0x1FF, 0);
+    if (!xf86ServerIsExiting())
+	FatalError("Hung in ApmSync" APM_SUFF_24 APM_SUFF_IOP "(%d) (Status = 0x%08X)\n", pScrn->pScreen->myNum, status);
+  }
+  if (pApm->apmClip) {
+    SETCLIP_CTRL(0);
+    pApm->apmClip = FALSE;
+  }
+}
+
+#if PSZ != 24
+static void
+A(Sync6422)(ScrnInfoPtr pScrn)
+{
+  APMDECL(pScrn);
+  volatile u32 i, j, stat;
+
+  for (j = 0; j < 2; j++) {
+      /*
+       * From Henrik Harmsen :
+       *
+       * This is a kludge. We can't trust the status register. Don't
+       * know why... We shouldn't be forced to read the status reg and get
+       * a correct value more than once...
+       */
+      for(i = 0; i < MAXLOOP; i++) {
+	stat = STATUS();
+	if ((!(stat & (STATUS_HOSTBLTBUSY | STATUS_ENGINEBUSY))) &&
+	    ((stat & STATUS_FIFO) >= 4))
+	  break;
+      }
+  }
+  if (i == MAXLOOP) {
+    unsigned int status = STATUS();
+
+    WRXB(0x1FF, 0);
+    if (!xf86ServerIsExiting())
+	FatalError("Hung in ApmSync6422() (Status = 0x%08X)\n", status);
+  }
+  if (pApm->apmClip) {
+    SETCLIP_CTRL(0);
+    pApm->apmClip = FALSE;
+  }
+}
+#endif
+#include "apm_video.c"
+
+
+#undef	RDXB
+#undef	RDXW
+#undef	RDXL
+#undef	WRXB
+#undef	WRXW
+#undef	WRXL
+#undef	ApmWriteSeq
+#define RDXB	RDXB_M
+#define RDXW	RDXW_M
+#define RDXL	RDXL_M
+#define WRXB	WRXB_M
+#define WRXW	WRXW_M
+#define WRXL	WRXL_M
+#define ApmWriteSeq(idx, val)	do { APMVGAB(0x3C4) = (idx); APMVGAB(0x3C5) = (val); break; } while(1)
+#undef DPRINTNAME
+#undef A
+#undef DEPTH
+#undef PSZ
+#undef IOP_ACCESS
+#undef APM_SUFF_24
+#undef APM_SUFF_IOP