Initial revisionXORG-STABLE

3 files changed, 1996 insertions, 0 deletions

diff --git a/man/vesa.man b/man/vesa.man
new file mode 100644
index 0000000..5a9dfd5
--- /dev/null
+++ b/man/vesa.man
@@ -0,0 +1,52 @@
+.\" $XFree86: xc/programs/Xserver/hw/xfree86/drivers/vesa/vesa.man,v 1.3 2001/12/17 20:52:34 dawes Exp $ 
+.\" shorthand for double quote that works everywhere.
+.ds q \N'34'
+.TH VESA __drivermansuffix__ __vendorversion__
+.SH NAME
+vesa \- Generic VESA video driver
+.SH SYNOPSIS
+.nf
+.B "Section \*qDevice\*q"
+.BI "  Identifier \*q"  devname \*q
+.B  "  Driver \*qvesa\*q"
+\ \ ...
+.B EndSection
+.fi
+.SH DESCRIPTION
+.B vesa
+is an XFree86 driver for generic VESA video cards.  It can drive most
+VESA-compatible video cards, but only makes use of the basic standard
+VESA core that is common to these cards.  The driver supports depths 8, 15
+16 and 24.
+.SH SUPPORTED HARDWARE
+The
+.B vesa
+driver supports most VESA-compatible video cards.  There are some known
+exceptions, and those should be listed here.
+.SH CONFIGURATION DETAILS
+Please refer to XF86Config(__filemansuffix__) for general configuration
+details.  This section only covers configuration details specific to this
+driver.
+.PP
+The driver auto-detects the presence of VESA-compatible hardware.  The
+.B ChipSet
+name may optionally be specified in the config file
+.B \*qDevice\*q
+section, and will override the auto-detection:
+.PP
+.RS 4
+"vesa"
+.RE
+.PP
+The following driver
+.B Options
+are supported:
+.TP
+.BI "Option \*qShadowFB\*q \*q" boolean \*q
+Enable or disable use of the shadow framebuffer layer.  Default: on.
+
+This option is recommended for performance reasons.
+.SH "SEE ALSO"
+XFree86(1), XF86Config(__filemansuffix__), xf86cfg(1), xf86config(1), Xserver(1), X(__miscmansuffix__)
+.SH AUTHORS
+Authors include: Paulo César Pereira de Andrade.
diff --git a/src/vesa.c b/src/vesa.c
new file mode 100644
index 0000000..f54becc
--- /dev/null
+++ b/src/vesa.c
@@ -0,0 +1,1821 @@
+#define DEBUG_VERB 2
+/*
+ * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Conectiva Linux shall
+ * not be used in advertising or otherwise to promote the sale, use or other
+ * dealings in this Software without prior written authorization from
+ * Conectiva Linux.
+ *
+ * Authors: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
+ *          David Dawes <dawes@xfree86.org>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/drivers/vesa/vesa.c,v 1.36 2003/01/23 17:20:46 tsi Exp $
+ */
+
+#include "vesa.h"
+
+/* All drivers initialising the SW cursor need this */
+#include "mipointer.h"
+
+/* All drivers implementing backing store need this */
+#include "mibstore.h"
+
+/* Colormap handling */
+#include "micmap.h"
+#include "xf86cmap.h"
+
+/* DPMS */
+#define DPMS_SERVER
+#include "extensions/dpms.h"
+
+/* Mandatory functions */
+static const OptionInfoRec * VESAAvailableOptions(int chipid, int busid);
+static void VESAIdentify(int flags);
+static Bool VESAProbe(DriverPtr drv, int flags);
+static Bool VESAPreInit(ScrnInfoPtr pScrn, int flags);
+static Bool VESAScreenInit(int Index, ScreenPtr pScreen, int argc,
+			   char **argv);
+static Bool VESAEnterVT(int scrnIndex, int flags);
+static void VESALeaveVT(int scrnIndex, int flags);
+static Bool VESACloseScreen(int scrnIndex, ScreenPtr pScreen);
+static Bool VESASaveScreen(ScreenPtr pScreen, int mode);
+
+static Bool VESASwitchMode(int scrnIndex, DisplayModePtr pMode, int flags);
+static Bool VESASetMode(ScrnInfoPtr pScrn, DisplayModePtr pMode);
+static void VESAAdjustFrame(int scrnIndex, int x, int y, int flags);
+static void VESAFreeScreen(int scrnIndex, int flags);
+static void VESAFreeRec(ScrnInfoPtr pScrn);
+
+static void
+VESADisplayPowerManagementSet(ScrnInfoPtr pScrn, int mode,
+                int flags);
+
+/* locally used functions */
+static int VESAFindIsaDevice(GDevPtr dev);
+static Bool VESAMapVidMem(ScrnInfoPtr pScrn);
+static void VESAUnmapVidMem(ScrnInfoPtr pScrn);
+static int VESABankSwitch(ScreenPtr pScreen, unsigned int iBank);
+static void VESALoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
+			    LOCO *colors, VisualPtr pVisual);
+static void SaveFonts(ScrnInfoPtr pScrn);
+static void RestoreFonts(ScrnInfoPtr pScrn);
+static Bool 
+VESASaveRestore(ScrnInfoPtr pScrn, vbeSaveRestoreFunction function);
+
+static void *VESAWindowPlanar(ScreenPtr pScrn, CARD32 row, CARD32 offset,
+			      int mode, CARD32 *size, void *closure);
+static void *VESAWindowLinear(ScreenPtr pScrn, CARD32 row, CARD32 offset,
+			      int mode, CARD32 *size, void *closure);
+static void *VESAWindowWindowed(ScreenPtr pScrn, CARD32 row, CARD32 offset,
+				int mode, CARD32 *size, void *closure);
+
+static Bool VESADGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen);
+
+/* 
+ * This contains the functions needed by the server after loading the
+ * driver module.  It must be supplied, and gets added the driver list by
+ * the Module Setup funtion in the dynamic case.  In the static case a
+ * reference to this is compiled in, and this requires that the name of
+ * this DriverRec be an upper-case version of the driver name.
+ */
+DriverRec VESA = {
+    VESA_VERSION,
+    VESA_DRIVER_NAME,
+    VESAIdentify,
+    VESAProbe,
+    VESAAvailableOptions,
+    NULL,
+    0
+};
+
+enum GenericTypes
+{
+    CHIP_VESA_GENERIC
+};
+
+/* Supported chipsets */
+static SymTabRec VESAChipsets[] =
+{
+    {CHIP_VESA_GENERIC, "vesa"},
+    {-1,		 NULL}
+};
+
+static PciChipsets VESAPCIchipsets[] = {
+  { CHIP_VESA_GENERIC, PCI_CHIP_VGA, RES_SHARED_VGA },
+  { -1,		-1,	   RES_UNDEFINED },
+};
+
+static IsaChipsets VESAISAchipsets[] = {
+  {CHIP_VESA_GENERIC, RES_EXCLUSIVE_VGA},
+  {-1,		0 }
+};
+
+typedef enum {
+    OPTION_SHADOW_FB,
+    OPTION_DFLT_REFRESH
+} VESAOpts;
+
+static const OptionInfoRec VESAOptions[] = {
+    { OPTION_SHADOW_FB,    "ShadowFB",		OPTV_BOOLEAN,	{0},	FALSE },
+    { OPTION_DFLT_REFRESH, "DefaultRefresh",	OPTV_BOOLEAN,	{0},	FALSE },
+    { -1,		   NULL,		OPTV_NONE,	{0},	FALSE }
+};
+
+/*
+ * List of symbols from other modules that this module references.  This
+ * list is used to tell the loader that it is OK for symbols here to be
+ * unresolved providing that it hasn't been told that they haven't been
+ * told that they are essential via a call to xf86LoaderReqSymbols() or
+ * xf86LoaderReqSymLists().  The purpose is this is to avoid warnings about
+ * unresolved symbols that are not required.
+ */
+static const char *miscfbSymbols[] = {
+    "xf1bppScreenInit",
+    "xf4bppScreenInit",
+    "afbScreenInit",
+    "mfbScreenInit",
+    NULL
+};
+
+static const char *fbSymbols[] = {
+    "fbPictureInit",
+    "fbScreenInit",
+    NULL
+};
+
+static const char *shadowSymbols[] = {
+    "shadowAlloc",
+    "shadowInit",
+    "shadowUpdatePacked",
+    "shadowUpdatePlanar4",
+    "shadowUpdatePlanar4x8",
+    NULL
+};
+
+static const char *vbeSymbols[] = {
+    "VBEBankSwitch",
+    "VBEExtendedInit",
+    "VBEFindSupportedDepths",
+    "VBEGetModeInfo",
+    "VBEGetVBEInfo",
+    "VBEGetVBEMode",
+    "VBEPrintModes",
+    "VBESaveRestore",
+    "VBESetDisplayStart",
+    "VBESetGetDACPaletteFormat",
+    "VBESetGetLogicalScanlineLength",
+    "VBESetGetPaletteData",
+    "VBESetModeNames",
+    "VBESetModeParameters",
+    "VBESetVBEMode",
+    "VBEValidateModes",
+    "vbeDoEDID",
+    "vbeFree",
+    NULL
+};
+
+static const char *ddcSymbols[] = {
+    "xf86PrintEDID",
+    "xf86SetDDCproperties",
+    NULL
+};
+
+#ifdef XFree86LOADER
+
+/* Module loader interface */
+static MODULESETUPPROTO(vesaSetup);
+
+static XF86ModuleVersionInfo vesaVersionRec =
+{
+    VESA_DRIVER_NAME,
+    MODULEVENDORSTRING,
+    MODINFOSTRING1,
+    MODINFOSTRING2,
+    XF86_VERSION_CURRENT,
+    VESA_MAJOR_VERSION, VESA_MINOR_VERSION, VESA_PATCHLEVEL,
+    ABI_CLASS_VIDEODRV,			/* This is a video driver */
+    ABI_VIDEODRV_VERSION,
+    MOD_CLASS_VIDEODRV,
+    {0, 0, 0, 0}
+};
+
+/*
+ * This data is accessed by the loader.  The name must be the module name
+ * followed by "ModuleData".
+ */
+XF86ModuleData vesaModuleData = { &vesaVersionRec, vesaSetup, NULL };
+
+static pointer
+vesaSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor)
+{
+    static Bool Initialised = FALSE;
+
+    if (!Initialised)
+    {
+	Initialised = TRUE;
+	xf86AddDriver(&VESA, Module, 0);
+	LoaderRefSymLists(miscfbSymbols,
+			  fbSymbols,
+			  shadowSymbols,
+			  vbeSymbols,
+			  ddcSymbols,
+			  NULL);
+	return (pointer)TRUE;
+    }
+
+    if (ErrorMajor)
+	*ErrorMajor = LDR_ONCEONLY;
+    return (NULL);
+}
+
+#endif
+
+static const OptionInfoRec *
+VESAAvailableOptions(int chipid, int busid)
+{
+    return (VESAOptions);
+}
+
+static void
+VESAIdentify(int flags)
+{
+    xf86PrintChipsets(VESA_NAME, "driver for VESA chipsets", VESAChipsets);
+}
+
+/*
+ * This function is called once, at the start of the first server generation to
+ * do a minimal probe for supported hardware.
+ */
+
+static Bool
+VESAProbe(DriverPtr drv, int flags)
+{
+    Bool foundScreen = FALSE;
+    int numDevSections, numUsed;
+    GDevPtr *devSections;
+    int *usedChips;
+    int i;
+
+    /*
+     * Find the config file Device sections that match this
+     * driver, and return if there are none.
+     */
+    if ((numDevSections = xf86MatchDevice(VESA_NAME,
+					  &devSections)) <= 0)
+	return (FALSE);
+
+    /* PCI BUS */
+    if (xf86GetPciVideoInfo()) {
+	numUsed = xf86MatchPciInstances(VESA_NAME, PCI_VENDOR_GENERIC,
+					VESAChipsets, VESAPCIchipsets, 
+					devSections, numDevSections,
+					drv, &usedChips);
+	if (numUsed > 0) {
+	    if (flags & PROBE_DETECT)
+		foundScreen = TRUE;
+	    else {
+		for (i = 0; i < numUsed; i++) {
+		    ScrnInfoPtr pScrn = NULL;
+		    /* Allocate a ScrnInfoRec  */
+		    if ((pScrn = xf86ConfigPciEntity(pScrn,0,usedChips[i],
+						     VESAPCIchipsets,NULL,
+						     NULL,NULL,NULL,NULL))) {
+			pScrn->driverVersion = VESA_VERSION;
+			pScrn->driverName    = VESA_DRIVER_NAME;
+			pScrn->name	     = VESA_NAME;
+			pScrn->Probe	     = VESAProbe;
+			pScrn->PreInit       = VESAPreInit;
+			pScrn->ScreenInit    = VESAScreenInit;
+			pScrn->SwitchMode    = VESASwitchMode;
+			pScrn->AdjustFrame   = VESAAdjustFrame;
+			pScrn->EnterVT       = VESAEnterVT;
+			pScrn->LeaveVT       = VESALeaveVT;
+			pScrn->FreeScreen    = VESAFreeScreen;
+			foundScreen = TRUE;
+		    }
+		}
+	    }
+	    xfree(usedChips);
+	}
+    }
+
+    /* Isa Bus */
+    numUsed = xf86MatchIsaInstances(VESA_NAME,VESAChipsets,
+				    VESAISAchipsets, drv,
+				    VESAFindIsaDevice, devSections,
+				    numDevSections, &usedChips);
+    if(numUsed > 0) {
+	if (flags & PROBE_DETECT)
+	    foundScreen = TRUE;
+	else for (i = 0; i < numUsed; i++) {
+	    ScrnInfoPtr pScrn = NULL;
+	    if ((pScrn = xf86ConfigIsaEntity(pScrn, 0,usedChips[i],
+					     VESAISAchipsets, NULL,
+					     NULL, NULL, NULL, NULL))) {
+	    
+		pScrn->driverVersion = VESA_VERSION;
+		pScrn->driverName    = VESA_DRIVER_NAME;
+		pScrn->name	     = VESA_NAME;
+		pScrn->Probe	     = VESAProbe;
+		pScrn->PreInit       = VESAPreInit;
+		pScrn->ScreenInit    = VESAScreenInit;
+		pScrn->SwitchMode    = VESASwitchMode;
+		pScrn->AdjustFrame   = VESAAdjustFrame;
+		pScrn->EnterVT       = VESAEnterVT;
+		pScrn->LeaveVT       = VESALeaveVT;
+		pScrn->FreeScreen    = VESAFreeScreen;
+		foundScreen = TRUE;
+	    }
+	}
+	xfree(usedChips);
+    }
+
+    xfree(devSections);
+
+    return (foundScreen);
+}
+
+static int
+VESAFindIsaDevice(GDevPtr dev)
+{
+#ifndef PC98_EGC
+    CARD16 GenericIOBase = VGAHW_GET_IOBASE();
+    CARD8 CurrentValue, TestValue;
+
+    /* There's no need to unlock VGA CRTC registers here */
+
+    /* VGA has one more read/write attribute register than EGA */
+    (void) inb(GenericIOBase + VGA_IN_STAT_1_OFFSET);  /* Reset flip-flop */
+    outb(VGA_ATTR_INDEX, 0x14 | 0x20);
+    CurrentValue = inb(VGA_ATTR_DATA_R);
+    outb(VGA_ATTR_DATA_W, CurrentValue ^ 0x0F);
+    outb(VGA_ATTR_INDEX, 0x14 | 0x20);
+    TestValue = inb(VGA_ATTR_DATA_R);
+    outb(VGA_ATTR_DATA_R, CurrentValue);
+
+    /* Quit now if no VGA is present */
+    if ((CurrentValue ^ 0x0F) != TestValue)
+      return -1;
+#endif
+    return (int)CHIP_VESA_GENERIC;
+}
+
+static VESAPtr
+VESAGetRec(ScrnInfoPtr pScrn)
+{
+    if (!pScrn->driverPrivate)
+	pScrn->driverPrivate = xcalloc(sizeof(VESARec), 1);
+
+    return ((VESAPtr)pScrn->driverPrivate);
+}
+
+static void
+VESAFreeRec(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+#if 0
+    DisplayModePtr mode = pScrn->modes;
+    /* I am not sure if the modes will ever get freed.
+     * Anyway, the data unknown to other modules is being freed here.
+     */
+    if (mode) {
+	do {
+	    if (mode->Private) {
+		VbeModeInfoData *data = (VbeModeInfoData*)mode->Private;
+
+		if (data->block)
+		    xfree(data->block);
+
+		xfree(data);
+
+		mode->Private = NULL;
+	    }
+	    mode = mode->next;
+	} while (mode && mode != pScrn->modes);
+    }
+#endif
+    xfree(pVesa->monitor);
+    xfree(pVesa->vbeInfo);
+    xfree(pVesa->pal);
+    xfree(pVesa->savedPal);
+    xfree(pVesa->fonts);
+    xfree(pScrn->driverPrivate);
+    pScrn->driverPrivate = NULL;
+}
+
+/*
+ * This function is called once for each screen at the start of the first
+ * server generation to initialise the screen for all server generations.
+ */
+static Bool
+VESAPreInit(ScrnInfoPtr pScrn, int flags)
+{
+    VESAPtr pVesa;
+    VbeInfoBlock *vbe;
+    DisplayModePtr pMode;
+    VbeModeInfoBlock *mode;
+    char *mod = NULL;
+    const char *reqSym = NULL;
+    Gamma gzeros = {0.0, 0.0, 0.0};
+    rgb rzeros = {0, 0, 0};
+    pointer pVbeModule, pDDCModule;
+    int i;
+    int flags24 = 0;
+    int defaultDepth = 0;
+    int depths = 0;
+
+    if (flags & PROBE_DETECT)
+	return (FALSE);
+
+    pVesa = VESAGetRec(pScrn);
+    pVesa->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+    pVesa->device = xf86GetDevFromEntity(pScrn->entityList[0],
+					 pScrn->entityInstanceList[0]);
+
+#if 0
+    /* Load vgahw module */
+    if (!xf86LoadSubModule(pScrn, "vgahw"))
+    	return (FALSE);
+
+    xf86LoaderReqSymLists(vgahwSymbols, NULL);
+#endif
+
+    /* Load vbe module */
+    if ((pVbeModule = xf86LoadSubModule(pScrn, "vbe")) == NULL)
+        return (FALSE);
+
+    xf86LoaderReqSymLists(vbeSymbols, NULL);
+
+    if ((pVesa->pVbe = VBEExtendedInit(NULL, pVesa->pEnt->index,
+				       SET_BIOS_SCRATCH
+				       | RESTORE_BIOS_SCRATCH)) == NULL)
+        return (FALSE);
+
+    if (pVesa->pEnt->location.type == BUS_PCI) {
+	pVesa->pciInfo = xf86GetPciInfoForEntity(pVesa->pEnt->index);
+	pVesa->pciTag = pciTag(pVesa->pciInfo->bus, pVesa->pciInfo->device,
+			       pVesa->pciInfo->func);
+	pVesa->primary = xf86IsPrimaryPci(pVesa->pciInfo);
+    }
+    else
+	pVesa->primary = TRUE;
+
+    pScrn->chipset = "vesa";
+    pScrn->monitor = pScrn->confScreen->monitor;
+    pScrn->progClock = TRUE;
+    pScrn->rgbBits = 8;
+
+    if ((vbe = VBEGetVBEInfo(pVesa->pVbe)) == NULL)
+	return (FALSE);
+    pVesa->major = (unsigned)(vbe->VESAVersion >> 8);
+    pVesa->minor = vbe->VESAVersion & 0xff;
+    pVesa->vbeInfo = vbe;
+    pScrn->videoRam = vbe->TotalMemory * 64;
+
+    /*
+     * Find what depths are available.
+     */
+    depths = VBEFindSupportedDepths(pVesa->pVbe, pVesa->vbeInfo, &flags24,
+				    V_MODETYPE_VBE);
+
+    /* Preferred order for default depth selection. */
+    if (depths & V_DEPTH_16)
+	defaultDepth = 16;
+    else if (depths & V_DEPTH_15)
+	defaultDepth = 15;
+    else if (depths & V_DEPTH_8)
+	defaultDepth = 8;
+    else if (depths & V_DEPTH_24)
+	defaultDepth = 24;
+    else if (depths & V_DEPTH_4)
+	defaultDepth = 4;
+    else if (depths & V_DEPTH_1)
+	defaultDepth = 1;
+
+    /*
+     * Setting this avoids a "Driver can't support depth 24" message,
+     * which could be misleading.
+     */
+    if (!flags24)
+	flags24 = Support24bppFb;
+
+    /* Prefer 24bpp for fb since it potentially allows larger modes. */
+    if (flags24 & Support24bppFb)
+	flags24 |= SupportConvert32to24 | PreferConvert32to24;
+
+    if (!xf86SetDepthBpp(pScrn, defaultDepth, 0, 0, flags24)) {
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+    xf86PrintDepthBpp(pScrn);
+
+    /* color weight */
+    if (pScrn->depth > 8 && !xf86SetWeight(pScrn, rzeros, rzeros)) {
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+    /* visual init */
+    if (!xf86SetDefaultVisual(pScrn, -1)) {
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+
+    xf86SetGamma(pScrn, gzeros);
+
+    if (pVesa->major >= 2) {
+	/* Load ddc module */
+	if ((pDDCModule = xf86LoadSubModule(pScrn, "ddc")) == NULL) {
+	    vbeFree(pVesa->pVbe);
+	    return (FALSE);
+	}
+
+	if ((pVesa->monitor = vbeDoEDID(pVesa->pVbe, pDDCModule)) != NULL) {
+	    xf86PrintEDID(pVesa->monitor);
+	}
+
+	xf86UnloadSubModule(pDDCModule);
+    }
+
+    if ((pScrn->monitor->DDC = pVesa->monitor) != NULL)
+	xf86SetDDCproperties(pScrn, pVesa->monitor);
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DEBUG_VERB,
+			"Searching for matching VESA mode(s):\n");
+
+    /*
+     * Check the available BIOS modes, and extract those that match the
+     * requirements into the modePool.  Note: modePool is a NULL-terminated
+     * list.
+     */
+    pScrn->modePool = VBEGetModePool (pScrn, pVesa->pVbe, pVesa->vbeInfo,
+				      V_MODETYPE_VBE);
+
+    xf86ErrorFVerb(DEBUG_VERB, "\n");
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DEBUG_VERB,
+		   "Total Memory: %d 64KB banks (%dkB)\n", vbe->TotalMemory,
+		   (vbe->TotalMemory * 65536) / 1024);
+
+    pVesa->mapSize = vbe->TotalMemory * 65536;
+    if (pScrn->modePool == NULL) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No matching modes\n");
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+
+    VBESetModeNames(pScrn->modePool);
+
+    /*
+     * If DDC information is available, use it to try to set the monitor
+     * parameters if they're not already set.
+     *
+     * The common layer will already do this, but doesn't try as hard.  If
+     * this proves useful, it should probably be moved into the common layer.
+     */
+    if (pVesa->monitor != NULL) {
+	MonPtr pMon;
+
+	pMon = pScrn->monitor;
+	if (pMon->nHsync == 0 || pMon->nVrefresh == 0) {
+	    struct monitor_ranges *mRange;
+	    float hmin = 1e6, hmax = 0.0, vmin = 1e6, vmax = 0.0;
+	    float h;
+	    struct std_timings *t;
+	    int j, k;
+
+	    j = 0;
+	    for (i = 0; i < DET_TIMINGS; i++) {
+		if (pVesa->monitor->det_mon[i].type == DS_RANGES) {
+		    mRange = &pVesa->monitor->det_mon[i].section.ranges;
+		    pMon->hsync[j].lo = mRange->min_h;
+		    pMon->hsync[j].hi = mRange->max_h;
+		    pMon->vrefresh[j].lo = mRange->min_v;
+		    pMon->vrefresh[j].hi = mRange->max_v;
+		    j++;
+		} else if (pVesa->monitor->det_mon[i].type == DS_STD_TIMINGS) {
+		    t = pVesa->monitor->det_mon[i].section.std_t;
+		    for (k = 0; k < 5; k++) {
+			if (t[k].hsize > 256) { /* sanity check */
+			    if (t[k].refresh < vmin)
+				vmin = t[i].refresh;
+			    if (t[k].refresh > vmax)
+				vmax = t[i].refresh;
+			    h = t[k].refresh * 1.07 * t[k].vsize / 1000.0;
+			    if (h < hmin)
+				hmin = h;
+			    if (h > hmax)
+				hmax = h;
+			}
+		    }
+		}
+		
+		if (j > MAX_HSYNC)
+		    break;
+	    }
+
+	    if (j == 0) {
+		t = pVesa->monitor->timings2;
+		for (i = 0; i < STD_TIMINGS; i++) {
+		    if (t[i].hsize > 256) { /* sanity check */
+			if (t[i].refresh < vmin)
+			    vmin = t[i].refresh;
+			if (t[i].refresh > vmax)
+			    vmax = t[i].refresh;
+			h = t[i].refresh * 1.07 * t[i].vsize / 1000.0;
+			if (h < hmin)
+			    hmin = h;
+			if (h > hmax)
+			    hmax = h;
+		    }
+		}
+		if (hmax > 0.0) {
+		    pMon->hsync[j].lo = hmin;
+		    pMon->hsync[j].hi = hmax;
+		    pMon->vrefresh[j].lo = vmin;
+		    pMon->vrefresh[j].hi = vmax;
+		    j++;
+		}
+	    }
+	    if (j > 0) {
+		pMon->nHsync = pMon->nVrefresh = j;
+		xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+			   "Monitor parameters set to DDC-probed values\n");
+	    }
+	}
+    }
+
+    i = VBEValidateModes(pScrn, NULL, pScrn->display->modes, 
+			  NULL, NULL, 0, 2048, 1, 0, 2048,
+			  pScrn->display->virtualX,
+			  pScrn->display->virtualY,
+			  pVesa->mapSize, LOOKUP_BEST_REFRESH);
+
+    if (i <= 0) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes\n");
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+
+    xf86PruneDriverModes(pScrn);
+
+    pMode = pScrn->modes;
+    do {
+	mode = ((VbeModeInfoData*)pMode->Private)->data;
+	if (mode->BytesPerScanline > pVesa->maxBytesPerScanline) {
+	    pVesa->maxBytesPerScanline = mode->BytesPerScanline;
+	}
+	pMode = pMode->next;
+    } while (pMode != pScrn->modes);
+
+    pScrn->currentMode = pScrn->modes;
+    pScrn->displayWidth = pScrn->virtualX;
+
+    VBEPrintModes(pScrn);
+
+    /* Set display resolution */
+    xf86SetDpi(pScrn, 0, 0);
+
+    if (pScrn->modes == NULL) {
+	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes\n");
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+
+    /* options */
+    xf86CollectOptions(pScrn, NULL);
+    if (!(pVesa->Options = xalloc(sizeof(VESAOptions)))) {
+        vbeFree(pVesa->pVbe);
+	return FALSE;
+    }
+    memcpy(pVesa->Options, VESAOptions, sizeof(VESAOptions));
+    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pVesa->Options);
+
+    /* Use shadow by default */
+    if (xf86ReturnOptValBool(pVesa->Options, OPTION_SHADOW_FB, TRUE)) 
+	pVesa->shadowFB = TRUE;
+
+    if (xf86ReturnOptValBool(pVesa->Options, OPTION_DFLT_REFRESH, FALSE))
+	pVesa->defaultRefresh = TRUE;
+
+    if (!pVesa->defaultRefresh)
+	VBESetModeParameters(pScrn, pVesa->pVbe);
+
+    mode = ((VbeModeInfoData*)pScrn->modes->Private)->data;
+    switch (mode->MemoryModel) {
+	case 0x0:	/* Text mode */
+	case 0x1:	/* CGA graphics */
+	case 0x2:	/* Hercules graphics */
+	case 0x5:	/* Non-chain 4, 256 color */
+	case 0x7:	/* YUV */
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Unsupported Memory Model: %d", mode->MemoryModel);
+	    break;
+	case 0x3:	/* Planar */
+	    if (pVesa->shadowFB) {
+		mod = "fb";
+		pScrn->bitmapBitOrder = BITMAP_BIT_ORDER; 
+
+		xf86LoaderReqSymbols("fbPictureInit", NULL);
+	    }
+	    else {
+		switch (pScrn->bitsPerPixel) {
+		    case 1:
+			mod = "xf1bpp";
+			reqSym = "xf1bppScreenInit";
+			break;
+		    case 4:
+			mod = "xf4bpp";
+			reqSym = "xf4bppScreenInit";
+			break;
+		    default:
+			mod = "afb";
+			reqSym = "afbScreenInit";
+			break;
+		}
+	    }
+	    break;
+	case 0x4:	/* Packed pixel */
+	case 0x6:	/*  Direct Color */
+	    mod = "fb";
+	    pScrn->bitmapBitOrder = BITMAP_BIT_ORDER; 
+
+	    switch (pScrn->bitsPerPixel) {
+		case 8:
+		case 16:
+		case 24:
+		case 32:
+		    break;
+		default:
+		    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+			       "Unsupported bpp: %d", pScrn->bitsPerPixel);
+		    vbeFree(pVesa->pVbe);
+		    return FALSE;
+	    }
+	    break;
+    }
+
+    if (pVesa->shadowFB) {
+	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Using \"Shadow Framebuffer\"\n");
+	if (pScrn->depth == 1) {
+            mod = "mfb";
+	    reqSym = "mfbScreenInit";
+	}
+	if (!xf86LoadSubModule(pScrn, "shadow")) {
+	    vbeFree(pVesa->pVbe);
+	    return (FALSE);
+	}
+	xf86LoaderReqSymLists(shadowSymbols, NULL);
+    }
+
+    if (mod && xf86LoadSubModule(pScrn, mod) == NULL) {
+	VESAFreeRec(pScrn);
+        vbeFree(pVesa->pVbe);
+	return (FALSE);
+    }
+
+    if (mod) {
+	if (reqSym) {
+	    xf86LoaderReqSymbols(reqSym, NULL);
+	} else {
+	    xf86LoaderReqSymLists(fbSymbols, NULL);
+	}
+    }
+
+    vbeFree(pVesa->pVbe);
+
+    return (TRUE);
+}
+
+static Bool
+VESAScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    VisualPtr visual;
+    VbeModeInfoBlock *mode;
+    int flags;
+    int init_picture = 0;
+
+    if ((pVesa->pVbe = VBEExtendedInit(NULL, pVesa->pEnt->index,
+				       SET_BIOS_SCRATCH
+				       | RESTORE_BIOS_SCRATCH)) == NULL)
+        return (FALSE);
+
+    if (pVesa->mapPhys == 0) {
+	mode = ((VbeModeInfoData*)(pScrn->currentMode->Private))->data;
+	pScrn->videoRam = pVesa->mapSize;
+	pVesa->mapPhys = mode->PhysBasePtr;
+	pVesa->mapOff = 0;
+    }
+
+    if (pVesa->mapPhys == 0) {
+	pVesa->mapPhys = 0xa0000;
+	pVesa->mapSize = 0x10000;
+    }
+
+    if (!VESAMapVidMem(pScrn)) {
+	if (pVesa->mapPhys != 0xa0000) {
+	    pVesa->mapPhys = 0xa0000;
+	    pVesa->mapSize = 0x10000;
+	    if (!VESAMapVidMem(pScrn))
+		return (FALSE);
+	}
+	else
+	    return (FALSE);
+    }
+
+    /* Set bpp to 8 for depth 4 when using shadowfb. */
+    if (pVesa->shadowFB && pScrn->bitsPerPixel == 4)
+	pScrn->bitsPerPixel = 8;
+
+    if (pVesa->shadowFB && (pVesa->shadowPtr =
+	shadowAlloc(pScrn->virtualX, pScrn->virtualY,
+		    pScrn->bitsPerPixel)) == NULL)
+	return (FALSE);
+
+    /* save current video state */
+    VESASaveRestore(pScrn, MODE_SAVE);
+    pVesa->savedPal = VBESetGetPaletteData(pVesa->pVbe, FALSE, 0, 256,
+					    NULL, FALSE, FALSE);
+
+    /* set first video mode */
+    if (!VESASetMode(pScrn, pScrn->currentMode))
+	return (FALSE);
+
+    /* mi layer */
+    miClearVisualTypes();
+    if (!xf86SetDefaultVisual(pScrn, -1))
+	return (FALSE);
+    if (pScrn->bitsPerPixel > 8) {
+	if (!miSetVisualTypes(pScrn->depth, TrueColorMask,
+			      pScrn->rgbBits, TrueColor))
+	    return (FALSE);
+    }
+    else {
+	if (!miSetVisualTypes(pScrn->depth,
+			      miGetDefaultVisualMask(pScrn->depth),
+			      pScrn->rgbBits, pScrn->defaultVisual))
+	    return (FALSE);
+    }
+    if (!miSetPixmapDepths())
+	return (FALSE);
+
+    mode = ((VbeModeInfoData*)pScrn->modes->Private)->data;
+    switch (mode->MemoryModel) {
+	case 0x0:	/* Text mode */
+	case 0x1:	/* CGA graphics */
+	case 0x2:	/* Hercules graphics */
+	case 0x5:	/* Non-chain 4, 256 color */
+	case 0x7:	/* YUV */
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Unsupported Memory Model: %d", mode->MemoryModel);
+	    return (FALSE);
+	case 0x3:	/* Planar */
+	    if (pVesa->shadowFB) {
+	        if (pScrn->depth == 1) {
+		    if (!mfbScreenInit(pScreen,
+				      pVesa->shadowPtr,
+				      pScrn->virtualX, pScrn->virtualY,
+				      pScrn->xDpi, pScrn->yDpi,
+				      pScrn->displayWidth))
+		        return FALSE;
+		} else {
+		    if (!fbScreenInit(pScreen,
+				      pVesa->shadowPtr,
+				      pScrn->virtualX, pScrn->virtualY,
+				      pScrn->xDpi, pScrn->yDpi,
+				      pScrn->displayWidth, pScrn->bitsPerPixel))
+		    return (FALSE);
+		    init_picture = 1;
+		}
+	    } else {
+		switch (pScrn->bitsPerPixel) {
+		    case 1:
+			if (!xf1bppScreenInit(pScreen, pVesa->base,
+					      pScrn->virtualX, pScrn->virtualY,
+					      pScrn->xDpi, pScrn->yDpi,
+					      pScrn->displayWidth))
+			    return (FALSE);
+			break;
+		    case 4:
+			if (!xf4bppScreenInit(pScreen, pVesa->base,
+					      pScrn->virtualX, pScrn->virtualY,
+					      pScrn->xDpi, pScrn->yDpi,
+					      pScrn->displayWidth))
+			    return (FALSE);
+			break;
+		    default:
+			if (!afbScreenInit(pScreen, pVesa->base,
+					   pScrn->virtualX, pScrn->virtualY,
+					   pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth))
+			    return (FALSE);
+			break;
+		}
+	    }
+	    break;
+	case 0x4:	/* Packed pixel */
+	case 0x6:	/*  Direct Color */
+	    switch (pScrn->bitsPerPixel) {
+		case 8:
+		case 16:
+		case 24:
+		case 32:
+		    if (!fbScreenInit(pScreen,
+			    pVesa->shadowFB ? pVesa->shadowPtr : pVesa->base,
+				       pScrn->virtualX, pScrn->virtualY,
+				       pScrn->xDpi, pScrn->yDpi,
+				       pScrn->displayWidth, pScrn->bitsPerPixel))
+			return (FALSE);
+		    init_picture = 1;
+		    break;
+		default:
+		    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+			       "Unsupported bpp: %d", pScrn->bitsPerPixel);
+		    return (FALSE);
+	    }
+	    break;
+    }
+
+
+    if (pScrn->bitsPerPixel > 8) {
+	/* Fixup RGB ordering */
+	visual = pScreen->visuals + pScreen->numVisuals;
+	while (--visual >= pScreen->visuals) {
+	    if ((visual->class | DynamicClass) == DirectColor) {
+		visual->offsetRed   = pScrn->offset.red;
+		visual->offsetGreen = pScrn->offset.green;
+		visual->offsetBlue  = pScrn->offset.blue;
+		visual->redMask     = pScrn->mask.red;
+		visual->greenMask   = pScrn->mask.green;
+		visual->blueMask    = pScrn->mask.blue;
+	    }
+	}
+    }
+
+    /* must be after RGB ordering fixed */
+    if (init_picture)
+	fbPictureInit(pScreen, 0, 0);
+
+    if (pVesa->shadowFB) {
+	ShadowUpdateProc update;
+	ShadowWindowProc window;
+
+	if (mode->MemoryModel == 3) {	/* Planar */
+	  if (pScrn->bitsPerPixel == 8)
+		update = shadowUpdatePlanar4x8;
+	    else
+		update = shadowUpdatePlanar4;
+	    window = VESAWindowPlanar;
+	}
+	else if (pVesa->mapPhys == 0xa0000) {	/* Windowed */
+	    update = shadowUpdatePacked;
+	    window = VESAWindowWindowed;
+	}
+	else {	/* Linear */
+	    update = shadowUpdatePacked;
+	    window = VESAWindowLinear;
+	}
+
+	if (!shadowInit(pScreen, update, window))
+	    return (FALSE);
+    }
+    else if (pVesa->mapPhys == 0xa0000 && mode->MemoryModel != 0x3) {
+	unsigned int bankShift = 0;
+	while ((unsigned)(64 >> bankShift) != mode->WinGranularity)
+	    bankShift++;
+	pVesa->curBank = -1;
+	pVesa->bank.SetSourceBank =
+	pVesa->bank.SetDestinationBank =
+	pVesa->bank.SetSourceAndDestinationBanks = VESABankSwitch;
+	pVesa->bank.pBankA = pVesa->bank.pBankB = pVesa->base;
+	pVesa->bank.BankSize = (mode->WinSize * 1024) >> bankShift;
+	pVesa->bank.nBankDepth = pScrn->depth;
+	if (!miInitializeBanking(pScreen, pScrn->virtualX, pScrn->virtualY,
+				 pScrn->virtualX, &pVesa->bank)) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Bank switch initialization failed!\n");
+	    return (FALSE);
+	}
+    }
+
+    VESADGAInit(pScrn, pScreen);
+
+    xf86SetBlackWhitePixels(pScreen);
+    miInitializeBackingStore(pScreen);
+    xf86SetBackingStore(pScreen);
+
+    /* software cursor */
+    miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+
+    /* colormap */
+    if (!miCreateDefColormap(pScreen))
+	return (FALSE);
+
+    flags = CMAP_RELOAD_ON_MODE_SWITCH;
+
+    if(!xf86HandleColormaps(pScreen, 256,
+	pVesa->vbeInfo->Capabilities[0] & 0x01 ? 8 : 6,
+	VESALoadPalette, NULL, flags))
+	return (FALSE);
+
+    pVesa->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = VESACloseScreen;
+    pScreen->SaveScreen = VESASaveScreen;
+
+    xf86DPMSInit(pScreen, VESADisplayPowerManagementSet, 0);
+
+    /* Report any unused options (only for the first generation) */
+    if (serverGeneration == 1)
+        xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+
+    return (TRUE);
+}
+
+static Bool
+VESAEnterVT(int scrnIndex, int flags)
+{
+    return (VESASetMode(xf86Screens[scrnIndex],
+			xf86Screens[scrnIndex]->currentMode));
+}
+
+static void
+VESALeaveVT(int scrnIndex, int flags)
+{
+    VESASaveRestore(xf86Screens[scrnIndex], MODE_RESTORE);
+}
+
+static Bool
+VESACloseScreen(int scrnIndex, ScreenPtr pScreen)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    if (pScrn->vtSema) {
+	VESASaveRestore(xf86Screens[scrnIndex], MODE_RESTORE);
+	VBESetGetPaletteData(pVesa->pVbe, TRUE, 0, 256,
+			     pVesa->savedPal, FALSE, TRUE);
+	VESAUnmapVidMem(pScrn);
+    }
+    if (pVesa->shadowPtr) {
+	xfree(pVesa->shadowPtr);
+	pVesa->shadowPtr = NULL;
+    }
+    if (pVesa->pDGAMode) {
+	xfree(pVesa->pDGAMode);
+	pVesa->pDGAMode = NULL;
+	pVesa->nDGAMode = 0;
+    }
+    pScrn->vtSema = FALSE;
+
+    pScreen->CloseScreen = pVesa->CloseScreen;
+    return pScreen->CloseScreen(scrnIndex, pScreen);
+}
+
+static Bool
+VESASwitchMode(int scrnIndex, DisplayModePtr pMode, int flags)
+{
+    return VESASetMode(xf86Screens[scrnIndex], pMode);
+}
+
+/* Set a graphics mode */
+static Bool
+VESASetMode(ScrnInfoPtr pScrn, DisplayModePtr pMode)
+{
+    VESAPtr pVesa;
+    VbeModeInfoData *data;
+    int mode;
+
+    pVesa = VESAGetRec(pScrn);
+
+    data = (VbeModeInfoData*)pMode->Private;
+
+    mode = data->mode | (1 << 15);
+
+    /* enable linear addressing */
+    if (pVesa->mapPhys != 0xa0000)
+	mode |= 1 << 14;
+
+    if (VBESetVBEMode(pVesa->pVbe, mode, data->block) == FALSE) {
+	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "VBESetVBEMode failed");
+	if ((data->block || (data->mode & (1 << 11))) &&
+	    VBESetVBEMode(pVesa->pVbe, (mode & ~(1 << 11)), NULL) == TRUE) {
+	    /* Some cards do not like setting the clock.
+	     * Free it as it will not be any longer useful
+	     */
+	    xf86ErrorF("...Tried again without customized values.\n");
+	    xfree(data->block);
+	    data->block = NULL;
+	    data->mode &= ~(1 << 11);
+	}
+	else {
+	    ErrorF("\n");
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Set VBE Mode failed!\n");
+	    return (FALSE);
+	}
+    }
+
+    pVesa->bankSwitchWindowB =
+	!((data->data->WinBSegment == 0) && (data->data->WinBAttributes == 0));
+
+    if (data->data->XResolution != pScrn->displayWidth)
+	VBESetLogicalScanline(pVesa->pVbe, pScrn->displayWidth);
+
+    if (pScrn->bitsPerPixel >= 8 && pVesa->vbeInfo->Capabilities[0] & 0x01)
+	VBESetGetDACPaletteFormat(pVesa->pVbe, 8);
+
+    pScrn->vtSema = TRUE;
+
+    return (TRUE);
+}
+
+static void
+VESAAdjustFrame(int scrnIndex, int x, int y, int flags)
+{
+    VESAPtr pVesa = VESAGetRec(xf86Screens[scrnIndex]);
+
+    VBESetDisplayStart(pVesa->pVbe, x, y, TRUE);
+}
+
+static void
+VESAFreeScreen(int scrnIndex, int flags)
+{
+    VESAFreeRec(xf86Screens[scrnIndex]);
+}
+
+static Bool
+VESAMapVidMem(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    if (pVesa->base != NULL)
+	return (TRUE);
+
+    pScrn->memPhysBase = pVesa->mapPhys;
+    pScrn->fbOffset = pVesa->mapOff;
+
+    if (pVesa->mapPhys != 0xa0000 && pVesa->pEnt->location.type == BUS_PCI)
+	pVesa->base = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
+				    pVesa->pciTag, pScrn->memPhysBase,
+				    pVesa->mapSize);
+    else
+	pVesa->base = xf86MapDomainMemory(pScrn->scrnIndex, 0, pVesa->pciTag,
+					  pScrn->memPhysBase, pVesa->mapSize);
+
+    if (pVesa->base) {
+	if (pVesa->mapPhys != 0xa0000)
+	    pVesa->VGAbase = xf86MapDomainMemory(pScrn->scrnIndex, 0,
+						 pVesa->pciTag,
+						 0xa0000, 0x10000);
+	else
+	    pVesa->VGAbase = pVesa->base;
+    }
+
+    pVesa->ioBase = pScrn->domainIOBase;
+
+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, DEBUG_VERB,
+		   "virtual address = %p,\n"
+		   "\tphysical address = %p, size = %d\n",
+		   pVesa->base, pScrn->memPhysBase, pVesa->mapSize);
+
+    return (pVesa->base != NULL);
+}
+
+static void
+VESAUnmapVidMem(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    if (pVesa->base == NULL)
+	return;
+
+    xf86UnMapVidMem(pScrn->scrnIndex, pVesa->base, pVesa->mapSize);
+    if (pVesa->mapPhys != 0xa0000)
+	xf86UnMapVidMem(pScrn->scrnIndex, pVesa->VGAbase, 0x10000);
+    pVesa->base = NULL;
+}
+
+void *
+VESAWindowPlanar(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode,
+		 CARD32 *size, void *closure)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    VbeModeInfoBlock *data = ((VbeModeInfoData*)(pScrn->currentMode->Private))->data;
+    int window;
+    int mask = 1 << (offset & 3);
+
+    outb(pVesa->ioBase + VGA_SEQ_INDEX, 2);
+    outb(pVesa->ioBase + VGA_SEQ_DATA, mask);
+    offset = (offset >> 2) + pVesa->maxBytesPerScanline * row;
+    window = offset / (data->WinGranularity * 1024);
+    pVesa->windowAoffset = window * data->WinGranularity * 1024;
+    VESABankSwitch(pScreen, window);
+    *size = data->WinSize * 1024 - (offset - pVesa->windowAoffset);
+
+    return (void *)((unsigned long)pVesa->base +
+		   (offset - pVesa->windowAoffset));
+}
+
+static void *
+VESAWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode,
+		 CARD32 *size, void *closure)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    *size = pVesa->maxBytesPerScanline;
+    return ((CARD8 *)pVesa->base + row * pVesa->maxBytesPerScanline + offset);
+}
+
+static void *
+VESAWindowWindowed(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode,
+		   CARD32 *size, void *closure)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    VbeModeInfoBlock *data = ((VbeModeInfoData*)(pScrn->currentMode->Private))->data;
+    int window;
+
+    offset += pVesa->maxBytesPerScanline * row;
+    window = offset / (data->WinGranularity * 1024);
+    pVesa->windowAoffset = window * data->WinGranularity * 1024;
+    VESABankSwitch(pScreen, window);
+    *size = data->WinSize * 1024 - (offset - pVesa->windowAoffset);
+
+    return (void *)((unsigned long)pVesa->base +
+		    (offset - pVesa->windowAoffset));
+}
+
+static void
+VESALoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
+		LOCO *colors, VisualPtr pVisual)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    int i, idx;
+
+#if 0
+
+    /* This code works, but is very slow for programs that use it intensively */
+    int base;
+
+    if (pVesa->pal == NULL)
+	pVesa->pal = xcalloc(1, sizeof(CARD32) * 256);
+
+    for (i = 0, base = idx = indices[i]; i < numColors; i++, idx++) {
+	int j = indices[i];
+
+	if (j < 0 || j >= 256)
+	    continue;
+	pVesa->pal[j] = colors[j].blue |
+			(colors[j].green << 8) |
+			(colors[j].red << 16);
+	if (j != idx) {
+	    VBESetGetPaletteData(pVesa->pVbe, TRUE, base, idx - base,
+				  pVesa->pal + base, FALSE, TRUE);
+	    idx = base = j;
+	}
+    }
+
+    if (idx - 1 == indices[i - 1])
+	VBESetGetPaletteData(pVesa->pVbe, TRUE, base, idx - base,
+			      pVesa->pal + base, FALSE, TRUE);
+
+#else
+
+#define VESADACDelay()							    \
+    do {								    \
+	(void)inb(pVesa->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET); \
+	(void)inb(pVesa->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET); \
+    } while (0)
+
+    for (i = 0; i < numColors; i++) {
+	idx = indices[i];
+	outb(pVesa->ioBase + VGA_DAC_WRITE_ADDR, idx);
+	VESADACDelay();
+	outb(pVesa->ioBase + VGA_DAC_DATA, colors[idx].red);
+	VESADACDelay();
+	outb(pVesa->ioBase + VGA_DAC_DATA, colors[idx].green);
+	VESADACDelay();
+	outb(pVesa->ioBase + VGA_DAC_DATA, colors[idx].blue);
+	VESADACDelay();
+    }
+
+#endif
+}
+
+/*
+ * Just adapted from the std* functions in vgaHW.c
+ */
+static void
+WriteAttr(VESAPtr pVesa, int index, int value)
+{
+    CARD8 tmp;
+
+    tmp = inb(pVesa->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET);
+
+    index |= 0x20;
+    outb(pVesa->ioBase + VGA_ATTR_INDEX, index);
+    outb(pVesa->ioBase + VGA_ATTR_DATA_W, value);
+}
+
+static int
+ReadAttr(VESAPtr pVesa, int index)
+{
+    CARD8 tmp;
+
+    tmp = inb(pVesa->ioBase + VGA_IOBASE_COLOR + VGA_IN_STAT_1_OFFSET);
+
+    index |= 0x20;
+    outb(pVesa->ioBase + VGA_ATTR_INDEX, index);
+    return (inb(pVesa->ioBase + VGA_ATTR_DATA_R));
+}
+
+#define WriteMiscOut(value)	outb(pVesa->ioBase + VGA_MISC_OUT_W, value)
+#define ReadMiscOut()		inb(pVesa->ioBase + VGA_MISC_OUT_R)
+#define WriteSeq(index, value)	outb(pVesa->ioBase + VGA_SEQ_INDEX, index);\
+				outb(pVesa->ioBase + VGA_SEQ_DATA, value)
+
+static int
+ReadSeq(VESAPtr pVesa, int index)
+{
+    outb(pVesa->ioBase + VGA_SEQ_INDEX, index);
+
+    return (inb(pVesa->ioBase + VGA_SEQ_DATA));
+}
+
+#define WriteGr(index, value)				\
+    outb(pVesa->ioBase + VGA_GRAPH_INDEX, index);	\
+    outb(pVesa->ioBase + VGA_GRAPH_DATA, value)
+
+static int
+ReadGr(VESAPtr pVesa, int index)
+{
+    outb(pVesa->ioBase + VGA_GRAPH_INDEX, index);
+
+    return (inb(pVesa->ioBase + VGA_GRAPH_DATA));
+}
+
+#define WriteCrtc(index, value)						     \
+    outb(pVesa->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_INDEX_OFFSET), index); \
+    outb(pVesa->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_DATA_OFFSET), value)
+
+static int
+ReadCrtc(VESAPtr pVesa, int index)
+{
+    outb(pVesa->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_INDEX_OFFSET), index);
+    return inb(pVesa->ioBase + (VGA_IOBASE_COLOR + VGA_CRTC_DATA_OFFSET));
+}
+
+static void
+SeqReset(VESAPtr pVesa, Bool start)
+{
+    if (start) {
+	WriteSeq(0x00, 0x01);		/* Synchronous Reset */
+    }
+    else {
+	WriteSeq(0x00, 0x03);		/* End Reset */
+    }
+}
+
+static void
+SaveFonts(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    unsigned char miscOut, attr10, gr4, gr5, gr6, seq2, seq4, scrn;
+
+    if (pVesa->fonts != NULL)
+	return;
+
+    /* If in graphics mode, don't save anything */
+    attr10 = ReadAttr(pVesa, 0x10);
+    if (attr10 & 0x01)
+	return;
+
+    pVesa->fonts = xalloc(16384);
+
+    /* save the registers that are needed here */
+    miscOut = ReadMiscOut();
+    gr4 = ReadGr(pVesa, 0x04);
+    gr5 = ReadGr(pVesa, 0x05);
+    gr6 = ReadGr(pVesa, 0x06);
+    seq2 = ReadSeq(pVesa, 0x02);
+    seq4 = ReadSeq(pVesa, 0x04);
+
+    /* Force into colour mode */
+    WriteMiscOut(miscOut | 0x01);
+
+    scrn = ReadSeq(pVesa, 0x01) | 0x20;
+    SeqReset(pVesa, TRUE);
+    WriteSeq(0x01, scrn);
+    SeqReset(pVesa, FALSE);
+
+    WriteAttr(pVesa, 0x10, 0x01);	/* graphics mode */
+
+    /*font1 */
+    WriteSeq(0x02, 0x04);	/* write to plane 2 */
+    WriteSeq(0x04, 0x06);	/* enable plane graphics */
+    WriteGr(0x04, 0x02);	/* read plane 2 */
+    WriteGr(0x05, 0x00);	/* write mode 0, read mode 0 */
+    WriteGr(0x06, 0x05);	/* set graphics */
+    slowbcopy_frombus(pVesa->VGAbase, pVesa->fonts, 8192);
+
+    /* font2 */
+    WriteSeq(0x02, 0x08);	/* write to plane 3 */
+    WriteSeq(0x04, 0x06);	/* enable plane graphics */
+    WriteGr(0x04, 0x03);	/* read plane 3 */
+    WriteGr(0x05, 0x00);	/* write mode 0, read mode 0 */
+    WriteGr(0x06, 0x05);	/* set graphics */
+    slowbcopy_frombus(pVesa->VGAbase, pVesa->fonts + 8192, 8192);
+
+    scrn = ReadSeq(pVesa, 0x01) & ~0x20;
+    SeqReset(pVesa, TRUE);
+    WriteSeq(0x01, scrn);
+    SeqReset(pVesa, FALSE);
+
+    /* Restore clobbered registers */
+    WriteAttr(pVesa, 0x10, attr10);
+    WriteSeq(0x02, seq2);
+    WriteSeq(0x04, seq4);
+    WriteGr(0x04, gr4);
+    WriteGr(0x05, gr5);
+    WriteGr(0x06, gr6);
+    WriteMiscOut(miscOut);
+}
+
+static void
+RestoreFonts(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    unsigned char miscOut, attr10, gr1, gr3, gr4, gr5, gr6, gr8, seq2, seq4, scrn;
+
+    if (pVesa->fonts == NULL)
+	return;
+
+    if (pVesa->mapPhys == 0xa0000 && pVesa->curBank != 0)
+	VESABankSwitch(pScrn->pScreen, 0);
+
+    /* save the registers that are needed here */
+    miscOut = ReadMiscOut();
+    attr10 = ReadAttr(pVesa, 0x10);
+    gr1 = ReadGr(pVesa, 0x01);
+    gr3 = ReadGr(pVesa, 0x03);
+    gr4 = ReadGr(pVesa, 0x04);
+    gr5 = ReadGr(pVesa, 0x05);
+    gr6 = ReadGr(pVesa, 0x06);
+    gr8 = ReadGr(pVesa, 0x08);
+    seq2 = ReadSeq(pVesa, 0x02);
+    seq4 = ReadSeq(pVesa, 0x04);
+
+    /* Force into colour mode */
+    WriteMiscOut(miscOut | 0x01);
+
+    scrn = ReadSeq(pVesa, 0x01) | 0x20;
+    SeqReset(pVesa, TRUE);
+    WriteSeq(0x01, scrn);
+    SeqReset(pVesa, FALSE);
+
+    WriteAttr(pVesa, 0x10, 0x01);	/* graphics mode */
+    if (pScrn->depth == 4) {
+	/* GJA */
+	WriteGr(0x03, 0x00);	/* don't rotate, write unmodified */
+	WriteGr(0x08, 0xFF);	/* write all bits in a byte */
+	WriteGr(0x01, 0x00);	/* all planes come from CPU */
+    }
+
+    WriteSeq(0x02, 0x04);   /* write to plane 2 */
+    WriteSeq(0x04, 0x06);   /* enable plane graphics */
+    WriteGr(0x04, 0x02);    /* read plane 2 */
+    WriteGr(0x05, 0x00);    /* write mode 0, read mode 0 */
+    WriteGr(0x06, 0x05);    /* set graphics */
+    slowbcopy_tobus(pVesa->fonts, pVesa->VGAbase, 8192);
+
+    WriteSeq(0x02, 0x08);   /* write to plane 3 */
+    WriteSeq(0x04, 0x06);   /* enable plane graphics */
+    WriteGr(0x04, 0x03);    /* read plane 3 */
+    WriteGr(0x05, 0x00);    /* write mode 0, read mode 0 */
+    WriteGr(0x06, 0x05);    /* set graphics */
+    slowbcopy_tobus(pVesa->fonts + 8192, pVesa->VGAbase, 8192);
+
+    scrn = ReadSeq(pVesa, 0x01) & ~0x20;
+    SeqReset(pVesa, TRUE);
+    WriteSeq(0x01, scrn);
+    SeqReset(pVesa, FALSE);
+
+    /* restore the registers that were changed */
+    WriteMiscOut(miscOut);
+    WriteAttr(pVesa, 0x10, attr10);
+    WriteGr(0x01, gr1);
+    WriteGr(0x03, gr3);
+    WriteGr(0x04, gr4);
+    WriteGr(0x05, gr5);
+    WriteGr(0x06, gr6);
+    WriteGr(0x08, gr8);
+    WriteSeq(0x02, seq2);
+    WriteSeq(0x04, seq4);
+}
+
+static Bool
+VESASaveScreen(ScreenPtr pScreen, int mode)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    Bool on = xf86IsUnblank(mode);
+
+    if (on)
+	SetTimeSinceLastInputEvent();
+
+    if (pScrn->vtSema) {
+	unsigned char scrn = ReadSeq(pVesa, 0x01);
+
+	if (on)
+	    scrn &= ~0x20;
+	else
+	    scrn |= 0x20;
+	SeqReset(pVesa, TRUE);
+	WriteSeq(0x01, scrn);
+	SeqReset(pVesa, FALSE);
+    }
+
+    return (TRUE);
+}
+
+static int 
+VESABankSwitch(ScreenPtr pScreen, unsigned int iBank)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    if (pVesa->curBank == iBank)
+	return (0);
+    if (!VBEBankSwitch(pVesa->pVbe, iBank, 0))
+        return (1);
+    if (pVesa->bankSwitchWindowB) {
+        if (!VBEBankSwitch(pVesa->pVbe, iBank, 1))
+	   return (1);
+    }
+    pVesa->curBank = iBank;
+
+    return (0);
+}
+
+Bool
+VESASaveRestore(ScrnInfoPtr pScrn, vbeSaveRestoreFunction function)
+{
+    VESAPtr pVesa;
+
+    if (MODE_QUERY < 0 || function > MODE_RESTORE)
+	return (FALSE);
+
+    pVesa = VESAGetRec(pScrn);
+
+
+    /* Query amount of memory to save state */
+    if (function == MODE_QUERY ||
+	(function == MODE_SAVE && pVesa->state == NULL)) {
+
+	/* Make sure we save at least this information in case of failure */
+	(void)VBEGetVBEMode(pVesa->pVbe, &pVesa->stateMode);
+	SaveFonts(pScrn);
+
+	if (pVesa->major > 1) {
+	    if (!VBESaveRestore(pVesa->pVbe,function,(pointer)&pVesa->state,
+				&pVesa->stateSize,&pVesa->statePage))
+	        return FALSE;
+
+	}
+    }
+
+    /* Save/Restore Super VGA state */
+    if (function != MODE_QUERY) {
+        Bool retval = TRUE;
+
+	if (pVesa->major > 1) {
+	    if (function == MODE_RESTORE)
+		memcpy(pVesa->state, pVesa->pstate, pVesa->stateSize);
+
+	    if ((retval = VBESaveRestore(pVesa->pVbe,function,
+					 (pointer)&pVesa->state,
+					 &pVesa->stateSize,&pVesa->statePage))
+		&& function == MODE_SAVE) {
+	        /* don't rely on the memory not being touched */
+	        if (pVesa->pstate == NULL)
+		    pVesa->pstate = xalloc(pVesa->stateSize);
+		memcpy(pVesa->pstate, pVesa->state, pVesa->stateSize);
+	    }
+	}
+
+	if (function == MODE_RESTORE) {
+	    VBESetVBEMode(pVesa->pVbe, pVesa->stateMode, NULL);
+	    RestoreFonts(pScrn);
+	}
+
+	if (!retval)
+	    return (FALSE);
+
+    }
+
+    return (TRUE);
+}
+
+static void
+VESADisplayPowerManagementSet(ScrnInfoPtr pScrn, int mode,
+                int flags)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    unsigned char seq1 = 0, crtc17 = 0;
+
+    if (!pScrn->vtSema)
+	return;
+
+    switch (mode) {
+	case DPMSModeOn:
+	    /* Screen: On; HSync: On, VSync: On */
+	    seq1 = 0x00;
+	    crtc17 = 0x80;
+	    break;
+	case DPMSModeStandby:
+	    /* Screen: Off; HSync: Off, VSync: On -- Not Supported */
+	    seq1 = 0x20;
+	    crtc17 = 0x80;
+	    break;
+	case DPMSModeSuspend:
+	    /* Screen: Off; HSync: On, VSync: Off -- Not Supported */
+	    seq1 = 0x20;
+	    crtc17 = 0x80;
+	    break;
+	case DPMSModeOff:
+	    /* Screen: Off; HSync: Off, VSync: Off */
+	    seq1 = 0x20;
+	    crtc17 = 0x00;
+	    break;
+    }
+    WriteSeq(0x00, 0x01);		  /* Synchronous Reset */
+    seq1 |= ReadSeq(pVesa, 0x01) & ~0x20;
+    WriteSeq(0x01, seq1);
+    crtc17 |= ReadCrtc(pVesa, 0x17) & ~0x80;
+    usleep(10000);
+    WriteCrtc(0x17, crtc17);
+    WriteSeq(0x00, 0x03);		  /* End Reset */
+}
+
+
+
+
+/***********************************************************************
+ * DGA stuff
+ ***********************************************************************/
+static Bool VESADGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName,
+				   unsigned char **ApertureBase,
+				   int *ApertureSize, int *ApertureOffset,
+				   int *flags);
+static Bool VESADGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode);
+static void VESADGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags);
+
+static Bool
+VESADGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName,
+		       unsigned char **ApertureBase, int *ApertureSize,
+		       int *ApertureOffset, int *flags)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    *DeviceName = NULL;		/* No special device */
+    *ApertureBase = (unsigned char *)(long)(pVesa->mapPhys);
+    *ApertureSize = pVesa->mapSize;
+    *ApertureOffset = pVesa->mapOff;
+    *flags = DGA_NEED_ROOT;
+
+    return (TRUE);
+}
+
+static Bool
+VESADGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode)
+{
+    DisplayModePtr pMode;
+    int scrnIdx = pScrn->pScreen->myNum;
+    int frameX0, frameY0;
+
+    if (pDGAMode) {
+	pMode = pDGAMode->mode;
+	frameX0 = frameY0 = 0;
+    }
+    else {
+	if (!(pMode = pScrn->currentMode))
+	    return (TRUE);
+
+	frameX0 = pScrn->frameX0;
+	frameY0 = pScrn->frameY0;
+    }
+
+    if (!(*pScrn->SwitchMode)(scrnIdx, pMode, 0))
+	return (FALSE);
+    (*pScrn->AdjustFrame)(scrnIdx, frameX0, frameY0, 0);
+
+    return (TRUE);
+}
+
+static void
+VESADGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags)
+{
+    (*pScrn->AdjustFrame)(pScrn->pScreen->myNum, x, y, flags);
+}
+
+static int
+VESADGAGetViewport(ScrnInfoPtr pScrn)
+{
+    return (0);
+}
+
+static DGAFunctionRec VESADGAFunctions =
+{
+    VESADGAOpenFramebuffer,
+    NULL,       /* CloseFramebuffer */
+    VESADGASetMode,
+    VESADGASetViewport,
+    VESADGAGetViewport,
+    NULL,       /* Sync */
+    NULL,       /* FillRect */
+    NULL,       /* BlitRect */
+    NULL,       /* BlitTransRect */
+};
+
+static void
+VESADGAAddModes(ScrnInfoPtr pScrn)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+    DisplayModePtr pMode = pScrn->modes;
+    DGAModePtr pDGAMode;
+
+    do {
+	pDGAMode = xrealloc(pVesa->pDGAMode,
+			    (pVesa->nDGAMode + 1) * sizeof(DGAModeRec));
+	if (!pDGAMode)
+	    break;
+
+	pVesa->pDGAMode = pDGAMode;
+	pDGAMode += pVesa->nDGAMode;
+	(void)memset(pDGAMode, 0, sizeof(DGAModeRec));
+
+	++pVesa->nDGAMode;
+	pDGAMode->mode = pMode;
+	pDGAMode->flags = DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE;
+	pDGAMode->byteOrder = pScrn->imageByteOrder;
+	pDGAMode->depth = pScrn->depth;
+	pDGAMode->bitsPerPixel = pScrn->bitsPerPixel;
+	pDGAMode->red_mask = pScrn->mask.red;
+	pDGAMode->green_mask = pScrn->mask.green;
+	pDGAMode->blue_mask = pScrn->mask.blue;
+	pDGAMode->visualClass = pScrn->bitsPerPixel > 8 ?
+	    TrueColor : PseudoColor;
+	pDGAMode->xViewportStep = 1;
+	pDGAMode->yViewportStep = 1;
+	pDGAMode->viewportWidth = pMode->HDisplay;
+	pDGAMode->viewportHeight = pMode->VDisplay;
+
+	pDGAMode->bytesPerScanline = pVesa->maxBytesPerScanline;
+	pDGAMode->imageWidth = pMode->HDisplay;
+	pDGAMode->imageHeight =  pMode->VDisplay;
+	pDGAMode->pixmapWidth = pDGAMode->imageWidth;
+	pDGAMode->pixmapHeight = pDGAMode->imageHeight;
+	pDGAMode->maxViewportX = pScrn->virtualX -
+				    pDGAMode->viewportWidth;
+	pDGAMode->maxViewportY = pScrn->virtualY -
+				    pDGAMode->viewportHeight;
+
+	pDGAMode->address = pVesa->base;
+
+	pMode = pMode->next;
+    } while (pMode != pScrn->modes);
+}
+
+static Bool
+VESADGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen)
+{
+    VESAPtr pVesa = VESAGetRec(pScrn);
+
+    if (pScrn->depth < 8 || pVesa->mapPhys == 0xa0000L)
+	return (FALSE);
+
+    if (!pVesa->nDGAMode)
+	VESADGAAddModes(pScrn);
+
+    return (DGAInit(pScreen, &VESADGAFunctions,
+	    pVesa->pDGAMode, pVesa->nDGAMode));
+}
diff --git a/src/vesa.h b/src/vesa.h
new file mode 100644
index 0000000..cc448eb
--- /dev/null
+++ b/src/vesa.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *  
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ * Except as contained in this notice, the name of Conectiva Linux shall
+ * not be used in advertising or otherwise to promote the sale, use or other
+ * dealings in this Software without prior written authorization from
+ * Conectiva Linux.
+ *
+ * Authors: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/drivers/vesa/vesa.h,v 1.14 2003/01/16 16:09:10 eich Exp $
+ */
+
+#ifndef _VESA_H_
+#define _VESA_H_
+
+/* All drivers should typically include these */
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+
+/* All drivers need this */
+#include "xf86_ansic.h"
+
+#include "compiler.h"
+
+/* Drivers for PCI hardware need this */
+#include "xf86PciInfo.h"
+
+#include "vgaHW.h"
+
+/* Drivers that need to access the PCI config space directly need this */
+#include "xf86Pci.h"
+
+/* VBE/DDC support */
+#include "vbe.h"
+#include "vbeModes.h"
+#include "xf86DDC.h"
+
+/* ShadowFB support */
+#include "shadow.h"
+
+/* Int 10 support */
+#include "xf86int10.h"
+
+/* bank switching */
+#include "mibank.h"
+
+/* Dga definitions */
+#include "dgaproc.h"
+
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+
+#include "xf1bpp.h"
+#include "xf4bpp.h"
+#include "fb.h"
+#include "afb.h"
+#include "mfb.h"
+#include "cfb24_32.h"
+
+#define VESA_VERSION		4000
+#define VESA_NAME		"VESA"
+#define VESA_DRIVER_NAME	"vesa"
+#define VESA_MAJOR_VERSION	1
+#define VESA_MINOR_VERSION	0
+#define VESA_PATCHLEVEL		0
+
+/*XXX*/
+
+typedef struct _VESARec
+{
+    vbeInfoPtr pVbe;
+    EntityInfoPtr pEnt;
+    CARD16 major, minor;
+    VbeInfoBlock *vbeInfo;
+    GDevPtr device;
+    pciVideoPtr pciInfo;
+    PCITAG pciTag;
+    miBankInfoRec bank;
+    int curBank, bankSwitchWindowB;
+    CARD16 maxBytesPerScanline;
+    unsigned long mapPhys, mapOff, mapSize;	/* video memory */
+    void *base, *VGAbase;
+    CARD8 *state, *pstate;	/* SVGA state */
+    int statePage, stateSize, stateMode;
+    int page;
+    CARD32 *pal, *savedPal;
+    CARD8 *fonts;
+    xf86MonPtr monitor;
+    Bool shadowFB, primary;
+    CARD8 *shadowPtr;
+    CARD32 windowAoffset;
+    /* Don't override the default refresh rate. */
+    Bool defaultRefresh;
+    /* DGA info */
+    DGAModePtr pDGAMode;
+    int nDGAMode;
+    CloseScreenProcPtr CloseScreen;
+    OptionInfoPtr Options;
+    IOADDRESS ioBase;
+} VESARec, *VESAPtr;
+
+
+#endif /* _VESA_H_ */