--- /dev/null
+diff -ruN XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile
+--- XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile Wed Jun 23 08:37:21 1999
++++ XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile Sat Oct 24 03:54:44 1998
+@@ -1,4 +1,4 @@
+-XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile,v 1.1.2.9 1999/06/23 12:37:21 hohndel Exp $
++XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/Imakefile,v 1.1.2.8 1998/10/22 04:31:05 hohndel Exp $
+ XCOMM
+ XCOMM This is an Imakefile for the cyrix driver.
+ XCOMM
+@@ -6,10 +6,10 @@
+ #include <Server.tmpl>
+
+ SRCS = cyrix_driver.c cyrix_accel.c cyrix_cursor.c cyrix_cmap.c cyrix_bank.s \
+- cyrix_asm.s gxrender.c
++ cyrix_asm.s
+
+ OBJS = cyrix_driver.o cyrix_accel.o cyrix_cursor.o cyrix_cmap.o cyrix_bank.o \
+- cyrix_asm.o gxrender.o
++ cyrix_asm.o
+
+ DEFINES = -DPSZ=8
+
+@@ -61,7 +61,6 @@
+ InstallLinkKitNonExecFile(cyrix_driver.c,$(LINKKITDIR)/drivers/vga256/cyrix)
+ InstallLinkKitNonExecFile(cyrix_bank.s,$(LINKKITDIR)/drivers/vga256/cyrix)
+ InstallLinkKitNonExecFile(cyrix_asm.s,$(LINKKITDIR)/drivers/vga256/cyrix)
+-InstallLinkKitNonExecFile(gxrender.c,$(LINKKITDIR)/drivers/vga256/cyrix)
+ InstallLinkKitNonExecFile(Imakefile,$(LINKKITDIR)/drivers/vga256/cyrix)
+
+ XCOMM
+@@ -82,4 +81,3 @@
+ XCOMM Install Link Kit Non Exec File(Imakefile,$(LINKKITDIR)/drivers/vga16/cyrix)
+
+ DependTarget()
+-
+diff -ruN XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h
+--- XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h Tue Dec 22 02:49:58 1998
++++ XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h Fri Nov 6 11:41:51 1998
+@@ -1,5 +1,5 @@
+
+-/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h,v 1.1.2.6 1998/12/22 07:49:58 hohndel Exp $ */
++/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix.h,v 1.1.2.5 1998/11/06 09:47:02 hohndel Exp $ */
+
+ /* this code is partly based on the MediaGX sources from the GGI project
+ based on CYRIX example code (gxvideo.c) and included with CYRIX and
+@@ -88,10 +88,9 @@
+ #define CYRIXsetVectorMode() \
+ GX_REG(GP_VECTOR_MODE) = (vectorMode)
+
+-#define IfDest(rop, planemask, val) \
+- (( (((rop) & 0x5) ^ (((rop) & 0xA) >> 1)) \
+- || (~((planemask) & 0xFF)) \
+- ) ? (val) : 0)
++#define IfDest(xrop, val) ((((xrop) & 0x5) ^ (((xrop) & 0xA) >> 1)) ? (val) : 0)
++
++
+
+ /* Generic MediaGX hardware register and value definitions */
+
+diff -ruN XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c
+--- XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c Wed Jun 23 08:37:21 1999
++++ XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c Fri Nov 6 11:41:51 1998
+@@ -1,7 +1,6 @@
+-/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c,v 1.1.2.6 1999/06/23 12:37:21 hohndel Exp $ */
++/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_accel.c,v 1.1.2.3 1998/11/06 09:47:04 hohndel Exp $ */
+
+ /*
+- * Copyright 1999 by Brian Falardeau.
+ * Copyright 1998 by Annius Groenink, Amsterdam.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+@@ -33,6 +32,7 @@
+ #include "cyrix.h"
+ #include "miline.h"
+
++
+ /* size of color expand source area (embedded in frame buffer) */
+ #define CYRIXexpandSize 32768
+
+@@ -41,64 +41,17 @@
+ upper nybble inverted X raster operation (bits 0 - 3 correspond to
+ bits 3 - 0 and 7 - 4 in Windows style ROP). In some routines,
+ the role of source and pattern is inverted. */
+-
+-/* The following ROPs only use pattern and destination data. */
+-/* They are used when the planemask specifies all planes (no mask). */
+-
+-static const int windowsROPpat[16] = {
+- 0x00, /* GXclear = 0 */
+- 0xA0, /* GXand = pat AND dst */
+- 0x50, /* GXandReverse = pat AND NOT dst */
+- 0xF0, /* GXcopy = pat */
+- 0x0A, /* GXandInverted = NOT pat AND dst */
+- 0xAA, /* GXnoop = dst */
+- 0x5A, /* GXxor = pat XOR dst */
+- 0xFA, /* GXor = pat OR dst */
+- 0x05, /* GXnor = NOT pat AND NOT dst */
+- 0xA5, /* GXequiv = NOT pat XOR dst */
+- 0x55, /* GXinvert = NOT dst */
+- 0xF5, /* GXorReverse = pat OR NOT dst */
+- 0x0F, /* GXcopyInverted = NOT pat */
+- 0xAF, /* GXorInverted = NOT pat OR dst */
+- 0x5F, /* GXnand = NOT pat OR NOT dst */
+- 0xFF, /* GXset = 1 */
+-};
+-
+-/* The following ROPs use source data to specify a planemask. */
+-/* If the planemask (src) is one, then the result is the appropriate */
+-/* combination of pattern and destination data. If the planemask (src) */
+-/* is zero, then the result is always just destination data. */
+-
+-static const int windowsROPsrcMask[16] = {
+- 0x22, /* GXclear => 0 if src = 1, dst if src = 0 */
+- 0xA2, /* GXand = pat AND dst if src = 1, dst if src = 0 */
+- 0x62, /* GXandReverse = pat AND NOT dst if src = 1, dst if src = 0 */
+- 0xE2, /* GXcopy = pat if src = 1, dst if src = 0 */
+- 0x2A, /* GXandInverted = NOT pat AND dst if src = 1, dst if src = 0 */
+- 0xAA, /* GXnoop = dst if src = 1, dst if src = 0 */
+- 0x6A, /* GXxor = pat XOR dst if src = 1, dst if src = 0 */
+- 0xEA, /* GXor = pat OR dst if src = 1, dst if src = 0 */
+- 0x26, /* GXnor = NOT pat AND NOT dst if src = 1, dst if src = 0 */
+- 0xA6, /* GXequiv = NOT pat XOR dst if src = 1, dst if src = 0 */
+- 0x66, /* GXinvert = NOT dst if src = 1, dst if src = 0 */
+- 0xE6, /* GXorReverse = pat OR NOT dst if src = 1, dst if src = 0 */
+- 0x2E, /* GXcopyInverted = NOT pat if src = 1, dst if src = 0 */
+- 0xAE, /* GXorInverted = NOT pat OR dst if src = 1, dst if src = 0 */
+- 0x6E, /* GXnand = NOT pat OR NOT dst if src = 1, dst if src = 0 */
+- 0xEE, /* GXset = 1 if src = 1, dst if src = 0 */
+-};
+-
+-/* The following ROPs use pattern data to specify a planemask. */
+-/* If the planemask (pat) is one, then the result is the appropriate */
+-/* combination of source and destination data. If the planemask (pat) */
+-/* is zero, then the result is always just destination data. */
+-
+ static const int windowsROPpatMask[16] = { 0x0A, 0x8A, 0x4A, 0xCA,
+ 0x2A, 0xAA, 0x6A, 0xEA,
+ 0x1A, 0x9A, 0x5A, 0xDA,
+ 0x3A, 0xBA, 0x7A, 0xFA };
+
++static const int windowsROPsrcMask[16] = { 0x22, 0xA2, 0x62, 0xE2,
++ 0x2A, 0xAA, 0x6A, 0xEA,
++ 0x26, 0xA6, 0x66, 0xE6,
++ 0x2E, 0xAE, 0x6E, 0xEE };
+
++static int bltBufWidth;
+
+ static int blitMode;
+ static int vectorMode;
+@@ -106,85 +59,25 @@
+ static int copyXdir;
+ static int setBlitModeOnSync = 0;
+
+-/* STATIC VARIABLES FOR THIS FILE */
+-/* Used to maintain state between setup and rendering calls. */
+-
+-static int CYRIXsavedROP;
+-static int CYRIXtransparent;
+-static int CYRIXtransColor;
+-static int CYRIXstartMonoExpand = 0;
+-
+-static unsigned short CYRIXsaveX, CYRIXsaveY, CYRIXsaveW, CYRIXsaveH;
+
+ /* Forward declaration of functions used in the driver */
+-
+ void CYRIXAccelSync();
+ void CYRIXAccelInit();
+ void CYRIXSetupForFillRectSolid();
+ void CYRIXSubsequentFillRectSolid();
+-void CYRIXSetupFor8x8PatternColorExpand();
+-void CYRIXSubsequent8x8PatternColorExpand();
+ void CYRIXSetupForScreenToScreenCopy();
+ void CYRIXSubsequentScreenToScreenCopy();
+-
+ void CYRIXSubsequentBresenhamLine();
++void CYRIXSetupFor8x8PatternColorExpand();
++void CYRIXSubsequent8x8PatternColorExpand();
+ void CYRIXSetupForCPUToScreenColorExpand();
+ void CYRIXSubsequentCPUToScreenColorExpand();
+
+-/* Routines in GXRENDER.C */
+-
+-void gxr_initialize(unsigned char *regptr, unsigned short bpp,
+- unsigned short BB0base, unsigned short BB1base,
+- unsigned short BBwidthPixels);
+-
+-void gxr_wait_until_idle(void);
+-
+-void gxr_load_solid_source(unsigned short color);
+-
+-void gxr_load_mono_source(unsigned short bgcolor, unsigned short fgcolor,
+- unsigned short transparent);
+-
+-void gxr_load_solid_pattern(unsigned short color);
+-
+-void gxr_load_mono_pattern(unsigned short bgcolor, unsigned short fgcolor,
+- unsigned long data0, unsigned long data1, unsigned char transparency);
+-
+-void gxr_load_raster_operation(unsigned char rop);
+-
+-void gxr_pattern_fill(unsigned short x, unsigned short y,
+- unsigned short width, unsigned short height);
+-
+-void gxr_screen_to_screen_blt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height);
+-
+-void gxr_screen_to_screen_xblt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned short color);
+-
+-void gxr_text_glyph(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned char *data, unsigned short pitch);
+-
+-void gxr_bresenham_line(unsigned short x, unsigned short y,
+- unsigned short length, unsigned short initerr,
+- unsigned short axialerr, unsigned short diagerr,
+- unsigned short flags);
+-
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXAccelInit
+-//
+-// This routine hooks the acceleration routines and sets appropriate flags.
+-//---------------------------------------------------------------------------
+-*/
+
++/* Acceleration init function, sets up pointers to our accelerated functions */
+ void
+ CYRIXAccelInit()
+-{
+- int bltBufWidth;
+-
+- /* General acceleration flags */
++{ /* General acceleration flags */
+ xf86AccelInfoRec.Flags = PIXMAP_CACHE
+ | BACKGROUND_OPERATIONS
+ | HARDWARE_PATTERN_SCREEN_ORIGIN
+@@ -245,344 +138,232 @@
+
+ /* calculate the pixel width of a blit buffer for convenience */
+ bltBufWidth = CYRIXbltBufSize / (vgaBitsPerPixel / 8);
++}
+
+- /* pass parameters to GXRENDER.C file */
+
+- gxr_initialize((unsigned char *) GXregisters,
+- (unsigned short) vgaBitsPerPixel,
+- (unsigned short) CYRIXbltBuf0Address,
+- (unsigned short) CYRIXbltBuf1Address,
+- (unsigned short) bltBufWidth);
+-}
++/* set colors - called through access macros in cyrix.h */
++static __inline__ void CYRIXsetColors01(reg, col0, col1)
++int reg;
++int col0;
++int col1;
++{ if (vgaBitsPerPixel == 16)
++ GX_REG(reg) = ((col1 & 0xFFFF) << 16) | (col0 & 0xFFFF);
++ else
++ { col0 &= 0xFF;
++ col1 &= 0xFF;
++ GX_REG(reg) = (col1 << 24) | (col1 << 16) | (col0 << 8) | col0;
++} }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXAccelSync
+-//
+-// This routine is called before accessing the frame buffer directly to
+-// make sure that the graphics pipeline is idle. It is also called after
+-// loading the monochrome data into BB0 for bitmap to screen BLTs.
+-//---------------------------------------------------------------------------
+-*/
+
++/* The generic Sync() function that waits for everything to
++ be completed (e.g. before writing to the frame buffer
++ directly). */
+ void
+ CYRIXAccelSync()
+-{
+- /* CHECK IF END TO CPU TO SCREEN EXPAND BLT */
+-
+- if (CYRIXstartMonoExpand)
+- {
+- /* START CPU TO SCREEN EXPAND BLT */
+- /* Data has already been loaded into BB0, so use NULL pointer. */
+-
+- /* this is formally incorrect: XAA may use both BB0 and BB1
+- for the text source bitmap, so READ_DST_FB1 should not be
+- used. So far, this problem has not manifested itself in
+- practice. */
+-
+- CYRIXstartMonoExpand = 0;
+- gxr_text_glyph(0, 0, CYRIXsaveX, CYRIXsaveY, CYRIXsaveW,
+- CYRIXsaveH, 0, 0);
++{ if (setBlitModeOnSync)
++ { setBlitModeOnSync = 0;
++ CYRIXsetupSync();
++ CYRIXsetBlitMode();
+ }
+-
+- /* WAIT UNTIL IDLE */
+-
+- gxr_wait_until_idle();
++ while (GX_REG(GP_BLIT_STATUS) &
++ (BS_BLIT_BUSY|BS_PIPELINE_BUSY|BS_BLIT_PENDING));
+ }
+
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSetupForFillRectSolid
+-//
+-// This routine is called to setup the solid pattern color for future
+-// rectangular fills or vectors.
+-//---------------------------------------------------------------------------
+-*/
+-
++/* Solid rectangles */
+ void
+ CYRIXSetupForFillRectSolid(color, rop, planemask)
+ int color, rop;
+ unsigned int planemask;
+-{
+- /* LOAD THE SOLID PATTERN COLOR */
+-
+- gxr_load_solid_pattern((unsigned short) color);
+-
+- /* CHECK IF PLANEMASK IS NOT USED (ALL PLANES ENABLED) */
+-
+- if (planemask == (unsigned int) -1)
+- {
+- /* use normal pattern ROPs if all planes are enabled */
+-
+- gxr_load_raster_operation(windowsROPpat[rop & 0x0F]);
+- }
+- else
+- {
+- /* select ROP that uses planemask in src data */
+-
+- gxr_load_solid_source((unsigned short) planemask);
+- gxr_load_raster_operation(windowsROPsrcMask[rop & 0x0F]);
+- }
++{ CYRIXsetupSync();
++ CYRIXsetSourceColors01(color, color);
++ CYRIXsetPatColors01(planemask, 0);
++ CYRIXsetPatMode(rop, RM_PAT_DISABLE);
++ blitMode = BM_READ_SRC_NONE | BM_WRITE_FB | BM_SOURCE_EXPAND
++ | IfDest(rop, BM_READ_DST_FB0);
++ vectorMode = IfDest(rop, VM_READ_DST_FB);
+ }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSubsequentFillRectSolid
+-//
+-// This routine is called to fill a rectangular region using the previously
+-// specified solid pattern and raster operation.
+-//
+-// Sample application uses:
+-// - Window backgrounds.
+-// - x11perf: rectangle tests (-rect500).
+-// - x11perf: fill trapezoid tests (-trap100).
+-// - x11perf: horizontal line segments (-hseg500).
+-//---------------------------------------------------------------------------
+-*/
+
+ void
+ CYRIXSubsequentFillRectSolid(x, y, w, h)
+ int x, y, w, h;
+-{
+- /* call routine to fill rectangular region */
+-
+- gxr_pattern_fill((unsigned short) x, (unsigned short) y,
+- (unsigned short) w, (unsigned short) h);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSetupFor8x8PatternColorExpand
+-//
+-// This routine is called to setup the monochrome pattern (8x8) and raster
+-// operation for future rectangular fills.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void CYRIXSetupFor8x8PatternColorExpand(patternx, patterny, bg, fg, rop, planemask)
+-int patternx, patterny;
+-int bg, fg, rop;
+-unsigned int planemask;
+-{ int trans = (bg == -1);
+-
+- /* LOAD PATTERN COLORS AND DATA */
+-
+- gxr_load_mono_pattern((unsigned short) bg, (unsigned short) fg,
+- (unsigned long) patternx, (unsigned long) patterny,
+- (unsigned char) trans);
+-
+- /* CHECK IF PLANEMASK IS NOT USED (ALL PLANES ENABLED) */
+-
+- if (planemask == (unsigned int) -1)
+- {
+- /* use normal pattern ROPs if all planes are enabled */
+-
+- gxr_load_raster_operation(windowsROPpat[rop & 0x0F]);
+- }
+- else
+- {
+- /* select ROP that uses planemask in src data */
+-
+- gxr_load_solid_source((unsigned short) planemask);
+- gxr_load_raster_operation(windowsROPsrcMask[rop & 0x0F]);
++{ /* divide the operation into columns if required; use twice the
++ blit buffer width because buffer 0 will overflow into buffer 1 */
++ while (w > 2 * bltBufWidth)
++ { CYRIXSubsequentFillRectSolid(x, y, 2 * bltBufWidth, h);
++ x += 2 * bltBufWidth;
++ w -= 2 * bltBufWidth;
+ }
++ CYRIXsetupSync();
++ CYRIXsetDstXY(x, y);
++ CYRIXsetWH(w, h);
++ CYRIXsetBlitMode();
+ }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSubsequent8x8PatternColorExpand
+-//
+-// This routine is called to fill a rectangular region using the previously
+-// specified monochrome pattern (8x8) and raster operation.
+-//
+-// Sample application uses:
+-// - Patterned desktops
+-// - x11perf: stippled rectangle tests (-srect500).
+-// - x11perf: opaque stippled rectangle tests (-osrect500).
+-//---------------------------------------------------------------------------
+-*/
+-
+-void CYRIXSubsequent8x8PatternColorExpand(patternx, patterny, x, y, w, h)
+-int patternx, patterny;
+-int x, y, w, h;
+-{
+- /* call routine to fill rectangular region */
+-
+- gxr_pattern_fill((unsigned short) x, (unsigned short) y,
+- (unsigned short) w, (unsigned short) h);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSetupForScreenToScreenCopy
+-//
+-// This routine is called to setup the planemask and raster operation
+-// for future screen to screen BLTs.
+-//---------------------------------------------------------------------------
+-*/
+
++/* Screen to screen copies */
+ void
+ CYRIXSetupForScreenToScreenCopy(xdir, ydir, rop, planemask, transparency_color)
+ int xdir, ydir;
+ int rop;
+ unsigned int planemask;
+ int transparency_color;
+-{
+- /* LOAD PLANEMASK INTO PATTERN DATA */
++{ CYRIXsetupSync();
++ CYRIXsetPatColors01(planemask, 0);
+
+- gxr_load_solid_pattern((unsigned short) planemask);
+-
+- /* SET RASTER OPERATION FOR USING PATTERN AS PLANE MASK */
++ if (transparency_color == -1)
++ { CYRIXsetPatMode(rop, RM_PAT_DISABLE);
++ transMode = 0;
++ }
++ else
++ { CYRIXsetPatModeTrans(RM_PAT_DISABLE);
++ transMode = 1;
+
+- gxr_load_raster_operation(windowsROPpatMask[rop & 0x0F]);
++ /* fill blit buffer 1 with the transparency color */
++ if (vgaBitsPerPixel == 16)
++ { int k = CYRIXbltBufSize / 4;
++ CARD32 val = (transparency_color << 16) |
++ transparency_color;
++ volatile CARD32* buf = &(GX_REG(CYRIXbltBuf1Address));
++
++ while (--k >= 0) buf[k] = val;
++ }
++ else
++ memset(GXregisters + CYRIXbltBuf1Address,
++ transparency_color, CYRIXbltBufSize);
++ }
+
+- /* SAVE TRANSPARENCY FLAG */
++ blitMode = BM_READ_SRC_FB | BM_WRITE_FB | BM_SOURCE_COLOR
++ | (transMode ? IfDest(rop, BM_READ_DST_FB1) : BM_READ_DST_NONE)
++ | (ydir < 0 ? BM_REVERSE_Y : 0);
+
+- CYRIXtransparent = (transparency_color == -1) ? 0 : 1;
+- CYRIXtransColor = transparency_color;
++ copyXdir = xdir;
+ }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSubsequentScreenToScreenCopy
+-//
+-// This routine is called to perform a screen to screen BLT using the
+-// previously specified planemask, raster operation, and transparency flag.
+-//
+-// Sample application uses (non-transparent):
+-// - Moving windows.
+-// - x11perf: scroll tests (-scroll500).
+-// - x11perf: copy from window to window (-copywinwin500).
+-//
+-// No application found using transparency.
+-//---------------------------------------------------------------------------
+-*/
+-
+ void
+ CYRIXSubsequentScreenToScreenCopy(x1, y1, x2, y2, w, h)
+ int x1, y1, x2, y2, w, h;
+-{
+- if (CYRIXtransparent)
+- {
+- /* CALL ROUTINE FOR TRANSPARENT SCREEN TO SCREEN BLT */
+- /* Should only be called for the "copy" raster operation. */
+-
+- gxr_screen_to_screen_xblt(
+- (unsigned short) x1, (unsigned short) y1,
+- (unsigned short) x2, (unsigned short) y2,
+- (unsigned short) w, (unsigned short) h,
+- (unsigned short) CYRIXtransColor);
++{ int up = (blitMode & BM_REVERSE_Y);
++
++ /* divide the operation into columns when necessary */
++ if (copyXdir < 0)
++ { int x_offset = w - bltBufWidth;
++
++ while (x_offset > 0)
++ { CYRIXSubsequentScreenToScreenCopy(x1 + x_offset, y1,
++ x2 + x_offset, y2,
++ bltBufWidth, h);
++ x_offset -= bltBufWidth;
++ w -= bltBufWidth;
++ } }
++ else while (w > bltBufWidth)
++ { CYRIXSubsequentScreenToScreenCopy(x1, y1, x2, y2,
++ bltBufWidth, h);
++ x1 += bltBufWidth;
++ x2 += bltBufWidth;
++ w -= bltBufWidth;
+ }
+- else
+- {
+- /* CALL ROUTINE FOR NORMAL SCREEN TO SCREEN BLT */
+
+- gxr_screen_to_screen_blt(
+- (unsigned short) x1, (unsigned short) y1,
+- (unsigned short) x2, (unsigned short) y2,
+- (unsigned short) w, (unsigned short) h);
++ CYRIXsetupSync();
++ CYRIXsetSrcXY(x1, (up ? (y1 + h - 1) : y1));
++ CYRIXsetDstXY(x2, (up ? (y2 + h - 1) : y2));
++
++ /* in transparent mode, one line reads the transparency color
++ into a processor-internal register, and the remaining lines
++ can be done in a single second pass */
++ if (transMode)
++ { blitMode |= BM_READ_DST_BB1;
++ CYRIXsetWH(w, 1);
++ CYRIXsetBlitMode();
++ h--;
++ if (!h) return;
++ if (up) { y1--; y2--; }
++ else { y1++; y2++; }
++ CYRIXsetupSync();
++ blitMode &= ~(BM_READ_DST_BB1);
+ }
++ CYRIXsetWH(w, h);
++ CYRIXsetBlitMode();
+ }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSubsequentBresenhamLine
+-//
+-// This routine is called to render a vector using the specified Bresenham
+-// parameters.
+-//
+-// Sample application uses:
+-// - Window outlines on window move.
+-// - x11perf: line segments (-seg500).
+-//---------------------------------------------------------------------------
+-*/
+
++/* Bresenham lines */
+ void
+ CYRIXSubsequentBresenhamLine(x1, y1, octant, err, e1, e2, length)
+ int x1, y1, octant, err, e1, e2, length;
+-{
+- unsigned short flags;
+-
+- /* DETERMINE YMAJOR AND DIRECTION FLAGS */
+-
+- if (octant & YMAJOR)
+- { flags = VM_Y_MAJOR;
+- if (!(octant & XDECREASING)) flags |= VM_MINOR_INC;
+- if (!(octant & YDECREASING)) flags |= VM_MAJOR_INC;
++{ if (octant & YMAJOR)
++ { vectorMode = (vectorMode & VM_READ_DST_FB) | VM_Y_MAJOR;
++ if (!(octant & XDECREASING)) vectorMode |= VM_MINOR_INC;
++ if (!(octant & YDECREASING)) vectorMode |= VM_MAJOR_INC;
+ }
+ else
+- { flags = VM_X_MAJOR;
+- if (!(octant & XDECREASING)) flags |= VM_MAJOR_INC;
+- if (!(octant & YDECREASING)) flags |= VM_MINOR_INC;
++ { vectorMode = (vectorMode & VM_READ_DST_FB) | VM_X_MAJOR;
++ if (!(octant & XDECREASING)) vectorMode |= VM_MAJOR_INC;
++ if (!(octant & YDECREASING)) vectorMode |= VM_MINOR_INC;
+ }
+
+- /* CALL ROUTINE TO DRAW VECTOR */
+-
+- gxr_bresenham_line((unsigned short) x1, (unsigned short) y1,
+- (unsigned short) length, (unsigned short) err,
+- (unsigned short) e1, (unsigned short) e2, (unsigned short) flags);
++ CYRIXsetupSync();
++ CYRIXsetDstXY(x1, y1);
++ CYRIXsetWH(length, (err & 0xFFFF));
++ CYRIXsetSrcXY((e1 & 0xFFFF), (e2 & 0xFFFF));
++ CYRIXsetVectorMode();
+ }
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSetupForCPUToScreenColorExpand
+-//
+-// This routine is called to setup the planemask, colors, and raster
+-// operation for future monocrome bitmap to screen BLTs.
+-//---------------------------------------------------------------------------
+-*/
+
+-void CYRIXSetupForCPUToScreenColorExpand(bg, fg, rop, planemask)
++/* 8x8 pattern color expand */
++void CYRIXSetupFor8x8PatternColorExpand(patternx, patterny, bg, fg, rop, planemask)
++int patternx, patterny;
+ int bg, fg, rop;
+ unsigned int planemask;
+ { int trans = (bg == -1);
+
+- /* LOAD SOURCE COLORS */
++ CYRIXsetupSync();
++ CYRIXsetSourceColors01(planemask, planemask);
++ CYRIXsetPatColors01(trans ? 0 : bg, fg);
++ CYRIXsetPatData(patternx, patterny);
++ CYRIXsetPatModeX(rop, RM_PAT_MONO | (trans ? RM_PAT_TRANSPARENT : 0));
+
+- gxr_load_mono_source((unsigned short) bg, (unsigned short) fg,
+- (unsigned short) trans);
++ blitMode = BM_READ_SRC_NONE | BM_WRITE_FB | BM_SOURCE_EXPAND
++ | (trans ? IfDest(rop, BM_READ_DST_FB0) : BM_READ_DST_NONE);
++}
+
+- /* LOAD PLANEMASK INTO PATTERN DATA */
++void CYRIXSubsequent8x8PatternColorExpand(patternx, patterny, x, y, w, h)
++int patternx, patterny;
++int x, y, w, h;
++{ CYRIXSubsequentFillRectSolid(x, y, w, h);
++}
+
+- gxr_load_solid_pattern((unsigned short) planemask);
+-
+- /* SET RASTER OPERATION FOR USING PATTERN AS PLANE MASK */
+
+- gxr_load_raster_operation(windowsROPpatMask[rop & 0x0F]);
+-}
++/* CPU-to-screen color expansion */
++void CYRIXSetupForCPUToScreenColorExpand(bg, fg, rop, planemask)
++int bg, fg, rop;
++unsigned int planemask;
++{ int trans = (bg == -1);
+
+-/*
+-//---------------------------------------------------------------------------
+-// CYRIXSubsequentCPUToScreenColorExpand
+-//
+-// This routine is called to render expanded monocrome bitmap data to the
+-// screen using the previously specified colors and raster operation. Since
+-// the server loads the monochrome data into BB0, not the driver, this
+-// routine just sets a flag and saves the parameters to use when the server
+-// is done loading the data and calls the CYRIXAccelSync function.
+-//
+-// Sample application uses:
+-// - Text in windows.
+-// - x11perf: text (-ftext, -f8text, -f9text, ...).
+-//---------------------------------------------------------------------------
+-*/
++ CYRIXsetupSync();
++ CYRIXsetSourceColors01(trans ? 0 : bg, fg);
++ CYRIXsetPatColors01(planemask, 0);
++
++ CYRIXsetPatMode(rop, RM_PAT_DISABLE | (trans ? RM_SRC_TRANSPARENT : 0));
++
++ /* this is formally incorrect: XAA may use both BB0 and BB1
++ for the text source bitmap, so READ_DST_FB1 should not be
++ used. So far, this problem has not manifested itself in
++ practice. */
++ blitMode = BM_READ_SRC_BB0 | BM_WRITE_FB | BM_SOURCE_EXPAND
++ | (trans ? IfDest(rop, BM_READ_DST_FB1) : BM_READ_DST_NONE);
++}
+
+ void CYRIXSubsequentCPUToScreenColorExpand(x, y, w, h, skipleft)
+ int x, y, w, h;
+ int skipleft;
+-{
+- CYRIXstartMonoExpand = 1;
+- CYRIXsaveX = x;
+- CYRIXsaveY = y;
+- CYRIXsaveW = w;
+- CYRIXsaveH = h;
+-
+- /* WAIT UNTIL IDLE BEFORE ALLOWING WRITES TO BLT BUFFERS */
+- /* Server will load the monochrome data into BB0 after this. */
++{ CYRIXsetupSync();
++ CYRIXsetSrcXY(0, 0);
++ CYRIXsetDstXY(x, y);
++ CYRIXsetWH(w, h);
+
+- gxr_wait_until_idle();
++ CYRIXAccelSync();
++ setBlitModeOnSync = 1;
+ }
+-
+-/* END OF FILE */
+
+diff -ruN XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c
+--- XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c Wed Jun 23 08:37:22 1999
++++ XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c Fri Nov 6 11:41:51 1998
+@@ -1,12 +1,9 @@
+-/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c,v 1.1.2.7 1999/06/23 12:37:22 hohndel Exp $ */
++/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/cyrix_driver.c,v 1.1.2.6 1998/11/06 09:47:08 hohndel Exp $ */
+ /*
+- * Copyright 1999 by Brian Falardeau
+ * Copyright 1998 by Annius V. Groenink (A.V.Groenink@zfc.nl, avg@cwi.nl),
+ * Dirk H. Hohndel (hohndel@suse.de),
+ * Portions: the GGI project & confidential CYRIX databooks.
+ *
+- * Substitute Brian Falardeau into a copy of the following legal jargon...
+- *
+ * 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
+@@ -25,17 +22,13 @@
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
++/* $XConsortium: $ */
+
+ /*************************************************************************/
+
+ /*
+ Log for the cyrix driver source as a whole
+
+- May 1999, Brian Falardeau:
+- - Fixed interaction with SoftVGA for setting 2K pitch at 1280x1024.
+- - Added CRTC tables for 60 Hz and 75 Hz modes.
+- - Removed enabling display compression directly for VSA1.
+-
+ 5th Nov 1998 avg - Fixed blit buffer organization using CPU_WRITE
+ instruction. Support for older chipsets (color
+ treatment and different CPU_WRITE opcode).
+@@ -115,35 +108,50 @@
+ #include "extensions/xf86dgastr.h"
+ #endif
+
++#ifdef XF86VGA16
++#define MONOVGA
++#endif
+
++#if !defined(MONOVGA) && !defined(XF86VGA16)
+ #include "vga256.h"
++#endif
++
+ #include "cyrix.h"
+
+ pciTagRec CyrixPciTag;
+ extern vgaHWCursorRec vgaHWCursor;
+
+-#define NUM_STD_CRTC_REGS 25
+-#define NUM_EXT_CRTC_REGS 16
+-
+ typedef struct {
+ vgaHWRec std; /* IBM VGA */
+ struct vgaCYRIXext
+- {
+- /* override of miscellaneous output register value */
+-
+- unsigned char miscOutput;
+-
+- /* override of standard CRTC register values */
+-
+- unsigned char stdCRTCregs[NUM_STD_CRTC_REGS];
+-
+- /* extended CRTC register values (specific to MediaGX) */
+-
+- unsigned char extCRTCregs[NUM_EXT_CRTC_REGS];
++ { /* extended SoftVGA registers */
++ unsigned char VerticalTimingExtension;
++ unsigned char ExtendedAddressControl;
++ unsigned char ExtendedOffset;
++ unsigned char ExtendedColorControl;
++ unsigned char DisplayCompression;
++ unsigned char DriverControl;
++ unsigned char DACControl;
++ unsigned char ClockControl;
++ unsigned char CrtClockFrequency;
++ unsigned char CrtClockFrequencyFraction;
++ unsigned char RefreshRate;
++
++ /* display controller hardware registers */
++ CARD32 DcGeneralCfg;
++ CARD32 DcCursStOffset;
++ CARD32 DcCbStOffset;
++ CARD32 DcLineDelta;
++ CARD32 DcBufSize;
++ CARD32 DcCursorX;
++ CARD32 DcCursorY;
++ CARD32 DcCursorColor;
+
+ /* graphics pipeline registers */
+-
+ CARD32 GpBlitStatus;
++
++ /* save area for cursor image */
++ char cursorPattern[256];
+ } ext;
+ } vgaCYRIXRec, *vgaCYRIXPtr;
+
+@@ -158,9 +166,11 @@
+ static void CYRIXRestore();
+ static void CYRIXAdjust();
+
++#ifndef MONOVGA
+ static void CYRIXFbInit();
+ static Bool CYRIXScreenInit();
+ static Bool CYRIXPitchAdjust();
++#endif
+
+ void CYRIXSetRead();
+ void CYRIXSetWrite();
+@@ -177,7 +187,11 @@
+ CYRIXAdjust,
+ vgaHWSaveScreen,
+ (void (*)())NoopDDA, /* CYRIXGetMode */
++#ifndef MONOVGA
+ CYRIXFbInit,
++#else
++ (void (*)())NoopDDA, /* CYRIXFbInit */
++#endif
+ CYRIXSetRead,
+ CYRIXSetWrite,
+ CYRIXSetReadWrite,
+@@ -191,9 +205,9 @@
+ VGA_NO_DIVIDE_VERT, /* ChipInterlaceType */
+ {0,}, /* ChipOptionFlags */
+ 8, /* ChipRounding */
+- TRUE, /* ChipUseLinearAddressing */
+- 0x40800000, /* ChipLinearBase */
+- 0x001FFFFF, /* ChipLinearSize */
++ FALSE, /* ChipUseLinearAddressing */
++ 0, /* ChipLinearBase */
++ 0, /* ChipLinearSize */
+ TRUE, /* ChipHas16bpp */
+ FALSE, /* ChipHas24bpp */
+ FALSE, /* ChipHas32bpp */
+@@ -207,10 +221,6 @@
+
+ char* GXregisters;
+
+-int CYRIXvsaversion; /* VSA version */
+-#define CYRIX_VSA1 1
+-#define CYRIX_VSA2 2
+-
+ int CYRIXcbufferAddress; /* relative to video base */
+ int CYRIXoffscreenAddress;
+ int CYRIXcursorAddress;
+@@ -225,94 +235,6 @@
+
+ #define newstate ((vgaCYRIXPtr)vgaNewVideoState)
+
+-typedef struct {
+- int xsize;
+- int ysize;
+- int clock;
+- unsigned char miscOutput;
+- unsigned char stdCRTCregs[NUM_STD_CRTC_REGS];
+- unsigned char extCRTCregs[NUM_EXT_CRTC_REGS];
+-} vgaCYRIXmode;
+-
+-vgaCYRIXmode CYRIXmodes[] =
+-{
+-/*------------------------------------------------------------------------------*/
+- { 640, 480, /* 640x480 */
+- 25, /* 25 MHz clock = 60 Hz refresh rate */
+- 0xE3, /* miscOutput register */
+- { 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, /* standard CRTC */
+- 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0xEA, 0x0C, 0xDF, 0x50, 0x00, 0xE7, 0x04, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 800, 600, /* 800x600 */
+- 40, /* 40 MHz clock = 60 Hz refresh rate */
+- 0x23, /* miscOutput register */
+- { 0x7F, 0x63, 0x64, 0x82, 0x6B, 0x1B, 0x72, 0xF0, /* standard CRTC */
+- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x59, 0x0D, 0x57, 0x64, 0x00, 0x57, 0x73, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0xA0, 0x50, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 1024, 768, /* 1024x768 */
+- 65, /* 65 MHz clock = 60 Hz refresh rate */
+- 0xE3, /* miscOutput register */
+- { 0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xF5, /* standard CRTC */
+- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x04, 0x0A, 0xFF, 0x80, 0x00, 0xFF, 0x25, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0x80, 0x41, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 1280, 1024, /* 1280x1024 */
+- 108, /* 108 MHz clock = 60 Hz refresh rate */
+- 0x23, /* miscOutput register */
+- { 0xCF, 0x9F, 0xA0, 0x92, 0xAA, 0x19, 0x28, 0x52, /* standard CRTC */
+- 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x01, 0x04, 0xFF, 0xA0, 0x00, 0x00, 0x29, 0xE3, 0xFF },
+- { 0x00, 0x51, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0x80, 0x6C, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 640, 480, /* 640x480 */
+- 31, /* 31.5 MHz clock = 75 Hz refresh rate */
+- 0xE3, /* miscOutput register */
+- { 0x64, 0x4F, 0x4F, 0x88, 0x54, 0x9B, 0xF2, 0x1F, /* standard CRTC */
+- 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0xE1, 0x04, 0xDF, 0x50, 0x00, 0xDF, 0xF3, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0xA0, 0x3F, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 800, 600, /* 800x600 */
+- 99, /* 99 MHz clock = 75 Hz refresh rate */
+- 0x23, /* miscOutput register */
+- { 0x7F, 0x63, 0x63, 0x83, 0x68, 0x11, 0x6F, 0xF0, /* standard CRTC */
+- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x59, 0x1C, 0x57, 0x64, 0x00, 0x57, 0x70, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0xA0, 0x63, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 1024, 768, /* 1024x768 */
+- 79, /* 79 MHz clock = 75 Hz refresh rate */
+- 0xE3, /* miscOutput register */
+- { 0x9F, 0x7F, 0x7F, 0x83, 0x84, 0x8F, 0x1E, 0xF5, /* standard CRTC */
+- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x01, 0x04, 0xFF, 0x80, 0x00, 0xFF, 0x1F, 0xE3, 0xFF },
+- { 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0x80, 0x4F, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+- { 1280, 1024, /* 1280x1024 */
+- 135, /* 135 MHz clock = 75 Hz refresh rate */
+- 0x23, /* miscOutput register */
+- { 0xCE, 0x9F, 0x9F, 0x92, 0xA4, 0x15, 0x28, 0x52, /* standard CRTC */
+- 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+- 0x01, 0x04, 0xFF, 0xA0, 0x00, 0x00, 0x29, 0xE3, 0xFF },
+- { 0x00, 0x51, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, /* extended CRTC */
+- 0x00, 0x00, 0x01, 0x03, 0x80, 0x87, 0x00, 0x00 } },
+-/*------------------------------------------------------------------------------*/
+-};
+-
+-#define NUM_CYRIX_MODES sizeof(CYRIXmodes)/sizeof(vgaCYRIXmode)
+-
+ static char *
+ CYRIXIdent(n)
+ int n;
+@@ -478,6 +400,7 @@
+ vga256InfoRec.bankedMono = TRUE;
+ OFLG_SET(CLOCK_OPTION_PROGRAMABLE, &vga256InfoRec.clockOptions);
+
++#ifndef MONOVGA
+ /* define option set valid for the driver */
+ OFLG_SET(OPTION_SW_CURSOR, &CYRIX.ChipOptionFlags);
+ OFLG_SET(OPTION_HW_CURSOR, &CYRIX.ChipOptionFlags);
+@@ -496,12 +419,13 @@
+ CYRIX.ChipLinearSize = (1024 * vga256InfoRec.videoRam);
+
+ CYRIX.ChipUseLinearAddressing = TRUE;
++#endif
+
+ /* map the entire area from GX_BASE (scratchpad area)
+ up to the end of the control registers */
+ GXregisters = (char*)xf86MapVidMem(vga256InfoRec.scrnIndex,
+ EXTENDED_REGION,
+- (void*)physbase, 0x20000);
++ (void*)physbase, 0x9000);
+
+ if (!GXregisters)
+ { ErrorF("%s %s: Cannot map hardware registers\n",
+@@ -509,80 +433,27 @@
+ goto probeFailed;
+ }
+
+- /* check VSA version */
+- /* VSA2 contains a "CX" signature at registers 0x35 and 0x36. */
+- /* The SoftVGA interface changed slightly for VSA2. Originally, */
+- /* VSA2 was intended for MXi only, but it may someday be */
+- /* provided for MediaGX systems as well. */
+-
+- CYRIXvsaversion = CYRIX_VSA2;
+- outb(vgaIOBase + 4, 0x35);
+- if (inb(vgaIOBase + 5) != 'C') CYRIXvsaversion = CYRIX_VSA1;
+- outb(vgaIOBase + 4, 0x36);
+- if (inb(vgaIOBase + 5) != 'X') CYRIXvsaversion = CYRIX_VSA1;
+- if (CYRIXvsaversion == CYRIX_VSA1)
+- {
+- ErrorF("%s %s: VSA1 detected\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
+- else
+- {
+- ErrorF("%s %s: VSA2 detected\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
+ return(TRUE);
+ }
+
+-/*------------------------------------------------------------------------*\
+-** FbInit()
+-**
+-** From README file: "The FbInit() function is required for drivers with
+-** accelerated graphics support. It is used to replace default cfb.banked
+-** functions with accelerated chip-specific versions.
+-**
+-** For the Cyrix driver, this routine is also used to allocate video
+-** memory. This is more complicated than it needs to be...
+-**
+-** For VSA1, SoftVGA manages all of graphics memory, including the
+-** compression buffer, cursor buffer, and offscreen memory. The driver
+-** should not allocate memory itself. For offscreen memory it reads
+-** registers 0x3C and 0x3D. For the cursor buffer it reads the hardware
+-** register after validating a mode. For compression, it just sets bit 0
+-** of register 0x49 if it wants to use compression, and SoftVGA will
+-** enable it if memory has been allocated.
+-**
+-** This model, however, breaks down for this driver. There is a bug in
+-** SoftVGA that keeps the 0x3C register from working properly. This bug
+-** also prevents compression from being enabled when using a virtual
+-** desktop. This driver also cannot use the memory past 2 Meg, which
+-** effects the memory calculation.
+-**
+-** Therefore, this driver does what it is not supposed to and allocates
+-** video memory itself. But, this is required due to bugs in SoftVGA and,
+-** as it turns out, works out fine (with limiting compression use).
+-**
+-** For VSA2, the driver is supposed to do this allocation itself.
+-\*------------------------------------------------------------------------*/
+
++#ifndef MONOVGA
+ static void
+ CYRIXFbInit()
+ { int lineDelta = vga256InfoRec.displayWidth * (vgaBitsPerPixel / 8);
+ int virtualDelta = vga256InfoRec.virtualX * (vgaBitsPerPixel / 8);
+- int base;
+
+ vgaSetScreenInitHook(CYRIXScreenInit);
+
+- /* always put the cursor at the end of video memory. */
+-
+- CYRIXcursorAddress = CYRIX.ChipLinearSize - 256;
+-
+ /* offscreen memory is, normally, right after the frame buffer;
++ always put the cursor at the end of video memory.
++
+ (It would be nice to use the ignored 64KB block at the end of
+ the video memory (2112 - 2048) for the hardware cursor, but
+ it is not mapped. This will not be a problem in Xfree 3.9 */
+-
+ CYRIXoffscreenAddress = (lineDelta * vga256InfoRec.virtualY);
+- CYRIXoffscreenSize = CYRIXcursorAddress - CYRIXoffscreenAddress;
++ CYRIXcursorAddress = CYRIX.ChipLinearSize - 256;
++ CYRIXoffscreenSize = CYRIXcursorAddress - CYRIXoffscreenAddress;
+
+ /* if there is enough room between lines, put the compression
+ buffer there */
+@@ -591,7 +462,7 @@
+ CYRIXcbLineDelta = (lineDelta >> 2);
+ if (xf86Verbose > 1)
+ ErrorF("%s %s: Interleaving frame buffer and compression buffer\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
++ XCONFIG_PROBED, vga256InfoRec.name);
+ }
+ /* otherwise, put it directly after the virtual frame */
+ else
+@@ -600,7 +471,7 @@
+ if (cbuffer_size > CYRIXoffscreenSize)
+ { CYRIXcbLineDelta = 0;
+ ErrorF("%s %s: No room for the compression buffer\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
++ XCONFIG_PROBED, vga256InfoRec.name);
+ }
+ else
+ { CYRIXcbufferAddress = CYRIXoffscreenAddress;
+@@ -609,43 +480,25 @@
+ CYRIXoffscreenSize -= cbuffer_size;
+ } }
+
+- /* print results of offscreen memory configuration */
+-
+- if (CYRIXoffscreenSize <= 0)
+- {
+- ErrorF("%s %s: No offscreen memory available.\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
+- else
+- {
+- ErrorF("%s %s: Offscreen memory from 0x%8.8X-0x%8.8X\n",
+- XCONFIG_PROBED, vga256InfoRec.name,
+- CYRIXoffscreenAddress,
+- CYRIXoffscreenAddress+CYRIXoffscreenSize-1);
+- }
+-
+- /* call CYRIXAccelInit to setup the XAA accelerated functions */
+-
++ /* call CYRIXAccelInit to setup the XAA accelerated functions */
+ if (!OFLG_ISSET(OPTION_NOACCEL, &vga256InfoRec.options))
+ CYRIXAccelInit();
+
+ /* install hardware cursor routines */
+-
+ if (OFLG_ISSET(OPTION_HW_CURSOR, &vga256InfoRec.options))
+- { if (CYRIXoffscreenSize > 0)
++ { if (CYRIXoffscreenSize >= 0)
+ { vgaHWCursor.Initialized = TRUE;
+ vgaHWCursor.Init = CYRIXCursorInit;
+ vgaHWCursor.Restore = CYRIXRestoreCursor;
+ vgaHWCursor.Warp = CYRIXWarpCursor;
+ vgaHWCursor.QueryBestSize = CYRIXQueryBestSize;
+- ErrorF("%s %s: Using hardware cursor at %8.8X\n",
+- XCONFIG_PROBED, vga256InfoRec.name, CYRIXcursorAddress);
++ if (xf86Verbose)
++ ErrorF("%s %s: Using hardware cursor\n",
++ XCONFIG_PROBED, vga256InfoRec.name);
+ }
+ else
+- {
+ ErrorF("%s %s: No room for hardware cursor\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
++ XCONFIG_PROBED, vga256InfoRec.name);
+ }
+ }
+
+@@ -696,6 +549,7 @@
+
+ return pitch;
+ }
++#endif /* not MONOVGA */
+
+
+ static void
+@@ -747,121 +601,210 @@
+
+ static void
+ CYRIXresetVGA()
+-{
+- int i;
++{ unsigned char temp;
++ /* switch off compression and cursor the hard way */
++ GX_REG(DC_UNLOCK) = DC_UNLOCK_VALUE;
++ GX_REG(DC_GENERAL_CFG) &= ~(DC_GCFG_CMPE | DC_GCFG_DECE | DC_GCFG_FDTY | DC_GCFG_CURE);
++ GX_REG(DC_UNLOCK) = 0;
++ CYRIXmarkLinesDirty();
+
+ /* reset SoftVGA extensions to standard VGA behaviour */
+-
+- for (i = 0; i < NUM_EXT_CRTC_REGS; i++)
+- {
+- outb(vgaIOBase + 4, 0x40 + i);
+- outb(vgaIOBase + 5, 0x00);
+- }
++ outb(vgaIOBase + 4, CrtcExtendedAddressControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, temp & 0xf8);
++ outb(vgaIOBase + 4, CrtcExtendedStartAddress);
++ outb(vgaIOBase + 5, 0x00);
++ outb(vgaIOBase + 4, CrtcWriteMemoryAperture);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, temp & 0xe0);
++ outb(vgaIOBase + 4, CrtcReadMemoryAperture);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, temp & 0xe0);
++ outb(vgaIOBase + 4, CrtcDriverControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, temp & 0xfe);
++ outb(vgaIOBase + 4, CrtcDisplayCompression);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, temp & 0xf0);
+ }
+
+ static void
+ CYRIXRestore(restore)
+ vgaCYRIXPtr restore;
+-{ unsigned char i, temp, temp2;
+- unsigned long value;
+-
+- /* unlock extended CRTC registers */
+-
+- outb(vgaIOBase + 4, 0x30);
+- outb(vgaIOBase + 5, 0x57);
+- outb(vgaIOBase + 5, 0x4C);
++{ unsigned char temp;
++ vgaProtect(TRUE); /* Blank the screen */
+
+- /* SIGNAL THE BEGINNING OF THE MODE SWITCH
+- SoftVGA will hold off validating the back end hardware. */
+-
+- outb(vgaIOBase + 4, CrtcModeSwitchControl);
+- outb(vgaIOBase + 5, 0x01);
++ /* it would be ideal to be able to use the ModeSwitchControl
++ register to protect SoftVGA from reading the configuration
++ before all registers have been written. But that bit must be
++ set somewhere in the middle of vgaHWRestore (after restoring
++ the font). Luckily things seem to work without it. */
+
+ /* restore standard VGA portion */
+-
+ CYRIXresetVGA();
+ vgaHWRestore((vgaHWPtr)restore);
++ CYRIXmarkLinesDirty();
+
+- /* override restored miscellaneous output regiter value */
+-
+- outb(0x3C2, restore->ext.miscOutput);
+-
+- /* override restored standard CRTC register values */
+-
+- outb(vgaIOBase + 4, 0x11);
+- outb(vgaIOBase + 5, 0x00);
+- for (i = 0; i < NUM_STD_CRTC_REGS; i++)
+- {
+- outb(vgaIOBase + 4, i);
+- outb(vgaIOBase + 5, restore->ext.stdCRTCregs[i]);
+- }
+-
+ /* restore SoftVGA extended registers */
++ outb(vgaIOBase + 4, CrtcDriverControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.DriverControl & 0x01)
++ | (temp & 0xfe));
++
++ outb(vgaIOBase + 4, CrtcVerticalTimingExtension);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.VerticalTimingExtension & 0x55)
++ | (temp & 0xaa));
++
++ outb(vgaIOBase + 4, CrtcExtendedAddressControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.ExtendedAddressControl & 0x07)
++ | (temp & 0xf8));
++
++ outb(vgaIOBase + 4, CrtcExtendedOffset);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.ExtendedOffset & 0x03)
++ | (temp & 0xfc));
++
++ outb(vgaIOBase + 4, CrtcExtendedColorControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.ExtendedColorControl & 0x07)
++ | (temp & 0xf8));
++
++ outb(vgaIOBase + 4, CrtcDisplayCompression);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.DisplayCompression & 0x0f)
++ | (temp & 0xf0));
++
++ outb(vgaIOBase + 4, CrtcDACControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.DACControl & 0x0e)
++ | (temp & 0xf1));
++
++ if (restore->std.NoClock >= 0)
++ { outb(vgaIOBase + 4, CrtcClockControl);
++ temp = inb(vgaIOBase + 5);
++ outb(vgaIOBase + 5, (restore->ext.ClockControl & 0xb0)
++ | (temp & 0x4f));
++
++ outb(vgaIOBase + 4, CrtcClockFrequency);
++ outb(vgaIOBase + 5, restore->ext.CrtClockFrequency);
++
++ outb(vgaIOBase + 4, CrtcClockFrequencyFraction);
++ outb(vgaIOBase + 5, restore->ext.CrtClockFrequencyFraction);
++
++ outb(vgaIOBase + 4, CrtcRefreshRate);
++ outb(vgaIOBase + 5, restore->ext.RefreshRate);
++ }
++
++ /* let SoftVGA programming settle before we access DC registers,
++ but don't wait too long */
++ usleep(1000);
++ CYRIXmarkLinesDirty();
++
++ /* restore display controller hardware registers */
++#ifndef MONOVGA
++#define DCFG_MASK (DC_GCFG_FDTY | DC_GCFG_DECE | DC_GCFG_CMPE)
++#define GPBS_MASK (BC_16BPP | BC_FB_WIDTH_2048)
+
+- for (i = 0; i < NUM_EXT_CRTC_REGS; i++)
+- {
+- outb(vgaIOBase + 4, 0x40+i);
+- outb(vgaIOBase + 5, restore->ext.extCRTCregs[i]);
+- }
++ GX_REG(DC_UNLOCK) = DC_UNLOCK_VALUE;
+
+- /* signal the end of the mode switch */
++ GX_REG(DC_CURS_ST_OFFSET) = restore->ext.DcCursStOffset;
++ GX_REG(DC_CB_ST_OFFSET) = restore->ext.DcCbStOffset;
++ GX_REG(DC_LINE_DELTA) = (GX_REG(DC_LINE_DELTA) & 0xFFC00FFF)
++ | (restore->ext.DcLineDelta & 0x003FF000);
++ GX_REG(DC_BUF_SIZE) = (GX_REG(DC_BUF_SIZE) & 0xFFFF01FF)
++ | (restore->ext.DcBufSize & 0x0000FE00);
++ GX_REG(DC_CURSOR_X) = restore->ext.DcCursorX;
++ GX_REG(DC_CURSOR_Y) = restore->ext.DcCursorY;
++ GX_REG(DC_CURSOR_COLOR) = restore->ext.DcCursorColor;
+
+- outb(vgaIOBase + 4, CrtcModeSwitchControl);
+- outb(vgaIOBase + 5, 0x00);
++ GX_REG(DC_GENERAL_CFG) = (GX_REG(DC_GENERAL_CFG) & (~DCFG_MASK))
++ | (restore->ext.DcGeneralCfg & DCFG_MASK);
+
+- /* wait until SoftVGA has validated the mode.
+- This is for VSA1 only, where SoftVGA waits until the next
+- vertical blank to recalculate the hardware state. For VSA2
+- the hardware us updated immediately, so this is not needed.
+- THIS MUST BE DONE FOR VSA1 before loading the GP_BLT_STATUS
+- register, otherwise SoftVGA will override the value. */
++ GX_REG(DC_UNLOCK) = 0;
+
+- if (CYRIXvsaversion == CYRIX_VSA1)
+- {
+- outb(vgaIOBase + 4, 0x33);
+- while(inb(vgaIOBase + 5) & 0x80);
+- }
++ GX_REG(GP_BLIT_STATUS) = (GX_REG(GP_BLIT_STATUS) & (~GPBS_MASK))
++ | (restore->ext.GpBlitStatus & GPBS_MASK);
+
+- /* overrite what SoftVGA may have stored into GP_BLIT_STATUS */
++ /* restore cursor pattern */
++ if (restore->ext.DcCursStOffset < 1024 * vga256InfoRec.videoRam)
++ memcpy((char*)vgaLinearBase + restore->ext.DcCursStOffset,
++ restore->ext.cursorPattern, 256);
++#endif
+
+- GX_REG(GP_BLIT_STATUS) = restore->ext.GpBlitStatus;
++ vgaProtect(FALSE); /* Turn on screen */
+ }
+
+ static void *
+ CYRIXSave(save)
+ vgaCYRIXPtr save;
+-{ unsigned char i;
+- struct vgaCYRIXext ext;
++{ struct vgaCYRIXext ext;
+
+- /* save miscellaneous output register */
++#ifndef MONOVGA
++ /* save graphics pipeline registers */
++ ext.GpBlitStatus = GX_REG(GP_BLIT_STATUS);
+
+- ext.miscOutput = inb(0x3CC);
++ /* save display controller hardware registers */
++ GX_REG(DC_UNLOCK) = DC_UNLOCK_VALUE;
++ ext.DcGeneralCfg = GX_REG(DC_GENERAL_CFG);
++ ext.DcCursStOffset = GX_REG(DC_CURS_ST_OFFSET);
++ ext.DcCbStOffset = GX_REG(DC_CB_ST_OFFSET);
++ ext.DcLineDelta = GX_REG(DC_LINE_DELTA);
++ ext.DcBufSize = GX_REG(DC_BUF_SIZE);
++ ext.DcCursorX = GX_REG(DC_CURSOR_X);
++ ext.DcCursorY = GX_REG(DC_CURSOR_Y);
++ ext.DcCursorColor = GX_REG(DC_CURSOR_COLOR);
++ GX_REG(DC_UNLOCK) = 0;
++
++ /* save cursor pattern.
++ In the 3.3.1 solution, we don't need to do this
++ if it is in the extra 64KB block of frame buffer memory
++ that we ignore (and is not mapped anyway) */
++ if (ext.DcCursStOffset < 1024 * vga256InfoRec.videoRam)
++ memcpy(ext.cursorPattern,
++ (char*)vgaLinearBase + ext.DcCursStOffset, 256);
++#endif
+
+- /* save standard CRTC registers */
++ /* save SoftVGA extended registers */
++ outb(vgaIOBase + 4, CrtcVerticalTimingExtension);
++ ext.VerticalTimingExtension = inb(vgaIOBase + 5);
+
+- for (i = 0; i < NUM_STD_CRTC_REGS; i++)
+- {
+- outb(vgaIOBase + 4, i);
+- ext.stdCRTCregs[i] = inb(vgaIOBase + 5);
+- }
++ outb(vgaIOBase + 4, CrtcExtendedAddressControl);
++ ext.ExtendedAddressControl = inb(vgaIOBase + 5);
+
+- /* save extended CRTC registers */
++ outb(vgaIOBase + 4, CrtcExtendedOffset);
++ ext.ExtendedOffset = inb(vgaIOBase + 5);
+
+- for (i = 0; i < NUM_EXT_CRTC_REGS; i++)
+- {
+- outb(vgaIOBase + 4, 0x40+i);
+- ext.extCRTCregs[i] = inb(vgaIOBase + 5);
+- }
++ outb(vgaIOBase + 4, CrtcExtendedColorControl);
++ ext.ExtendedColorControl = inb(vgaIOBase + 5);
+
+- /* save graphics pipeline registers */
++ outb(vgaIOBase + 4, CrtcDisplayCompression);
++ ext.DisplayCompression = inb(vgaIOBase + 5);
+
+- ext.GpBlitStatus = GX_REG(GP_BLIT_STATUS);
++ outb(vgaIOBase + 4, CrtcDriverControl);
++ ext.DriverControl = inb(vgaIOBase + 5);
+
+- /* save standard VGA portion */
++ outb(vgaIOBase + 4, CrtcDACControl);
++ ext.DACControl = inb(vgaIOBase + 5);
++
++ outb(vgaIOBase + 4, CrtcClockControl);
++ ext.ClockControl = inb(vgaIOBase + 5);
++
++ outb(vgaIOBase + 4, CrtcClockFrequency);
++ ext.CrtClockFrequency = inb(vgaIOBase + 5);
+
++ outb(vgaIOBase + 4, CrtcClockFrequencyFraction);
++ ext.CrtClockFrequencyFraction = inb(vgaIOBase + 5);
++
++ outb(vgaIOBase + 4, CrtcRefreshRate);
++ ext.RefreshRate = inb(vgaIOBase + 5);
++
++ /* save standard VGA portion */
+ CYRIXresetVGA();
+ save = (vgaCYRIXPtr)vgaHWSave((vgaHWPtr)save, sizeof(vgaCYRIXRec));
+ save->ext = ext;
++
+ return ((void *) save);
+ }
+
+@@ -869,108 +812,101 @@
+ static Bool
+ CYRIXInit(mode)
+ DisplayModePtr mode;
+-{ int i, mode_index;
+- int clock = vga256InfoRec.clock[mode->Clock] / 1000;
+- int min, diff;
+- int offset_shift = (vgaBitsPerPixel == 16) ? 2 :
++{ int offset_shift = (vgaBitsPerPixel == 16) ? 2 :
+ (vgaBitsPerPixel == 8) ? 3 : 4;
+ int line_offset = vga256InfoRec.displayWidth >> offset_shift;
+
+ /* initialize standard VGA portion */
+-
+ if (!vgaHWInit(mode,sizeof(vgaCYRIXRec)))
+ return(FALSE);
+
+- /* search for specified mode in the table */
+- /* Need to find the entry with the closest dot clock value */
+- /* Assume within at least 200 MHz and then maintain closest natch. */
+-
+- mode_index = 0;
+- min = 200;
+- for (i = 0; i < NUM_CYRIX_MODES; i++)
+- {
+- diff = clock - CYRIXmodes[i].clock;
+- if (diff < 0) diff = -diff;
+- if ((mode->CrtcHDisplay == CYRIXmodes[i].xsize) &&
+- (mode->CrtcVDisplay == CYRIXmodes[i].ysize) &&
+- (diff < min))
+- {
+- mode_index = i;
+- min = diff;
+- }
+- }
+-
+- /* override standard miscOutput register value */
+-
+- newstate->ext.miscOutput = CYRIXmodes[mode_index].miscOutput;
++ newstate->std.CRTC[19] = line_offset;
+
+- /* override standard CRTC register values */
++ /* initialize SoftVGA extended registers */
++ newstate->ext.VerticalTimingExtension =
++ ((mode->CrtcVSyncStart & 0x400) >> 4) |
++ (((mode->CrtcVDisplay - 1) & 0x400) >> 8) |
++ (((mode->CrtcVTotal - 2) & 0x400) >> 10) |
++ ((mode->CrtcVSyncStart & 0x400) >> 6);
+
+- for (i = 0; i < NUM_STD_CRTC_REGS; i++)
+- {
+- newstate->ext.stdCRTCregs[i] =
+- CYRIXmodes[mode_index].stdCRTCregs[i];
+- }
+-
+- /* set extended CRTC registers */
+-
+- for (i = 0; i < NUM_EXT_CRTC_REGS; i++)
+- {
+- newstate->ext.extCRTCregs[i] =
+- CYRIXmodes[mode_index].extCRTCregs[i];
+- }
+-
+- /* override pitch from the mode tables */
+- /* (same tables are used for 8BPP and 16BPP) */
++ if (vgaBitsPerPixel < 8)
++ newstate->ext.ExtendedAddressControl = EAC_DIRECT_FRAME_BUFFER;
++ else
++ newstate->ext.ExtendedAddressControl = EAC_DIRECT_FRAME_BUFFER |
++ EAC_PACKED_CHAIN4;
+
+- newstate->ext.stdCRTCregs[19] = line_offset;
+- newstate->ext.extCRTCregs[5] = ((line_offset >> 8) & 0x03);
++ newstate->ext.ExtendedOffset = ((line_offset >> 8) & 0x03);
+
+- /* override color control from the mode tables */
+- /* (same tables are used for 8BPP and 16BPP) */
++ newstate->ext.ExtendedColorControl = (vgaBitsPerPixel == 16)
++ ? ECC_16BPP | ECC_565_FORMAT
++ : ECC_8BPP;
++
++ /* display compression is set using the DC registers */
++ newstate->ext.DisplayCompression = 0x00;
++
++ /* we drive the palette through the display controller (in new
++ chipsets only) in 8bpp and 16bpp (that is, whenever the
++ hardware cursor is used). */
++ if (vgaBitsPerPixel < 8)
++ newstate->ext.DriverControl = 0x00;
++ else
++ newstate->ext.DriverControl = DRVCT_DISPLAY_DRIVER_ACTIVE;
+
+- newstate->ext.extCRTCregs[6] = (vgaBitsPerPixel == 16)
+- ? ECC_16BPP | ECC_565_FORMAT : ECC_8BPP;
++ /* set `16 bit bus' or else compression will hang the
++ system in 16bpp mode */
++ if (vgaBitsPerPixel == 16)
++ newstate->ext.DACControl = DACCT_ENABLE_16BIT_BUS;
++ else
++ newstate->ext.DACControl = 0;
+
+- /* enable display compression when appropriate */
+
+- if (CYRIXvsaversion == CYRIX_VSA1)
+- {
+- /* For VSA1, SoftVGA manages the compression buffer. */
+- /* Enabling compression directly causes unpredictable results. */
+- /* Only enable if not panning (there is a bug in SoftVGA that */
+- /* will put the compression buffer in the wrong place when */
+- /* using a virtual desktop. */
+- /* By setting bit 0 of register 0x49, SoftVGA will enable */
+- /* compression whenever possible, based on memory available */
+- /* and starting address of memory. */
+-
+- if ((mode->CrtcVDisplay == vga256InfoRec.virtualY) &&
+- (mode->CrtcHDisplay == vga256InfoRec.virtualX))
+- {
+- newstate->ext.extCRTCregs[9] = 0x01;
+- ErrorF("%s %s: Display compression enabled.\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
+- else
+- {
+- ErrorF("%s %s: Display compression disabled.\n",
+- XCONFIG_PROBED, vga256InfoRec.name);
+- }
++ if (newstate->std.NoClock >= 0)
++ { int entier_clock = (vga256InfoRec.clock[mode->Clock] / 1000);
++ int clock_fraction = (vga256InfoRec.clock[mode->Clock] / 100)
++ - (entier_clock * 10);
++
++ newstate->ext.ClockControl = CLKCT_EXT_CLOCK_MODE;
++ newstate->ext.CrtClockFrequency = entier_clock;
++ newstate->ext.CrtClockFrequencyFraction = clock_fraction;
++ newstate->ext.RefreshRate = 0 /* relevant to VGA BIOS only */;
++ }
++
++#ifndef MONOVGA
++ /* initialize masked contents of display controller
++ hardware registers. */
++ newstate->ext.DcCursStOffset = CYRIXcursorAddress;
++ newstate->ext.DcCbStOffset = CYRIXcbufferAddress;
++ newstate->ext.DcLineDelta = CYRIXcbLineDelta << 12;
++ newstate->ext.DcBufSize = 0x41 << 9;
++ newstate->ext.DcCursorX = 0;
++ newstate->ext.DcCursorY = 0;
++ newstate->ext.DcCursorColor = 0;
++
++ /* Compression is enabled only when a buffer was allocated by
++ FbInit and provided that the displayed screen is the virtual
++ screen. If the line delta is not 1024 or 2048, entire frames
++ will be flagged dirty as opposed to lines. Problems with 16bpp
++ and line-dirty flagging seem to have been solved now. */
++ if (CYRIXcbLineDelta != 0 &&
++ mode->CrtcVDisplay == vga256InfoRec.virtualY &&
++ mode->CrtcHDisplay == vga256InfoRec.virtualX)
++ { newstate->ext.DcGeneralCfg = DC_GCFG_DECE
++ | DC_GCFG_CMPE;
++ if (/* vgaBitsPerPixel != 8 || -- this is OK now */
++ (vga256InfoRec.displayWidth * (vgaBitsPerPixel / 8)) & 0x03FF)
++ newstate->ext.DcGeneralCfg |= DC_GCFG_FDTY;
+ }
+ else
+- {
+- /* ### TO DO ### */
+- /* Enable display compression directly for VSA2. */
+- /* For VSA2, the display driver manages all graphics memory. */
+- }
++ newstate->ext.DcGeneralCfg = 0;
+
+- /* initialize the graphics pipeline registers */
+
++ /* initialize the graphics pipeline registers */
+ newstate->ext.GpBlitStatus = ((vga256InfoRec.displayWidth == 2048) ?
+ BC_FB_WIDTH_2048 : BC_FB_WIDTH_1024) |
+ ((vgaBitsPerPixel == 16) ?
+ BC_16BPP : BC_8BPP);
++#endif
++
+ return(TRUE);
+ }
+
+@@ -978,68 +914,31 @@
+ CYRIXAdjust(x, y)
+ int x, y;
+ { int Base = (y * vga256InfoRec.displayWidth + x);
+- unsigned long active, sync, count1, count2;
+
+ if (vgaBitsPerPixel > 8) Base *= (vgaBitsPerPixel / 8);
+ if (vgaBitsPerPixel < 8) Base /= 2;
+
+- /* wait until out of active display area */
+-
+- active = GX_REG(DC_V_TIMING_1) & 0x07FF;
+- sync = GX_REG(DC_V_TIMING_3) & 0x07FF;
+-
+- do
+- {
+- /* read twice to avoid transition values */
+-
+- count1 = GX_REG(DC_V_LINE_CNT) & 0x07FF;
+- count2 = GX_REG(DC_V_LINE_CNT) & 0x07FF;
+- } while ((count1 != count2) || (count1 < active) || (count1 >= sync));
+-
+- /* load the start address directly */
+-
++ /* doing this using the SoftVGA registers does not work reliably */
+ GX_REG(DC_UNLOCK) = DC_UNLOCK_VALUE;
+ GX_REG(DC_FB_ST_OFFSET) = Base;
+ GX_REG(DC_UNLOCK) = 0;
+ }
+
+-/*------------------------------------------------------------------------*\
+-** ValidMode()
+-**
+-** From README file: "The ValidMode() function is required. It is used to
+-** check for any chipset dependent reasons why a graphics mode might not be
+-** valid. It gets called by higher levels of the code after the Probe()
+-** stage. In many cases no special checking will be required and this
+-** function will simply return TRUE always."
+-**
+-** For the Cyrix driver, this routine loops through modes provided in a
+-** table at the beginning of this file and returns OK if it finds a match.
+-** These tables were required to make the standard VESA 60 Hz and 75 Hz
+-** modes work correctly. Doing this, however, takes away the flexibility
+-** of adding different resolutions or different refresh rates to the
+-** XF86Config file.
+-\*------------------------------------------------------------------------*/
+-
+ static int
+ CYRIXValidMode(mode, verbose, flag)
+ DisplayModePtr mode;
+ Bool verbose;
+ int flag;
+-{
+- int i;
+-
+- /* loop through table of modes */
+-
+- for (i = 0; i < NUM_CYRIX_MODES; i++)
+- {
+- if ((mode->CrtcHDisplay == CYRIXmodes[i].xsize) &&
+- (mode->CrtcVDisplay == CYRIXmodes[i].ysize))
+- {
+- return MODE_OK;
+- }
++{ /* note (avg): there seems to be a lot more to this if you look
++ at the GGI code (adjustment). */
++ if (mode->CrtcHSyncStart - mode->CrtcHDisplay >= 24 ||
++ mode->CrtcHSyncStart - mode->CrtcHDisplay <= 8)
++ { if (verbose)
++ ErrorF("%s %s: mode %s: horizontal sync out of range (sync - display should be between 8 and 24)\n",
++ XCONFIG_PROBED, vga256InfoRec.name, mode->name
++ );
++ return MODE_HSYNC;
+ }
+- return MODE_BAD;
++ return(MODE_OK);
+ }
+-
+-/* END OF FILE */
+
+diff -ruN XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/gxrender.c XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/gxrender.c
+--- XFree86-3.3.5/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/gxrender.c Thu Jun 24 01:59:41 1999
++++ XFree86-3.3.3.1/xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/gxrender.c Wed Dec 31 19:00:00 1969
+@@ -1,1237 +0,0 @@
+-/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cyrix/gxrender.c,v 1.1.2.1 1999/06/24 05:59:41 hohndel Exp $ */
+-/*
+-//---------------------------------------------------------------------------
+-// gxrender.c
+-//
+-// This file gives examples of using the MediaGX graphics unit to provide
+-// acceleration for 2D display drivers. It is intended to provide an
+-// absraction layer for new display driver development. This code handles
+-// the quirks of the MediaGX graphics unit to allow faster developemt times
+-// for new drivers.
+-//---------------------------------------------------------------------------
+-*/
+-
+-/* GRAPHICS PIPELINE REGISTER DEFINITIONS */
+-
+-#define GP_DST_XCOOR 0x8100 /* x destination origin */
+-#define GP_DST_YCOOR 0x8102 /* y destination origin */
+-#define GP_WIDTH 0x8104 /* pixel width */
+-#define GP_HEIGHT 0x8106 /* pixel height */
+-#define GP_SRC_XCOOR 0x8108 /* x source origin */
+-#define GP_SRC_YCOOR 0x810A /* y source origin */
+-
+-#define GP_VECTOR_LENGTH 0x8104 /* vector length */
+-#define GP_INIT_ERROR 0x8106 /* vector initial error */
+-#define GP_AXIAL_ERROR 0x8108 /* axial error increment */
+-#define GP_DIAG_ERROR 0x810A /* diagonal error increment */
+-
+-#define GP_SRC_COLOR_0 0x810C /* source color 0 */
+-#define GP_SRC_COLOR_1 0x810E /* source color 1 */
+-#define GP_PAT_COLOR_0 0x8110 /* pattern color 0 */
+-#define GP_PAT_COLOR_1 0x8112 /* pattern color 1 */
+-#define GP_PAT_COLOR_2 0x8114 /* pattern color 2 */
+-#define GP_PAT_COLOR_3 0x8116 /* pattern color 3 */
+-#define GP_PAT_DATA_0 0x8120 /* bits 31:0 of pattern */
+-#define GP_PAT_DATA_1 0x8124 /* bits 63:32 of pattern */
+-#define GP_PAT_DATA_2 0x8128 /* bits 95:64 of pattern */
+-#define GP_PAT_DATA_3 0x812C /* bits 127:96 of pattern */
+-
+-#define GP_RASTER_MODE 0x8200 /* raster operation */
+-#define GP_VECTOR_MODE 0x8204 /* vector mode register */
+-#define GP_BLIT_MODE 0x8208 /* blit mode register */
+-#define GP_BLIT_STATUS 0x820C /* blit status register */
+-
+-/* "GP_VECTOR_MODE" BIT DEFINITIONS */
+-
+-#define VM_X_MAJOR 0x0000 /* X major vector */
+-#define VM_Y_MAJOR 0x0001 /* Y major vector */
+-#define VM_MAJOR_INC 0x0002 /* positive major axis step */
+-#define VM_MINOR_INC 0x0004 /* positive minor axis step */
+-#define VM_READ_DST_FB 0x0008 /* read destination data */
+-
+-/* "GP_RASTER_MODE" BIT DEFINITIONS */
+-
+-#define RM_PAT_DISABLE 0x0000 /* pattern is disabled */
+-#define RM_PAT_MONO 0x0100 /* 1BPP pattern expansion */
+-#define RM_PAT_DITHER 0x0200 /* 2BPP pattern expansion */
+-#define RM_PAT_COLOR 0x0300 /* 8BPP or 16BPP pattern */
+-#define RM_PAT_MASK 0x0300 /* mask for pattern mode */
+-#define RM_PAT_TRANSPARENT 0x0400 /* transparent 1BPP pattern */
+-#define RM_SRC_TRANSPARENT 0x0800 /* transparent 1BPP source */
+-
+-/* "GP_BLIT_STATUS" BIT DEFINITIONS */
+-
+-#define BS_BLIT_BUSY 0x0001 /* blit engine is busy */
+-#define BS_PIPELINE_BUSY 0x0002 /* graphics pipeline is bus */
+-#define BS_BLIT_PENDING 0x0004 /* blit pending */
+-#define BC_8BPP 0x0000 /* 8BPP mode */
+-#define BC_16BPP 0x0100 /* 16BPP mode */
+-#define BC_FB_WIDTH_1024 0x0000 /* framebuffer width = 1024 */
+-#define BC_FB_WIDTH_2048 0x0200 /* framebuffer width = 2048 */
+-
+-/* "GP_BLIT_MODE" BIT DEFINITIONS */
+-
+-#define BM_READ_SRC_NONE 0x0000 /* source foreground color */
+-#define BM_READ_SRC_FB 0x0001 /* read source from FB */
+-#define BM_READ_SRC_BB0 0x0002 /* read source from BB0 */
+-#define BM_READ_SRC_BB1 0x0003 /* read source from BB1 */
+-#define BM_READ_SRC_MASK 0x0003 /* read source mask */
+-
+-#define BM_READ_DST_NONE 0x0000 /* no destination data */
+-#define BM_READ_DST_BB0 0x0008 /* destination from BB0 */
+-#define BM_READ_DST_BB1 0x000C /* destination from BB1 */
+-#define BM_READ_DST_FB0 0x0010 /* dest from FB (store BB0) */
+-#define BM_READ_DST_FB1 0x0014 /* dest from FB (store BB1)*/
+-#define BM_READ_DST_MASK 0x001C /* read destination mask */
+-
+-#define BM_WRITE_FB 0x0000 /* write to framebuffer */
+-#define BM_WRITE_MEM 0x0020 /* write to memory */
+-#define BM_WRITE_MASK 0x0020 /* write mask */
+-
+-#define BM_SOURCE_COLOR 0x0000 /* source is 8BPP or 16BPP */
+-#define BM_SOURCE_EXPAND 0x0040 /* source is 1BPP */
+-#define BM_SOURCE_TEXT 0x00C0 /* source is 1BPP text */
+-#define BM_SOURCE_MASK 0x00C0 /* source mask */
+-
+-#define BM_REVERSE_Y 0x0100 /* reverse Y direction */
+-
+-/* THE DRIVER NEEDS TO MAINTAIN THE SIZE AND LOCATION OF THE BLT BUFFERS
+-// These constants will work with 2K or 3K config, 8 or 16 BPP. The driver
+-// should set them, however, to optimize for the current config. Otherwise
+-// screen to screen BLTs, for example, may be visibly split into two vertical
+-// sections when they do not need to be.
+-*/
+-
+-/* STATIC VARIABLES FOR GXRENDER.C FILE */
+-
+-unsigned char *GXRregptr;
+-unsigned short GXRbpp;
+-unsigned short GXRbb0Base;
+-unsigned short GXRbb1Base;
+-unsigned short GXRbufferWidthPixels;
+-
+-unsigned short GXRpatternFlags;
+-unsigned short GXRsourceFlags;
+-unsigned short GXRsavedColor;
+-unsigned short GXRsavedRop;
+-unsigned short GXRusesDstData;
+-
+-/* MACROS FOR REGISTER ACCESS
+-// These macros asssume that a pointer was specified during initialization.
+-// They also assume 32-bit access is possible (16-bit access such as for
+-// Windows 98 display drivers would require different macros).
+-*/
+-
+-#define WRITE_REG8(offset, value) \
+- (*(volatile unsigned char *)(GXRregptr + (offset))) = (value)
+-
+-#define WRITE_REG16(offset, value) \
+- (*(volatile unsigned short *)(GXRregptr + (offset))) = (value)
+-
+-#define WRITE_REG32(offset, value) \
+- (*(volatile unsigned long *)(GXRregptr + (offset))) = (value)
+-
+-#define READ_REG16(offset) \
+- (*(volatile unsigned short *)(GXRregptr + (offset)))
+-
+-#define READ_REG32(offset) \
+- (*(volatile unsigned long *)(GXRregptr + (offset)))
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_INITIALIZE
+-//
+-// This routine initializes the parameters for the current configuration.
+-//
+-// REGPTR pointer to GX memory mapped registers
+-// BPP bits per pixel (8 pr 16)
+-//
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_initialize(unsigned char *regptr, unsigned short bpp,
+- unsigned short BB0base, unsigned short BB1base,
+- unsigned short BBwidthPixels)
+-{
+- GXRregptr = regptr;
+- GXRbpp = bpp;
+- GXRbb0Base = BB0base;
+- GXRbb1Base = BB1base;
+- GXRbufferWidthPixels = BBwidthPixels;
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_WAIT_UNTIL_IDLE
+-//
+-// This routine waits until the graphics engine is idle.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_wait_until_idle(void)
+-{
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_BUSY);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_LOAD_SOLID_SOURCE
+-//
+-// This routine is used to specify a solid source color. For the Xfree96
+-// display driver, the source color is used to specify a planemask and the
+-// ROP is adjusted accordingly.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_load_solid_source(unsigned short color)
+-{
+- /* CLEAR TRANSPARENCY FLAG */
+-
+- GXRsourceFlags = 0;
+-
+- /* FORMAT 8 BPP COLOR */
+- /* GX requires 8BPP color data be duplicated into bits [15:8]. */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- color &= 0x00FF;
+- color |= (color << 8);
+- }
+-
+- /* POLL UNTIL ABLE TO WRITE THE SOURCE COLOR */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_SRC_COLOR_0, color);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_LOAD_MONO_SOURCE
+-//
+-// This routine is used to specify the monochrome source colors.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_load_mono_source(unsigned short bgcolor, unsigned short fgcolor,
+- unsigned short transparent)
+-{
+- /* SET TRANSPARENCY FLAG */
+-
+- GXRsourceFlags = transparent ? RM_SRC_TRANSPARENT : 0;
+-
+- /* FORMAT 8 BPP COLOR */
+- /* GX requires 8BPP color data be duplicated into bits [15:8]. */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- bgcolor &= 0x00FF;
+- bgcolor |= (bgcolor << 8);
+- fgcolor &= 0x00FF;
+- fgcolor |= (fgcolor << 8);
+- }
+-
+- /* POLL UNTIL ABLE TO WRITE THE SOURCE COLOR */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_SRC_COLOR_0, bgcolor);
+- WRITE_REG16(GP_SRC_COLOR_1, fgcolor);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_LOAD_SOLID_PATTERN
+-//
+-// This routine is used to specify a solid pattern color. It is called
+-// before performing solid rectangle fills or more complicated BLTs that
+-// use a solid pattern color.
+-//
+-// The driver should always call "gxr_load_raster_operation" after a call
+-// to this routine to make sure that the pattern flags are set appropriately.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_load_solid_pattern(unsigned short color)
+-{
+- /* SET PATTERN FLAGS */
+-
+- GXRpatternFlags = 0;
+-
+- /* FORMAT 8 BPP COLOR */
+- /* GX requires 8BPP color data be duplicated into bits [15:8]. */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- color &= 0x00FF;
+- color |= (color << 8);
+- }
+-
+- /* SAVE THE REFORMATTED COLOR FOR LATER */
+- /* Used to call the "gxr_solid_fill" routine for special cases. */
+-
+- GXRsavedColor = color;
+-
+- /* POLL UNTIL ABLE TO WRITE THE PATTERN COLOR */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_PAT_COLOR_0, color);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_LOAD_MONO_PATTERN
+-//
+-// This routine is used to specify a monochrome pattern.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_load_mono_pattern(unsigned short bgcolor, unsigned short fgcolor,
+- unsigned long data0, unsigned long data1, unsigned char transparent)
+-{
+- /* SET PATTERN FLAGS */
+-
+- GXRpatternFlags = transparent ? RM_PAT_MONO | RM_PAT_TRANSPARENT :
+- RM_PAT_MONO;
+-
+- /* FORMAT 8 BPP COLOR */
+- /* GX requires 8BPP color data be duplicated into bits [15:8]. */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- bgcolor &= 0x00FF;
+- bgcolor |= (bgcolor << 8);
+- fgcolor &= 0x00FF;
+- fgcolor |= (fgcolor << 8);
+- }
+-
+- /* POLL UNTIL ABLE TO WRITE THE PATTERN COLORS AND DATA */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_PAT_COLOR_0, bgcolor);
+- WRITE_REG16(GP_PAT_COLOR_1, fgcolor);
+- WRITE_REG32(GP_PAT_DATA_0, data0);
+- WRITE_REG32(GP_PAT_DATA_1, data1);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_LOAD_RASTER_OPERATION
+-//
+-// This routine loads the specified raster operation. It sets the pattern
+-// flags appropriately.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_load_raster_operation(unsigned char rop)
+-{
+- unsigned short rop16;
+-
+- /* GENERATE 16-BIT VERSION OF ROP WITH PATTERN FLAGS */
+-
+- rop16 = (unsigned short) rop | GXRpatternFlags;
+- if ((rop & 0x33) ^ ((rop >> 2) & 0x33))
+- rop16 |= GXRsourceFlags;
+-
+- /* SAVE ROP FOR LATER COMPARISONS */
+- /* Need to have the pattern flags included */
+-
+- GXRsavedRop = rop16;
+-
+- /* SET FLAG INDICATING ROP REQUIRES DESTINATION DATA */
+- /* True if even bits (0:2:4:6) do not equal the correspinding */
+- /* even bits (1:3:5:7). */
+-
+- GXRusesDstData = ((rop & 0x55) ^ ((rop >> 1) & 0x55));
+-
+- /* POLL UNTIL ABLE TO WRITE THE PATTERN COLOR */
+- /* Only one operation can be pending at a time. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_RASTER_MODE, rop16);
+-}
+-
+-/*
+-//---------------------------------------------------------------------------
+-// GXR_SOLID_FILL
+-//
+-// This routine MUST be used when performing a solid rectangle fill with
+-// the ROPs of PATCOPY (0xF0), BLACKNESS (0x00), WHITENESS (0xFF), or
+-// PATINVERT (0x0F). There is a bug in GXm for these cases that requires a
+-// workaround.
+-//
+-// For BLACKNESS (ROP = 0x00), set the color to 0x0000.
+-// For WHITENESS (ROP = 0xFF), set the color to 0xFFFF.
+-// For PATINVERT (ROP = 0x0F), invert the desired color.
+-//
+-// X screen X position (left)
+-// Y screen Y position (top)
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// COLOR fill color
+-//
+-// THIS ROUTINE SHOULD NOT BE DIRECTLY CALLED FROM THE DRIVER. The driver
+-// should always use gxr_pattern_fill and let that routine call this one
+-// when approipriate. This is to hide quirks specific to MediaGX hardware.
+-//---------------------------------------------------------------------------
+-*/
+-
+-void gxr_solid_fill(unsigned short x, unsigned short y,
+- unsigned short width, unsigned short height, unsigned short color)
+-{
+- unsigned short section;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Only one operation can be pending at a time. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+-
+- /* SET REGISTERS TO DRAW RECTANGLE */
+-
+- WRITE_REG16(GP_DST_XCOOR, x);
+- WRITE_REG16(GP_DST_YCOOR, y);
+- WRITE_REG16(GP_HEIGHT, height);
+- WRITE_REG16(GP_RASTER_MODE, 0x00F0); /* PATCOPY */
+- WRITE_REG16(GP_PAT_COLOR_0, color);
+-
+- /* CHECK WIDTH FOR GX BUG WORKAROUND */
+-
+- if (width <= 16)
+- {
+- /* OK TO DRAW SMALL RECTANGLE IN ONE PASS */
+-
+- WRITE_REG16(GP_WIDTH, width);
+- WRITE_REG16(GP_BLIT_MODE, 0);
+- }
+- else
+- {
+- /* DRAW FIRST PART OF RECTANGLE */
+- /* Get to a 16 pixel boundary. */
+-
+- section = 0x10 - (x & 0x0F);
+- WRITE_REG16(GP_WIDTH, section);
+- WRITE_REG16(GP_BLIT_MODE, 0);
+-
+- /* POLL UNTIL ABLE TO LOAD THE SECOND RECTANGLE */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, x + section);
+- WRITE_REG16(GP_DST_YCOOR, y);
+- WRITE_REG16(GP_WIDTH, width - section);
+- WRITE_REG16(GP_BLIT_MODE, 0);
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// GXR_PATTERN_FILL
+-//
+-// This routine is used to fill a rectangular region. The pattern must
+-// be previously loaded using one of gxr_load_*_pattern routines. Also, the
+-// raster operation must be previously specified using the
+-// "gxr_load_raster_operation" routine.
+-//
+-// X screen X position (left)
+-// Y screen Y position (top)
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_pattern_fill(unsigned short x, unsigned short y,
+- unsigned short width, unsigned short height)
+-{
+- unsigned short section, buffer_width, blit_mode;
+-
+- /* CHECK IF OPTIMIZED SOLID CASES */
+- /* Check all 16 bits of the ROP to include solid pattern flags. */
+-
+- switch(GXRsavedRop)
+- {
+- /* CHECK FOR SPECIAL CASES WITHOUT DESTINATION DATA */
+- /* Need hardware workaround for fast "burst write" cases. */
+-
+- case 0x00F0:
+- gxr_solid_fill(x, y, width, height, GXRsavedColor);
+- break;
+- case 0x000F:
+- gxr_solid_fill(x, y, width, height, ~GXRsavedColor);
+- break;
+- case 0x0000:
+- gxr_solid_fill(x, y, width, height, 0x0000);
+- break;
+- case 0x00FF:
+- gxr_solid_fill(x, y, width, height, 0xFFFF);
+- break;
+-
+- /* REMAINING CASES REQUIRE DESTINATION DATA OR NOT SOLID COLOR */
+-
+- default:
+-
+- /* DETERMINE BLT MODE VALUE */
+- /* Still here for non-solid patterns without destination data. */
+-
+- blit_mode = GXRusesDstData ? BM_READ_DST_FB0 : 0;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Write the registers that do not change for each section. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, height);
+-
+- /* SINCE ONLY DESTINATION DATA, WE CAN USE BOTH BB0 AND BB1. */
+- /* Therefore, width available = BLT buffer width * 2. */
+-
+- buffer_width = GXRbufferWidthPixels << 1;
+-
+- /* REPEAT UNTIL FINISHED WITH RECTANGLE */
+- /* Perform BLT in vertical sections, as wide as the BLT buffer */
+- /* allows. Hardware does not split the operations, so */
+- /* software must do it to avoid large scanlines that would */
+- /* overflow the BLT buffers. */
+-
+- while(width > 0)
+- {
+- /* DETERMINE WIDTH OF SECTION */
+-
+- if (width > buffer_width) section = buffer_width;
+- else section = width;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, x);
+- WRITE_REG16(GP_DST_YCOOR, y);
+- WRITE_REG16(GP_WIDTH, section);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+-
+- /* ADJUST PARAMETERS FOR NEXT SECTION */
+-
+- width -= section;
+- x += section;
+- }
+- break;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// SCREEN TO SCREEN BLT
+-//
+-// This routine should be used to perform a screen to screen BLT when the
+-// ROP does not require destination data.
+-//
+-// SRCX screen X position to copy from
+-// SRCY screen Y position to copy from
+-// DSTX screen X position to copy to
+-// DSTY screen Y position to copy to
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_screen_to_screen_blt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height)
+-{
+- unsigned short section, buffer_width;
+- unsigned short blit_mode;
+-
+- /* CHECK IF RASTER OPERATION REQUIRES DESTINATION DATA */
+-
+- blit_mode = GXRusesDstData ? BM_READ_DST_FB1 | BM_READ_SRC_FB :
+- BM_READ_SRC_FB;
+-
+- /* CHECK Y DIRECTION */
+- /* Hardware has support for negative Y direction. */
+-
+- if (dsty > srcy)
+- {
+- blit_mode |= BM_REVERSE_Y;
+- srcy += height - 1;
+- dsty += height - 1;
+- }
+-
+- /* CHECK X DIRECTION */
+- /* Hardware does not support negative X direction since at the time */
+- /* of development all supported resolutions could fit a scanline of */
+- /* data at once into the BLT buffers (using both BB0 and BB1). This */
+- /* code is more generic to allow for any size BLT buffer. */
+-
+- if (dstx > srcx)
+- {
+- srcx += width;
+- dstx += width;
+- }
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Write the registers that do not change for each section. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, height);
+-
+- /* CHECK AVAILABLE BLT BUFFER SIZE */
+- /* Can use both BLT buffers if no destination data is required. */
+-
+- buffer_width = GXRusesDstData ? GXRbufferWidthPixels :
+- GXRbufferWidthPixels << 1;
+-
+- /* REPEAT UNTIL FINISHED WITH RECTANGLE */
+- /* Perform BLT in vertical sections, as wide as the BLT buffer allows. */
+- /* Hardware does not split the operations, so software must do it to */
+- /* avoid large scanlines that would overflow the BLT buffers. */
+-
+- while(width > 0)
+- {
+- /* CHECK WIDTH OF CURRENT SECTION */
+-
+- if (width > buffer_width) section = buffer_width;
+- else section = width;
+-
+- /* PROGRAM REGISTERS THAT ARE THE SAME FOR EITHER X DIRECTION */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_SRC_YCOOR, srcy);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_WIDTH, section);
+-
+- /* CHECK X DIRECTION */
+-
+- if (dstx > srcx)
+- {
+- /* NEGATIVE X DIRECTION */
+- /* Still positive X direction within the section. */
+-
+- srcx -= section;
+- dstx -= section;
+- WRITE_REG16(GP_SRC_XCOOR, srcx);
+- WRITE_REG16(GP_DST_XCOOR, dstx);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+- }
+- else
+- {
+- /* POSITIVE X DIRECTION */
+-
+- WRITE_REG16(GP_SRC_XCOOR, srcx);
+- WRITE_REG16(GP_DST_XCOOR, dstx);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+- dstx += section;
+- srcx += section;
+- }
+- width -= section;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// SCREEN TO SCREEN TRANSPARENT BLT
+-//
+-// This routine should be used to perform a screen to screen BLT when a
+-// specified color should by transparent. The only supported ROP is SRCCOPY.
+-//
+-// SRCX screen X position to copy from
+-// SRCY screen Y position to copy from
+-// DSTX screen X position to copy to
+-// DSTY screen Y position to copy to
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// COLOR transparent color
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_screen_to_screen_xblt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned short color)
+-{
+- unsigned short section, buffer_width;
+- unsigned short blit_mode = BM_READ_SRC_FB;
+- unsigned short i;
+-
+- /* CHECK Y DIRECTION */
+- /* Hardware has support for negative Y direction. */
+-
+- if (dsty > srcy)
+- {
+- blit_mode |= BM_REVERSE_Y;
+- srcy += height - 1;
+- dsty += height - 1;
+- }
+-
+- /* CHECK X DIRECTION */
+- /* Hardware does not support negative X direction since at the time */
+- /* of development all supported resolutions could fit a scanline of */
+- /* data at once into the BLT buffers (using both BB0 and BB1). This */
+- /* code is more generic to allow for any size BLT buffer. */
+-
+- if (dstx > srcx)
+- {
+- srcx += width;
+- dstx += width;
+- }
+-
+- /* CALCULATE BLT BUFFER SIZE */
+- /* Need to use BB1 to store the BLT buffer data. */
+-
+- buffer_width = GXRbufferWidthPixels;
+-
+- /* WRITE TRANSPARENCY COLOR TO BLT BUFFER 1 */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- color &= 0x00FF;
+- color |= (color << 8);
+- }
+-
+- /* WAIT UNTIL PIPELINE IS NOT BUSY BEFORE LOADING DATA INTO BB1 */
+- /* Need to make sure any previous BLT using BB1 is complete. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY);
+- for (i = 0; i < 16; i+=2)
+- {
+- WRITE_REG16(GXRbb1Base+i, color);
+- }
+-
+- /* DO BOGUS BLT TO LATCH DATA FROM BB1 */
+- /* Already know graphics pipeline is idle. */
+-
+- WRITE_REG32(GP_DST_XCOOR, 0);
+- WRITE_REG32(GP_SRC_XCOOR, 0);
+- WRITE_REG16(GP_WIDTH, 16);
+- WRITE_REG16(GP_HEIGHT, 1);
+- WRITE_REG16(GP_RASTER_MODE, 0x00CC);
+- WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_FB | BM_READ_DST_BB1);
+-
+- /* WRITE REGISTERS FOR REAL SCREEN TO SCREEN BLT */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, height);
+- WRITE_REG16(GP_RASTER_MODE, 0x10C6);
+- WRITE_REG32(GP_PAT_COLOR_0, 0xFFFFFFFF);
+-
+- /* REPEAT UNTIL FINISHED WITH RECTANGLE */
+- /* Perform BLT in vertical sections, as wide as the BLT buffer allows. */
+- /* Hardware does not split the operations, so software must do it to */
+- /* avoid large scanlines that would overflow the BLT buffers. */
+-
+- while(width > 0)
+- {
+- /* CHECK WIDTH OF CURRENT SECTION */
+-
+- if (width > buffer_width) section = buffer_width;
+- else section = width;
+-
+- /* PROGRAM REGISTERS THAT ARE THE SAME FOR EITHER X DIRECTION */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_SRC_YCOOR, srcy);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_WIDTH, section);
+-
+- /* CHECK X DIRECTION */
+- /* Again, this must be done in software, and can be removed if the */
+- /* display driver knows that the BLT buffers will always be large */
+- /* enough to contain an entire scanline of a screen to screen BLT. */
+-
+- if (dstx > srcx)
+- {
+- /* NEGATIVE X DIRECTION */
+- /* Still positive X direction within the section. */
+-
+- srcx -= section;
+- dstx -= section;
+- WRITE_REG16(GP_SRC_XCOOR, srcx);
+- WRITE_REG16(GP_DST_XCOOR, dstx);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+- }
+- else
+- {
+- /* POSITIVE X DIRECTION */
+-
+- WRITE_REG16(GP_SRC_XCOOR, srcx);
+- WRITE_REG16(GP_DST_XCOOR, dstx);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+- dstx += section;
+- srcx += section;
+- }
+- width -= section;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// COLOR BITMAP TO SCREEN BLT
+-//
+-// This routine transfers color bitmap data to the screen. For most cases,
+-// when the ROP is SRCCOPY, it may be faster to write a separate routine that
+-// copies the data to the frame buffer directly. This routine should be
+-// used when the ROP requires destination data.
+-//
+-// Transparency is handled by another routine.
+-//
+-// SRCX X offset within source bitmap
+-// SRCY Y offset within source bitmap
+-// DSTX screen X position to render data
+-// DSTY screen Y position to render data
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// *DATA pointer to bitmap data
+-// PITCH pitch of bitmap data (bytes between scanlines)
+-// ROP ternary raster operation (0x00-0xFF).
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_color_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned char *data, unsigned short pitch,
+- unsigned char rop)
+-{
+- unsigned short section, buffer_width;
+- unsigned short blit_mode = BM_READ_SRC_BB0;
+- unsigned short line_srcx, line_dstx, line_width;
+- unsigned short offset, i;
+-
+- /* CHECK IF ROP REQUIRES DESTINATION DATA */
+- /* Even bits (0:2:4:6) do not equal corresponding odd bits (1:3:5:7). */
+-
+- if ((rop & 0x55) ^ ((rop >> 1) & 0x55))
+- blit_mode |= BM_READ_DST_FB1;
+-
+- /* CHECK SIZE OF BLT BUFFER */
+-
+- buffer_width = GXRbufferWidthPixels;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Write the registers that do not change for each section. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, 1);
+- WRITE_REG16(GP_RASTER_MODE, (unsigned short) rop & 0x00FF);
+-
+- /* REPEAT FOR EACH SCANLINE */
+-
+- offset = srcy * pitch;
+-
+- while(height > 0)
+- {
+- line_width = width;
+- line_srcx = srcx;
+- line_dstx = dstx;
+-
+- while(line_width > 0)
+- {
+- /* CHECK WIDTH OF CURRENT SECTION */
+-
+- if (line_width > buffer_width) section = buffer_width;
+- else section = line_width;
+-
+- /* TRANSFER SCANLINE OF BITMAP DATA TO BLT BUFFER 0 */
+- /* Need to wait for BS_PIPELINE_BUSY to make sure that the */
+- /* data in BB0 for the previous scanline is no longer used. */
+- /* This can be heavily optimized to not do a byte at a time. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY);
+- if (READ_REG16(GP_BLIT_STATUS) & BC_16BPP)
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG16(GXRbb0Base+i, data[offset+((line_srcx+i)<<1)]);
+- }
+- }
+- else
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG8(GXRbb0Base+i, data[line_srcx+offset+i]);
+- }
+- }
+-
+- /* RENDER FROM BB0 TO FRAME BUFFER */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, line_dstx);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_WIDTH, section);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+-
+- line_width -= section;
+- line_dstx += section;
+- line_srcx += section;
+- }
+- height--;
+- dsty++;
+- offset += pitch;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// COLOR BITMAP TO SCREEN TRANSPARENT BLT
+-//
+-// This routine transfers color bitmap data to the screen with transparency.
+-// The transparent color is specified. The only supported ROP is SRCCOPY,
+-// meaning that transparency cannot be applied if the ROP requires
+-// destination data (this is a hardware restriction).
+-//
+-// SRCX X offset within source bitmap
+-// SRCY Y offset within source bitmap
+-// DSTX screen X position to render data
+-// DSTY screen Y position to render data
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// *DATA pointer to bitmap data
+-// PITCH pitch of bitmap data (bytes between scanlines)
+-// COLOR transparent color
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_color_bitmap_to_screen_xblt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned char *data, unsigned short pitch,
+- unsigned short color)
+-{
+- unsigned short section, buffer_width;
+- unsigned short blit_mode = BM_READ_SRC_BB0;
+- unsigned short line_srcx, line_dstx, line_width;
+- unsigned short offset, i, first_blt = 1;
+-
+- /* CHECK SIZE OF BLT BUFFER */
+-
+- buffer_width = GXRbufferWidthPixels;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Write the registers that do not change for each section. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, 1);
+- WRITE_REG16(GP_RASTER_MODE, 0x10C6);
+- WRITE_REG32(GP_PAT_COLOR_0, 0xFFFFFFFF);
+-
+- /* CALCULATE OFFSET INTO BITMAP DATA */
+-
+- offset = srcy * pitch;
+-
+- /* REPEAT FOR EACH SCANLINE */
+-
+- while(height > 0)
+- {
+- line_width = width;
+- line_srcx = srcx;
+- line_dstx = dstx;
+-
+- while(line_width > 0)
+- {
+- /* CHECK WIDTH OF CURRENT SECTION */
+-
+- if (line_width > buffer_width) section = buffer_width;
+- else section = line_width;
+-
+- /* TRANSFER SCANLINE OF BITMAP DATA TO BLT BUFFER 0 */
+- /* Need to wait for BS_PIPELINE_BUSY to make sure that the */
+- /* data in BB0 for the previous scanline is no longer used. */
+- /* This can be heavily optimized to not do a byte at a time. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY);
+- if (READ_REG16(GP_BLIT_STATUS) & BC_16BPP)
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG16(GXRbb0Base+i, data[offset+((line_srcx+i)<<1)]);
+- }
+- }
+- else
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG8(GXRbb0Base+i, data[line_srcx+offset+i]);
+- }
+- }
+-
+- /* RENDER FROM BB0 TO FRAME BUFFER */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, line_dstx);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_WIDTH, section);
+-
+- /* NEED TO DO EXTRA WORK FOR THE FIRST BLT */
+-
+- if (first_blt)
+- {
+- /* WRITE TRANSPARENCY COLOR TO BLT BUFFER 1 */
+- /* This can be heavily optimized to not do 16-bits at a time. */
+-
+- if (READ_REG16(GP_BLIT_STATUS) & BC_16BPP)
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG16(GXRbb1Base+i*2, color);
+- }
+- }
+- else
+- {
+- for (i = 0; i < section; i++)
+- {
+- WRITE_REG8(GXRbb1Base+i, (unsigned char) color);
+- }
+- }
+- WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_BB0 | BM_READ_DST_BB1);
+- first_blt = 0;
+- }
+- else
+- {
+- /* AFTER FIRST BLT, THE TRANSPARENCY DATA IS LATCHED */
+- /* Save time by not reading data from BB1. */
+-
+- WRITE_REG16(GP_BLIT_MODE, BM_READ_SRC_BB0);
+- }
+- line_width -= section;
+- line_dstx += section;
+- line_srcx += section;
+- }
+- height--;
+- dsty++;
+- offset += pitch;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// MONOCHROME BITMAP TO SCREEN BLT
+-//
+-// This routine transfers monochrome bitmap data to the screen.
+-//
+-// SRCX X offset within source bitmap
+-// SRCY Y offset within source bitmap
+-// DSTX screen X position to render data
+-// DSTY screen Y position to render data
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// *DATA pointer to bitmap data
+-// PITCH pitch of bitmap data (bytes between scanlines)
+-// FGCOLOR color for bits = 1
+-// BGCOLOR color for bits = 0
+-// ROP ternary raster operation (0x00-0xFF).
+-// TRANSPARENT zero for opaque, otherwise transparent
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_mono_bitmap_to_screen_blt(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned char *data, unsigned short pitch,
+- unsigned short fgcolor, unsigned short bgcolor, unsigned char rop,
+- unsigned char transparent)
+-{
+- unsigned short section, buffer_width;
+- unsigned short blit_mode = BM_READ_SRC_BB0 | BM_SOURCE_EXPAND;
+- unsigned short line_srcx, line_dstx, line_width;
+- unsigned short offset, i, bytes, raster_mode;
+-
+- /* FORMAT 8BPP COLOR */
+- /* GX requires that 8BPP color data be duplicated into bits [15:8]. */
+-
+- if (!(READ_REG16(GP_BLIT_STATUS) & BC_16BPP))
+- {
+- fgcolor &= 0x00FF;
+- fgcolor |= (fgcolor << 8);
+- bgcolor &= 0x00FF;
+- bgcolor |= (bgcolor << 8);
+- }
+-
+- /* CHECK IF ROP REQUIRES DESTINATION DATA */
+- /* Even bits (0:2:4:6) do not equal corresponding odd bits (1:3:5:7). */
+-
+- if ((rop & 0x55) ^ ((rop >> 1) & 0x55))
+- blit_mode |= BM_READ_DST_FB1;
+-
+- /* CALCULATE RASTER MODE */
+- /* Set mono flag. Transparency set based on input parameter. */
+-
+- raster_mode = ((unsigned short) rop & 0x00FF);
+- if (transparent) raster_mode |= RM_SRC_TRANSPARENT;
+-
+- /* CHECK SIZE OF BLT BUFFER */
+-
+- buffer_width = GXRbufferWidthPixels;
+-
+- /* CALCULATE OFFSET INTO BITMAP DATA */
+-
+- offset = srcy * pitch;
+-
+- /* POLL UNTIL ABLE TO WRITE TO THE REGISTERS */
+- /* Write the registers that do not change for each section. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_HEIGHT, 1);
+- WRITE_REG16(GP_RASTER_MODE, raster_mode);
+- WRITE_REG16(GP_SRC_COLOR_0, bgcolor);
+- WRITE_REG16(GP_SRC_COLOR_1, fgcolor);
+-
+- /* REPEAT FOR EACH SCANLINE */
+-
+- while(height > 0)
+- {
+- line_width = width;
+- line_srcx = srcx;
+- line_dstx = dstx;
+-
+- while(line_width > 0)
+- {
+- /* CHECK WIDTH OF CURRENT SECTION */
+- /* Only divide into sections if reading destination data. */
+- /* Since the source data is monochrome, it will always fit. */
+-
+- section = line_width;
+- if ((line_width > buffer_width) && (blit_mode & BM_READ_DST_FB1))
+- section = buffer_width;
+-
+- /* BYTES TO TRANSFER */
+- /* Add two bytes to handle truncating and alignment. */
+-
+- bytes = (section >> 3) + 2;
+-
+- /* TRANSFER SCANLINE OF BITMAP DATA TO BLT BUFFER 0 */
+- /* Need to wait for BS_PIPELINE_BUSY to make sure that the */
+- /* data in BB0 for the previous scanline is no longer used. */
+- /* This can be heavily optimized to not do a byte at a time. */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY);
+- for (i = 0; i < bytes; i++)
+- {
+- WRITE_REG8(GXRbb0Base+i, data[(line_srcx >> 3)+offset+i]);
+- }
+-
+- /* RENDER FROM BB0 TO FRAME BUFFER */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, line_dstx);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_SRC_XCOOR, line_srcx & 7);
+- WRITE_REG16(GP_WIDTH, section);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+-
+- line_width -= section;
+- line_dstx += section;
+- line_srcx += section;
+- }
+- height--;
+- dsty++;
+- offset += pitch;
+- }
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// TEXT GLYPH
+-//
+-// This routine draws a single character of text. It can only be used for
+-// characters that are less than or equal to 64x64 in size, since it
+-// transfers the entire data into the BLT buffers at once. Larger characters
+-// should use the monochrome bitmap to screen routine. The only supported
+-// ROP is SRCCOPY, again since the BLT buffer size is limited.
+-//
+-// SRCX X offset within source bitmap
+-// SRCY Y offset within source bitmap
+-// DSTX screen X position to render data
+-// DSTY screen Y position to render data
+-// WIDTH width of rectangle, in pixels
+-// HEIGHT height of rectangle, in scanlines
+-// *DATA pointer to bitmap data (NULL if already loaded)
+-// PITCH pitch of bitmap data (bytes between scanlines)
+-//
+-// For the Xfree86 display driver, the OS is given a pointer to BB0.
+-// Therefore, the data is already loaded when the driver is called, so the
+-// driver simply passes a NULL pointer to this routine.
+-//
+-// This same type of routine could be developed for "icons", or small
+-// color bitmaps that can fit entirely in the BLT buffer.
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_text_glyph(unsigned short srcx, unsigned short srcy,
+- unsigned short dstx, unsigned short dsty, unsigned short width,
+- unsigned short height, unsigned char *data, unsigned short pitch)
+-{
+- unsigned short offset, i, j, buffer_offset, bytes, blit_mode;
+-
+- blit_mode = BM_READ_SRC_BB0 | BM_SOURCE_EXPAND;
+- if (GXRusesDstData) blit_mode |= BM_READ_DST_FB1;
+-
+- /* CHECK IF DATA NEEDS TO BE TRANSFERRED */
+-
+- if (data != 0)
+- {
+- /* TRANSFER ENTIRE BITMAP DATA TO BLT BUFFER 0 */
+- /* Need to wait for BS_PIPELINE_BUSY to make sure that the */
+- /* data in BB0 for any previous BLT is no longer used. */
+- /* This data transfer has lots of room for performance optimization. */
+-
+- buffer_offset = 0;
+- offset = srcy * pitch + (srcx >> 3);
+- bytes = ((width + (srcx & 7) + 7) >> 3);
+- while(READ_REG16(GP_BLIT_STATUS) & BS_PIPELINE_BUSY);
+- for (j = 0; j < height; j++)
+- {
+- for (i = 0; i < bytes; i++)
+- {
+- WRITE_REG8(GXRbb0Base+buffer_offset, data[offset+i]);
+- buffer_offset++;
+- }
+- offset += pitch;
+- }
+- }
+-
+- /* RENDER FROM BB0 TO FRAME BUFFER */
+- /* Already know that the pipeline is idle from loading data. */
+-
+- WRITE_REG16(GP_DST_XCOOR, dstx);
+- WRITE_REG16(GP_DST_YCOOR, dsty);
+- WRITE_REG16(GP_SRC_XCOOR, srcx & 7);
+- WRITE_REG16(GP_WIDTH, width);
+- WRITE_REG16(GP_HEIGHT, height);
+- WRITE_REG16(GP_BLIT_MODE, blit_mode);
+-}
+-
+-/*
+-//----------------------------------------------------------------------------
+-// BRESENHAM LINE
+-//
+-// This routine draws a vector using the specified Bresenham parameters.
+-// Currently this file does not support a routine that accepts the two
+-// endpoints of a vector and calculates the Bresenham parameters. If it
+-// ever does, this routine is still required for vectors that have been
+-// clipped.
+-//
+-// X screen X position to start vector
+-// Y screen Y position to start vector
+-// LENGTH length of the vector, in pixels
+-// INITERR Bresenham initial error term
+-// AXIALERR Bresenham axial error term
+-// DIAGERR Bresenham diagonal error term
+-// FLAGS VM_YMAJOR, VM_MAJOR_INC, VM_MINOR_INC
+-//----------------------------------------------------------------------------
+-*/
+-
+-void gxr_bresenham_line(unsigned short x, unsigned short y,
+- unsigned short length, unsigned short initerr,
+- unsigned short axialerr, unsigned short diagerr,
+- unsigned short flags)
+-{
+- unsigned short vector_mode = flags;
+- if (GXRusesDstData) vector_mode |= VM_READ_DST_FB;
+-
+- /* CHECK NULL LENGTH */
+-
+- if (!length) return;
+-
+- /* LOAD THE REGISTERS FOR THE VECTOR */
+-
+- while(READ_REG16(GP_BLIT_STATUS) & BS_BLIT_PENDING);
+- WRITE_REG16(GP_DST_XCOOR, x);
+- WRITE_REG16(GP_DST_YCOOR, y);
+- WRITE_REG16(GP_VECTOR_LENGTH, length);
+- WRITE_REG16(GP_INIT_ERROR, initerr);
+- WRITE_REG16(GP_AXIAL_ERROR, axialerr);
+- WRITE_REG16(GP_DIAG_ERROR, diagerr);
+- WRITE_REG16(GP_VECTOR_MODE, vector_mode);
+-}
+-
+-/* END OF FILE */
+-
projects / packages / XFree86.git / commitdiff