text: /********************************************************************
  Copyright 1998, 1999 by Precision Insight, Inc., Cedar Park, Texas.
  
                          All Rights Reserved
  
  Permission to use, copy, modify, distribute, and sell this software and
  its documentation for any purpose is hereby granted without fee,
  provided that the above copyright notice appear in all copies and that
  both that copyright notice and this permission notice appear in
  supporting documentation, and that the name of Precision Insight not be
  used in advertising or publicity pertaining to distribution of the
  software without specific, written prior permission.  Precision Insight
  and its suppliers make no representations about the suitability of this
  software for any purpose.  It is provided "as is" without express or 
  implied warranty.
  
  PRECISION INSIGHT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY
  SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  **********************************************************************/
  /* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/neomagic/neo_2200.c,v 1.19tsi Exp $ */
  /*
   * The original Precision Insight driver for
   * XFree86 v.3.3 has been sponsored by Red Hat.
   *
   * Authors:
   *   Jens Owen (jens@tungstengraphics.com)
   *   Kevin E. Martin (kevin@precisioninsight.com)
   *
   * Port to Xfree86 v.4.0
   *   1998, 1999 by Egbert Eich (Egbert.Eich@Physik.TU-Darmstadt.DE)
   */
  
  #ifdef HAVE_CONFIG_H
  #include "config.h"
  #endif
  
  #include "xf86.h"
  #include "xf86_OSproc.h"
  #include "xf86_ansic.h"
  #include "compiler.h"
  
  /* Drivers that use XAA need this */
  #include "xf86fbman.h"
  
  #include "miline.h"
  
  #include "neo.h"
  #include "neo_reg.h"
  #include "neo_macros.h"
  
  static void Neo2200Sync(ScrnInfoPtr pScrn);
  static void Neo2200SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir,
  					      int ydir, int rop,
  					      unsigned int planemask,
  					      int trans_color);
  #ifdef NOT_BROKEN
  static void Neo2200SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn, int srcX,
  						int srcY, int dstX, int dstY,
  						int w, int h);
  #else
  static void Neo2200SubsequentScreenToScreenCopyBroken(ScrnInfoPtr pScrn, int srcX,
  						int srcY, int dstX, int dstY,
  						int w, int h);
  #endif
  static void Neo2200SetupForSolidFillRect(ScrnInfoPtr pScrn, int color, int rop,
  				  unsigned int planemask);
  static void Neo2200SubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y,
  					   int w, int h);
  static void Neo2200SetupForScanlineCPUToScreenColorExpandFill(
                                                        ScrnInfoPtr pScrn,
  						      int fg, int bg,
  						      int rop,
  						unsigned int planemask);
  static void Neo2200SubsequentScanlineCPUToScreenColorExpandFill(
                                                          ScrnInfoPtr pScrn,
  							int x, int y,
  							int w, int h,
  							int skipleft);
  static void Neo2200SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno);
  #if 0
  static void Neo2200SetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
  					       int patternx,
  					       int patterny,
  					       int bg,
  					       int fg,
  					       int rop, 
  					       unsigned int planemask);
  static void Neo2200SubsequentMono8x8PatternFill(ScrnInfoPtr pScrn,
  						 int patternx,
  						 int patterny, 
  						 int x, int y,
  						 int w, int h);
  #endif
  
  
  static unsigned int neo2200Rop[16] = {
      0x000000,    /* 0x0000 - GXclear         */
      0x080000,    /* 0x1000 - GXand           */
      0x040000,    /* 0x0100 - GXandReverse    */
      0x0c0000,    /* 0x1100 - GXcopy          */
      0x020000,    /* 0x0010 - GXandInvert     */
      0x0a0000,    /* 0x1010 - GXnoop          */
      0x060000,    /* 0x0110 - GXxor           */
      0x0e0000,    /* 0x1110 - GXor            */
      0x010000,    /* 0x0001 - GXnor           */
      0x090000,    /* 0x1001 - GXequiv         */
      0x050000,    /* 0x0101 - GXinvert        */
      0x0d0000,    /* 0x1101 - GXorReverse     */
      0x030000,    /* 0x0011 - GXcopyInvert    */
      0x0b0000,    /* 0x1011 - GXorInverted    */
      0x070000,    /* 0x0111 - GXnand          */
      0x0f0000     /* 0x1111 - GXset           */
  };
  
  Bool 
  Neo2200AccelInit(ScreenPtr pScreen)
  {
      XAAInfoRecPtr infoPtr;
      ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      nPtr->AccelInfoRec = infoPtr = XAACreateInfoRec();
      if(!infoPtr) return FALSE;
  
      /*
       * Set up the main acceleration flags.
       */
      infoPtr->Flags = LINEAR_FRAMEBUFFER | OFFSCREEN_PIXMAPS;
      if(nAcl->cacheEnd > nAcl->cacheStart) infoPtr->Flags |= PIXMAP_CACHE;
  #if 0
      infoPtr->PixmapCacheFlags |= DO_NOT_BLIT_STIPPLES;
  #endif
      /* sync */
      infoPtr->Sync = Neo2200Sync;
  
      /* screen to screen copy */
      infoPtr->ScreenToScreenCopyFlags = (NO_TRANSPARENCY | NO_PLANEMASK);
      infoPtr->SetupForScreenToScreenCopy = 
  	Neo2200SetupForScreenToScreenCopy;
      infoPtr->SubsequentScreenToScreenCopy
  #ifdef NOT_BROKEN
  	= Neo2200SubsequentScreenToScreenCopy;
  #else
  	= Neo2200SubsequentScreenToScreenCopyBroken;
  #endif
  
      /* solid filled rectangles */
      infoPtr->SolidFillFlags = NO_PLANEMASK;
      infoPtr->SetupForSolidFill = 
  	Neo2200SetupForSolidFillRect;
      infoPtr->SubsequentSolidFillRect = 
  	Neo2200SubsequentSolidFillRect;
  
      /* cpu to screen color expansion */
      /*
       * We do CPUToScreenColorExpand (ab)using the Scanline functions:
       * the neo chipsets need byte padding however we can only do dword
       * padding. Fortunately the graphics engine doesn't choke if we
       * transfer up to 3 bytes more than it wants.
       */
  
      if (!nPtr->strangeLockups) {
  	
  	infoPtr->ScanlineCPUToScreenColorExpandFillFlags = ( NO_PLANEMASK |
  #ifdef NEO_DO_CLIPPING
  						LEFT_EDGE_CLIPPING |
  #endif
  						SCANLINE_PAD_DWORD |
  						CPU_TRANSFER_PAD_DWORD |
  						BIT_ORDER_IN_BYTE_MSBFIRST );
  	infoPtr->ScanlineColorExpandBuffers =
  	    (unsigned char **)xnfalloc(sizeof(char*));
  	infoPtr->ScanlineColorExpandBuffers[0] =
  	    (unsigned char *)(nPtr->NeoMMIOBase + 0x100000);
  	infoPtr->NumScanlineColorExpandBuffers = 1;
  	infoPtr->SetupForScanlineCPUToScreenColorExpandFill = 
  	    Neo2200SetupForScanlineCPUToScreenColorExpandFill;
  	infoPtr->SubsequentScanlineCPUToScreenColorExpandFill = 
  	    Neo2200SubsequentScanlineCPUToScreenColorExpandFill;
  	infoPtr->SubsequentColorExpandScanline =
  	    Neo2200SubsequentColorExpandScanline;
      }
      
  #if 0
      /* 8x8 pattern fills */
      infoPtr->Mono8x8PatternFillFlags = NO_PLANEMASK
  	| HARDWARE_PATTERN_PROGRAMMED_ORIGIN
  	|BIT_ORDER_IN_BYTE_MSBFIRST;
      
      infoPtr->SetupForMono8x8PatternFill = 
  	Neo2200SetupForMono8x8PatternFill;
      infoPtr->SubsequentMono8x8PatternFillRect = 
  	Neo2200SubsequentMono8x8PatternFill;
  #endif
  
      /*
       * Setup some global variables
       */
  
      /* Initialize for 8bpp or 15/16bpp support accelerated */
      switch (pScrn->bitsPerPixel) {
      case 8:
  	nAcl->BltModeFlags = NEO_MODE1_DEPTH8;
          nAcl->PixelWidth = 1;
  	break;
      case 15:
      case 16:
  	nAcl->BltModeFlags = NEO_MODE1_DEPTH16;
          nAcl->PixelWidth = 2;
  	break;
      case 24:
  	if (nPtr->noAccelSet || nPtr->NeoChipset == NM2230
  	    || nPtr->NeoChipset == NM2360
  	    || nPtr->NeoChipset == NM2380) {
  	    nAcl->BltModeFlags = NEO_MODE1_DEPTH24;
              nAcl->PixelWidth = 3;
  	} else
  	    return FALSE;
  	break;
      default:
  	return FALSE;
      }
      nAcl->Pitch = pScrn->displayWidth * nAcl->PixelWidth;    
  
      /* Initialize for widths */
      switch (pScrn->displayWidth) {
      case 320:
  	nAcl->BltModeFlags |= NEO_MODE1_X_320;
  	break;
      case 640:
  	nAcl->BltModeFlags |= NEO_MODE1_X_640;
  	break;
      case 800:
  	nAcl->BltModeFlags |= NEO_MODE1_X_800;
  	break;
      case 1024:
  	nAcl->BltModeFlags |= NEO_MODE1_X_1024;
  	break;
      case 1152:
  	nAcl->BltModeFlags |= NEO_MODE1_X_1152;
  	break;
      case 1280:
  	nAcl->BltModeFlags |= NEO_MODE1_X_1280;
  	break;
      case 1600:
  	nAcl->BltModeFlags |= NEO_MODE1_X_1600;
  	break;
      default:
  	return FALSE;
      }
  
      return (xaaSetupWrapper(pScreen, infoPtr, pScrn->depth, &nPtr->accelSync));
  }
  
  static void
  Neo2200Sync(ScrnInfoPtr pScrn)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
  
      WAIT_ENGINE_IDLE();
  }
  
  static void
  Neo2200SetupForScreenToScreenCopy(ScrnInfoPtr pScrn, int xdir, int ydir,
  				  int rop,
  				  unsigned int planemask,
  				  int trans_color)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      nAcl->tmpBltCntlFlags = (NEO_BC3_SKIP_MAPPING | neo2200Rop[rop]);
      /* set blt control */
      WAIT_ENGINE_IDLE();
      /*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
      OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
      OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags);
      OUTREG(NEOREG_PITCH, (nAcl->Pitch<<16) 
  	   | (nAcl->Pitch & 0xffff));
  }
  
  #ifdef NOT_BROKEN
  static void
  Neo2200SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
  				    int srcX, int srcY,
  				    int dstX, int dstY,
  				    int w, int h)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      if ((dstY < srcY) || ((dstY == srcY) && (dstX < srcX))) {
  	/* start with upper left corner */
  	WAIT_ENGINE_IDLE();
  #if 0
  	OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags);
  #endif
  	OUTREG(NEOREG_SRCSTARTOFF,
              (srcY * nAcl->Pitch) + (srcX * nAcl->PixelWidth));
  	OUTREG(NEOREG_DSTSTARTOFF,
              (dstY * nAcl->Pitch) + (dstX * nAcl->PixelWidth));
  	OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
      }
      else {
  	/* start with lower right corner */
  	WAIT_ENGINE_IDLE();
  #if 0
  	OUTREG(NEOREG_BLTCNTL, (nAcl->tmpBltCntlFlags 
  				| NEO_BC0_X_DEC
  				| NEO_BC0_DST_Y_DEC 
  				| NEO_BC0_SRC_Y_DEC));
  #endif
  	OUTREG(NEOREG_SRCSTARTOFF,
              ((srcY+h-1) * nAcl->Pitch) + ((srcX+w-1) 
  						 * nAcl->PixelWidth));
  	OUTREG(NEOREG_DSTSTARTOFF,
              ((dstY+h-1) * nAcl->Pitch) + ((dstX+w-1) 
  						 * nAcl->PixelWidth));
  	OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
      }
  }
  
  #else /* NOT_BROKEN */
  
  static void
  Neo2200SubsequentScreenToScreenCopyBroken(ScrnInfoPtr pScrn,
  					  int srcX, int srcY,
  					  int dstX, int dstY,
  					  int w, int h)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      if ((dstY < srcY) || ((dstY == srcY) && (dstX < srcX))) {
  	if ((((dstX < 64) && ((srcX + w + 64) >= pScrn->displayWidth)) ||
  	    ((dstX == 0) && (w > (pScrn->displayWidth - 64)))) && (w > 64)) {
  	    
  #define COPY_64 \
  	    OUTREG(NEOREG_SRCSTARTOFF,\
  		   (srcY * nAcl->Pitch) + (srcX * nAcl->PixelWidth));\
  	    OUTREG(NEOREG_DSTSTARTOFF,\
  		   (dstY * nAcl->Pitch) + (dstX * nAcl->PixelWidth));\
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (64));
  #define COPY_W \
  	    OUTREG(NEOREG_SRCSTARTOFF,\
  		   (srcY * nAcl->Pitch) + (srcX1 * nAcl->PixelWidth));\
  	    OUTREG(NEOREG_DSTSTARTOFF,\
  		   (dstY * nAcl->Pitch) + (dstX1 * nAcl->PixelWidth));\
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  
  	    int srcX1 = srcX + 64;
  	    int dstX1 = dstX + 64;
  	    w -= 64;
  	    /* start with upper left corner */
  	    WAIT_ENGINE_IDLE();
  	    OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags);
  	    if (srcX < dstX) {
  		COPY_W;
  	        WAIT_ENGINE_IDLE();
  	        COPY_64;
  	    } else {
  		COPY_64;
  	        WAIT_ENGINE_IDLE();
  		COPY_W;
  	    }
  #undef COPY_W
  #undef COPY_64
  	} else {
  	    /* start with upper left corner */
  	    WAIT_ENGINE_IDLE();
  	    OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags);
  	    OUTREG(NEOREG_SRCSTARTOFF,
  		   (srcY * nAcl->Pitch) + (srcX * nAcl->PixelWidth));
  	    OUTREG(NEOREG_DSTSTARTOFF,
  		   (dstY * nAcl->Pitch) + (dstX * nAcl->PixelWidth));
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  	}
      } else {
  	if (((((dstX + w) > (pScrn->displayWidth - 64)) && (srcX == 0))
  	    || (((dstX + w + 64) >= pScrn->displayWidth)
  		&& (w > (pScrn->displayWidth - 64)))) && (w > 64)) {
  #define COPY_64 \
  	    OUTREG(NEOREG_SRCSTARTOFF, \
  		   ((srcY+h-1) * nAcl->Pitch) + ((srcX1+64-1)  \
  						 * nAcl->PixelWidth)); \
  	    OUTREG(NEOREG_DSTSTARTOFF, \
  		   ((dstY+h-1) * nAcl->Pitch) + ((dstX1+64-1) \
  						 * nAcl->PixelWidth)); \
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (64 & 0xffff)); 
  #define COPY_W \
  	    OUTREG(NEOREG_SRCSTARTOFF, \
  		   ((srcY+h-1) * nAcl->Pitch) + ((srcX + w -1)  \
  						 * nAcl->PixelWidth)); \
  	    OUTREG(NEOREG_DSTSTARTOFF, \
  		   ((dstY+h-1) * nAcl->Pitch) + ((dstX + w -1) \
  						 * nAcl->PixelWidth)); \
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff)); 
  
  	    int srcX1, dstX1;
  	    
  	    w -= 64;
  	    srcX1 = srcX + w;
  	    dstX1 = dstX + w;
  	    /* start with lower right corner */
  	    WAIT_ENGINE_IDLE();
  	    OUTREG(NEOREG_BLTCNTL, (nAcl->tmpBltCntlFlags 
  				    | NEO_BC0_X_DEC
  				    | NEO_BC0_DST_Y_DEC 
  				    | NEO_BC0_SRC_Y_DEC));
  	    if (srcX < dstX) {
  	      COPY_64;
  	      WAIT_ENGINE_IDLE();
  	      COPY_W;
  	    } else {
  	      COPY_W;
  	      WAIT_ENGINE_IDLE();
  	      COPY_64;
  	    }
  #undef COPY_W
  #undef COPY_64
  	} else {
  	    /* start with lower right corner */
  	    WAIT_ENGINE_IDLE();
  	    OUTREG(NEOREG_BLTCNTL, (nAcl->tmpBltCntlFlags 
  				    | NEO_BC0_X_DEC
  				    | NEO_BC0_DST_Y_DEC 
  				    | NEO_BC0_SRC_Y_DEC));
  	    OUTREG(NEOREG_SRCSTARTOFF,
  		   ((srcY+h-1) * nAcl->Pitch) + ((srcX+w-1) 
  						 * nAcl->PixelWidth));
  	    OUTREG(NEOREG_DSTSTARTOFF,
  		   ((dstY+h-1) * nAcl->Pitch) + ((dstX+w-1) 
  						 * nAcl->PixelWidth));
  	    OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  	}
      }
  }
  
  #endif /* NOT_BROKEN */
  
  static void
  Neo2200SetupForSolidFillRect(ScrnInfoPtr pScrn, int color, int rop,
  			     unsigned int planemask)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      WAIT_ENGINE_IDLE();
  
      /* set blt control */
      /*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
      OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
      OUTREG(NEOREG_BLTCNTL, NEO_BC0_SRC_IS_FG    |
                             NEO_BC3_SKIP_MAPPING |
                             NEO_BC3_DST_XY_ADDR  |
                             NEO_BC3_SRC_XY_ADDR  | neo2200Rop[rop]);
  
      /* set foreground color */
      OUTREG(NEOREG_FGCOLOR, color);
  }
  
  
  static void
  Neo2200SubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
  
      WAIT_ENGINE_IDLE();
      OUTREG(NEOREG_DSTSTARTOFF, (y <<16) | (x & 0xffff));
      OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  }
  
  static void
  Neo2200SetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
   				      int fg, int bg,
  				      int rop,
  				      unsigned int planemask)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      if (bg == -1) {
  	/* transparent setup */
  	nAcl->tmpBltCntlFlags = ( NEO_BC0_SYS_TO_VID   |
  					 NEO_BC0_SRC_MONO     |
  					 NEO_BC0_SRC_TRANS    |
  					 NEO_BC3_SKIP_MAPPING |
  					 NEO_BC3_DST_XY_ADDR  | 
  #ifdef NEO_DO_CLIPPING
  				         NEO_BC3_CLIP_ON      |
  #endif
  				         neo2200Rop[rop]);
  
  	WAIT_ENGINE_IDLE();
  	/*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
  	OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
  	OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags);
  	OUTREG(NEOREG_FGCOLOR, fg);
      }
      else {
  	/* opaque setup */
          nAcl->tmpBltCntlFlags = ( NEO_BC0_SYS_TO_VID   |
  					 NEO_BC0_SRC_MONO     |
  					 NEO_BC3_SKIP_MAPPING |
  					 NEO_BC3_DST_XY_ADDR  | 
  #ifdef NEO_DO_CLIPPING
   				         NEO_BC3_CLIP_ON      |
  #endif
  					 neo2200Rop[rop]);
  
  	WAIT_ENGINE_IDLE();
  	/*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
  	OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
  	OUTREG(NEOREG_FGCOLOR, fg);
  	OUTREG(NEOREG_BGCOLOR, bg);
      }
  }
  
  
  static void
  Neo2200SubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
  					int x, int y,
  					int w, int h,
  					int skipleft)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
  #ifdef NEO_DO_CLIPPING
          w = (w + 31) & ~31;
  #else
      nAcl->CPUToScreenColorExpandFill_x = x;
      nAcl->CPUToScreenColorExpandFill_y = y;
      nAcl->CPUToScreenColorExpandFill_w = w;
      nAcl->CPUToScreenColorExpandFill_h = h;
      nAcl->CPUToScreenColorExpandFill_skipleft = skipleft;
  #endif
      OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags 
  	   | ((skipleft << 2) & 0x1C));
  #ifdef NEO_DO_CLIPPING
      OUTREG(NEOREG_CLIPLT, (y << 16) | (x + skipleft));
      OUTREG(NEOREG_CLIPRB, ((y + h) << 16) | (x + w));
  #endif
      OUTREG(NEOREG_SRCSTARTOFF, 0);
      OUTREG(NEOREG_DSTSTARTOFF, (y<<16) | (x & 0xffff));
  #ifdef NEO_DO_CLIPPING
      OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  #else
      OUTREG(NEOREG_XYEXT, (1<<16) | (w & 0xffff));
  #endif
  }
  
  static void
  Neo2200SubsequentColorExpandScanline(ScrnInfoPtr pScrn,	int bufno)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
  #ifdef NEO_DO_CLIPPING
      /* Should I be waiting for fifo slots to prevent retries ?
         How do I do that on this engine ? */
  #else
      if (!(--nAcl->CPUToScreenColorExpandFill_h))
  	return;
  
      WAIT_ENGINE_IDLE();
      OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags 
  	   | ((nAcl->CPUToScreenColorExpandFill_skipleft << 2) & 0x1C));
      OUTREG(NEOREG_SRCSTARTOFF, 0);
      OUTREG(NEOREG_DSTSTARTOFF, ((++nAcl->CPUToScreenColorExpandFill_y)<<16)
  	   | (nAcl->CPUToScreenColorExpandFill_x & 0xffff));
      OUTREG(NEOREG_XYEXT, (1<<16)
  	   | (nAcl->CPUToScreenColorExpandFill_w & 0xffff));
  #endif
  }
  
  #if 0
  static void
  Neo2200SetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
  				     int patternx,
  				     int patterny,
  				     int fg, int bg, 
  				     int rop, unsigned int planemask)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      if (bg == -1) {
  	/* transparent setup */
  	nAcl->tmpBltCntlFlags = ( NEO_BC0_SRC_MONO     |
  					 NEO_BC0_FILL_PAT     |
  					 NEO_BC0_SRC_TRANS    |
  					 NEO_BC3_SKIP_MAPPING |
  					 NEO_BC3_DST_XY_ADDR  | 
  					 neo2200Rop[rop]);
  
  	WAIT_ENGINE_IDLE();
  	/*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
  	OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
  	OUTREG(NEOREG_FGCOLOR, fg);
  	OUTREG(NEOREG_SRCSTARTOFF, 
  	    (patterny * pScrn->displayWidth * pScrn->bitsPerPixel 
  	     + patternx) >> 3);
      }
      else {
  	/* opaque setup */
  	nAcl->tmpBltCntlFlags = ( NEO_BC0_SRC_MONO     |
  					 NEO_BC0_FILL_PAT     |
  					 NEO_BC3_SKIP_MAPPING |
  					 NEO_BC3_DST_XY_ADDR  | 
  					 neo2200Rop[rop]);
  
  	WAIT_ENGINE_IDLE();
  	/*OUTREG16(NEOREG_BLTMODE, nAcl->BltModeFlags);*/
  	OUTREG(NEOREG_BLTSTAT, nAcl->BltModeFlags << 16);
  	OUTREG(NEOREG_FGCOLOR, fg);
  	OUTREG(NEOREG_BGCOLOR, bg);
  	OUTREG(NEOREG_SRCSTARTOFF, 
  	    (patterny * pScrn->displayWidth * pScrn->bitsPerPixel 
  	     + patternx) >> 3);
      }
  }
  
  
  static void
  Neo2200SubsequentMono8x8PatternFill(ScrnInfoPtr pScrn,
  				    int patternx,
  				    int patterny, 
  				    int x, int y,
  				    int w, int h)
  {
      NEOPtr nPtr = NEOPTR(pScrn);
      NEOACLPtr nAcl = NEOACLPTR(pScrn);
  
      patterny &= 0x7;
  
      WAIT_ENGINE_IDLE();
      OUTREG(NEOREG_BLTCNTL, nAcl->tmpBltCntlFlags | 
  	   (patterny << 20)       | 
  	   ((patternx << 10) & 0x1C00));
      OUTREG(NEOREG_SRCBITOFF, patternx);
      OUTREG(NEOREG_DSTSTARTOFF, (y<<16) | (x & 0xffff));
      OUTREG(NEOREG_XYEXT, (h<<16) | (w & 0xffff));
  }
  #endif
  