Initial revisionXORG-STABLE

1 files changed, 3586 insertions, 0 deletions

diff --git a/src/i830_driver.c b/src/i830_driver.c
new file mode 100644
index 00000000..073f8eb6
--- /dev/null
+++ b/src/i830_driver.c
@@ -0,0 +1,3586 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/i810/i830_driver.c,v 1.27 2003/02/14 17:12:42 dawes Exp $ */
+/**************************************************************************
+
+Copyright 2001 VA Linux Systems Inc., Fremont, California.
+Copyright © 2002 by David Dawes
+
+All Rights Reserved.
+
+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
+on the rights to use, copy, modify, merge, publish, distribute, sub
+license, 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 (including the next
+paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS 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.
+
+**************************************************************************/
+
+/*
+ * Reformatted with GNU indent (2.2.8), using the following options:
+ *
+ *    -bad -bap -c41 -cd0 -ncdb -ci6 -cli0 -cp0 -ncs -d0 -di3 -i3 -ip3 -l78
+ *    -lp -npcs -psl -sob -ss -br -ce -sc -hnl
+ *
+ * This provides a good match with the original i810 code and preferred
+ * XFree86 formatting conventions.
+ *
+ * When editing this driver, please follow the existing formatting, and edit
+ * with <TAB> characters expanded at 8-column intervals.
+ */
+
+/*
+ * Authors: Jeff Hartmann <jhartmann@valinux.com>
+ *          Abraham van der Merwe <abraham@2d3d.co.za>
+ *          David Dawes <dawes@tungstengraphics.com>
+ */
+
+/*
+ * Mode handling is based on the VESA driver written by:
+ * Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
+ */
+
+/*
+ * Changes:
+ *
+ *    23/08/2001 Abraham van der Merwe <abraham@2d3d.co.za>
+ *        - Fixed display timing bug (mode information for some
+ *          modes were not initialized correctly)
+ *        - Added workarounds for GTT corruptions (I don't adjust
+ *          the pitches for 1280x and 1600x modes so we don't
+ *          need extra memory)
+ *        - The code will now default to 60Hz if LFP is connected
+ *        - Added different refresh rate setting code to work
+ *          around 0x4f02 BIOS bug
+ *        - BIOS workaround for some mode sets (I use legacy BIOS
+ *          calls for setting those)
+ *        - Removed 0x4f04, 0x01 (save state) BIOS call which causes
+ *          LFP to malfunction (do some house keeping and restore
+ *          modes ourselves instead - not perfect, but at least the
+ *          LFP is working now)
+ *        - Several other smaller bug fixes
+ *
+ *    06/09/2001 Abraham van der Merwe <abraham@2d3d.co.za>
+ *        - Preliminary local memory support (works without agpgart)
+ *        - DGA fixes (the code were still using i810 mode sets, etc.)
+ *        - agpgart fixes
+ *
+ *    18/09/2001
+ *        - Proper local memory support (should work correctly now
+ *          with/without agpgart module)
+ *        - more agpgart fixes
+ *        - got rid of incorrect GTT adjustments
+ *
+ *    09/10/2001
+ *        - Changed the DPRINTF() variadic macro to an ANSI C compatible
+ *          version
+ *
+ *    10/10/2001
+ *        - Fixed DPRINTF_stub(). I forgot the __...__ macros in there
+ *          instead of the function arguments :P
+ *        - Added a workaround for the 1600x1200 bug (Text mode corrupts
+ *          when you exit from any 1600x1200 mode and 1280x1024@85Hz. I
+ *          suspect this is a BIOS bug (hence the 1280x1024@85Hz case)).
+ *          For now I'm switching to 800x600@60Hz then to 80x25 text mode
+ *          and then restoring the registers - very ugly indeed.
+ *
+ *    15/10/2001
+ *        - Improved 1600x1200 mode set workaround. The previous workaround
+ *          was causing mode set problems later on.
+ *
+ *    18/10/2001
+ *        - Fixed a bug in I830BIOSLeaveVT() which caused a bug when you
+ *          switched VT's
+ */
+/*
+ *    07/2002 David Dawes
+ *        - Add Intel(R) 855GM/852GM support.
+ */
+/*
+ *    07/2002 David Dawes
+ *        - Cleanup code formatting.
+ *        - Improve VESA mode selection, and fix refresh rate selection.
+ *        - Don't duplicate functions provided in 4.2 vbe modules.
+ *        - Don't duplicate functions provided in the vgahw module.
+ *        - Rewrite memory allocation.
+ *        - Rewrite initialisation and save/restore state handling.
+ *        - Decouple the i810 support from i830 and later.
+ *        - Remove various unnecessary hacks and workarounds.
+ *        - Fix an 845G problem with the ring buffer not in pre-allocated
+ *          memory.
+ *        - Fix screen blanking.
+ *        - Clear the screen at startup so you don't see the previous session.
+ *        - Fix some HW cursor glitches, and turn HW cursor off at VT switch
+ *          and exit.
+ *
+ *    08/2002 Keith Whitwell
+ *        - Fix DRI initialisation.
+ */
+/*
+ *    08/2002 Alan Hourihane and David Dawes
+ *        - Add XVideo support.
+ */
+/*
+ *    10/2002 David Dawes
+ *        - Add Intel(R) 865G support.
+ */
+
+
+#ifndef PRINT_MODE_INFO
+#define PRINT_MODE_INFO 0
+#endif
+
+#include "xf86.h"
+#include "xf86_ansic.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86RAC.h"
+#include "xf86cmap.h"
+#include "compiler.h"
+#include "mibstore.h"
+#include "vgaHW.h"
+#include "mipointer.h"
+#include "micmap.h"
+
+#include "fb.h"
+#include "miscstruct.h"
+#include "xf86xv.h"
+#include "Xv.h"
+#include "vbe.h"
+#include "vbeModes.h"
+
+#include "i830.h"
+
+#ifdef XF86DRI
+#include "dri.h"
+#endif
+
+#define BIT(x) (1 << (x))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#define NB_OF(x) (sizeof (x) / sizeof (*x))
+
+/* *INDENT-OFF* */
+static SymTabRec I830BIOSChipsets[] = {
+   {PCI_CHIP_I830_M,		"i830"},
+   {PCI_CHIP_845_G,		"845G"},
+   {PCI_CHIP_I855_GM,		"852GM/855GM"},
+   {PCI_CHIP_I865_G,		"865G"},
+   {-1,				NULL}
+};
+
+static PciChipsets I830BIOSPciChipsets[] = {
+   {PCI_CHIP_I830_M,		PCI_CHIP_I830_M,	RES_SHARED_VGA},
+   {PCI_CHIP_845_G,		PCI_CHIP_845_G,		RES_SHARED_VGA},
+   {PCI_CHIP_I855_GM,		PCI_CHIP_I855_GM,	RES_SHARED_VGA},
+   {PCI_CHIP_I865_G,		PCI_CHIP_I865_G,	RES_SHARED_VGA},
+   {-1,				-1,			RES_UNDEFINED}
+};
+
+/*
+ * Note: "ColorKey" is provided for compatibility with the i810 driver.
+ * However, the correct option name is "VideoKey".  "ColorKey" usually
+ * refers to the tranparency key for 8+24 overlays, not for video overlays.
+ */
+
+typedef enum {
+   OPTION_NOACCEL,
+   OPTION_SW_CURSOR,
+   OPTION_CACHE_LINES,
+   OPTION_DRI,
+   OPTION_PAGEFLIP,
+   OPTION_XVIDEO,
+   OPTION_VIDEO_KEY,
+   OPTION_COLOR_KEY,
+   OPTION_STRETCH,
+   OPTION_CENTER
+} I830Opts;
+
+static OptionInfoRec I830BIOSOptions[] = {
+   {OPTION_NOACCEL,	"NoAccel",	OPTV_BOOLEAN,	{0},	FALSE},
+   {OPTION_SW_CURSOR,	"SWcursor",	OPTV_BOOLEAN,	{0},	FALSE},
+   {OPTION_CACHE_LINES,	"CacheLines",	OPTV_INTEGER,	{0},	FALSE},
+   {OPTION_DRI,		"DRI",		OPTV_BOOLEAN,	{0},	TRUE},
+   {OPTION_PAGEFLIP,	"PageFlip",	OPTV_BOOLEAN,	{0},	FALSE},
+   {OPTION_XVIDEO,	"XVideo",	OPTV_BOOLEAN,	{0},	TRUE},
+   {OPTION_COLOR_KEY,	"ColorKey",	OPTV_INTEGER,	{0},	FALSE},
+   {OPTION_VIDEO_KEY,	"VideoKey",	OPTV_INTEGER,	{0},	FALSE},
+   {OPTION_STRETCH,	"Stretch",	OPTV_BOOLEAN,	{0},	FALSE},
+   {OPTION_CENTER,	"Center",	OPTV_BOOLEAN,	{0},	FALSE},
+   {-1,			NULL,		OPTV_NONE,	{0},	FALSE}
+};
+/* *INDENT-ON* */
+
+static void I830DisplayPowerManagementSet(ScrnInfoPtr pScrn,
+					  int PowerManagementMode, int flags);
+static void I830BIOSAdjustFrame(int scrnIndex, int x, int y, int flags);
+static Bool I830BIOSCloseScreen(int scrnIndex, ScreenPtr pScreen);
+static Bool I830BIOSSaveScreen(ScreenPtr pScreen, int unblack);
+static Bool I830BIOSEnterVT(int scrnIndex, int flags);
+static Bool I830VESASetVBEMode(ScrnInfoPtr pScrn, int mode,
+			       VbeCRTCInfoBlock *block);
+
+static Bool OffsetFrame = FALSE;
+
+
+
+#ifdef I830DEBUG
+void
+I830DPRINTF_stub(const char *filename, int line, const char *function,
+		 const char *fmt, ...)
+{
+   va_list ap;
+
+   ErrorF("\n##############################################\n"
+	  "*** In function %s, on line %d, in file %s ***\n",
+	  function, line, filename);
+   va_start(ap, fmt);
+   VErrorF(fmt, ap);
+   va_end(ap);
+   ErrorF("##############################################\n\n");
+}
+#else /* #ifdef I830DEBUG */
+void
+I830DPRINTF_stub(const char *filename, int line, const char *function,
+		 const char *fmt, ...)
+{
+   /* do nothing */
+}
+#endif /* #ifdef I830DEBUG */
+
+/* XXX Check if this is still needed. */
+const OptionInfoRec *
+I830BIOSAvailableOptions(int chipid, int busid)
+{
+   int i;
+
+   for (i = 0; I830BIOSPciChipsets[i].PCIid > 0; i++) {
+      if (chipid == I830BIOSPciChipsets[i].PCIid)
+	 return I830BIOSOptions;
+   }
+   return NULL;
+}
+
+static Bool
+I830BIOSGetRec(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830;
+
+   if (pScrn->driverPrivate)
+      return TRUE;
+   pI830 = pScrn->driverPrivate = xnfcalloc(sizeof(I830Rec), 1);
+   pI830->vesa = xnfcalloc(sizeof(VESARec), 1);
+   return TRUE;
+}
+
+static void
+I830BIOSFreeRec(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830;
+   VESAPtr pVesa;
+   DisplayModePtr mode;
+
+   if (!pScrn)
+      return;
+   if (!pScrn->driverPrivate)
+      return;
+
+   pI830 = I830PTR(pScrn);
+   mode = pScrn->modes;
+
+   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);
+   }
+
+   if (pI830->vbeInfo)
+      VBEFreeVBEInfo(pI830->vbeInfo);
+   if (pI830->pVbe)
+      vbeFree(pI830->pVbe);
+
+   pVesa = pI830->vesa;
+   if (pVesa->monitor)
+      xfree(pVesa->monitor);
+   if (pVesa->savedPal)
+      xfree(pVesa->savedPal);
+   xfree(pVesa);
+
+   xfree(pScrn->driverPrivate);
+   pScrn->driverPrivate = NULL;
+}
+
+static void
+I830BIOSProbeDDC(ScrnInfoPtr pScrn, int index)
+{
+   vbeInfoPtr pVbe;
+
+   /* The vbe module gets loaded in PreInit(), so no need to load it here. */
+
+   pVbe = VBEInit(NULL, index);
+   ConfiguredMonitor = vbeDoEDID(pVbe, NULL);
+}
+
+/* Various extended video BIOS functions. */
+static const int refreshes[] = {
+   43, 56, 60, 70, 72, 75, 85, 100, 120
+};
+static const int nrefreshes = sizeof(refreshes) / sizeof(refreshes[0]);
+
+static Bool
+Check5fStatus(ScrnInfoPtr pScrn, int func, int ax)
+{
+   if (ax == 0x005f)
+      return TRUE;
+   else if (ax == 0x015f) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Extended BIOS function 0x%04x failed.\n", func);
+      return FALSE;
+   } else if ((ax & 0xff) != 0x5f) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Extended BIOS function 0x%04x not supported.\n", func);
+      return FALSE;
+   } else {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Extended BIOS function 0x%04x returns 0x%04x.\n",
+		 func, ax & 0xffff);
+      return FALSE;
+   }
+}
+
+#if 0
+static int
+BitToRefresh(int bits)
+{
+   int i;
+
+   for (i = 0; i < nrefreshes; i++)
+      if (bits & (1 << i))
+	 return refreshes[i];
+   return 0;
+}
+
+static int
+GetRefreshRate(ScrnInfoPtr pScrn, int mode, int refresh, int *availRefresh)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "GetRefreshRate\n");
+
+   /* Only 8-bit mode numbers are supported. */
+   if (mode & 0x100)
+      return 0;
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f05;
+   pVbe->pInt10->bx = (mode & 0xff) | 0x100;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f05, pVbe->pInt10->ax)) {
+      if (availRefresh)
+         *availRefresh = pVbe->pInt10->bx;
+      return BitToRefresh(pVbe->pInt10->cx);
+   } else
+      return 0;
+}
+#endif
+
+static int
+SetRefreshRate(ScrnInfoPtr pScrn, int mode, int refresh)
+{
+   int i;
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "SetRefreshRate: mode 0x%x, refresh: %d\n", mode, refresh);
+
+   /* Only 8-bit mode numbers are supported. */
+   if (mode & 0x100)
+      return 0;
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f05;
+   pVbe->pInt10->bx = mode & 0xff;
+
+   for (i = nrefreshes - 1; i >= 0; i--) {
+      /*
+       * Look for the highest value that the requested (refresh + 2) is
+       * greater than or equal to.
+       */
+      if (refreshes[i] <= (refresh + 2))
+	 break;
+   }
+   /* i can be 0 if the requested refresh was higher than the max. */
+   if (i == 0) {
+      if (refresh >= refreshes[nrefreshes - 1])
+         i = nrefreshes - 1;
+   }
+   DPRINTF(PFX, "Setting refresh rate to %dHz for mode 0x%02x\n",
+	   refreshes[i], mode & 0xff);
+   pVbe->pInt10->cx = 1 << i;
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f05, pVbe->pInt10->ax))
+      return refreshes[i];
+   else
+      return 0;
+}
+
+static Bool
+GetModeSupport(ScrnInfoPtr pScrn, int modePipeA, int modePipeB,
+	       int devicesPipeA, int devicesPipeB, int *maxBandwidth,
+	       int *bandwidthPipeA, int *bandwidthPipeB)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "GetModeSupport: modes 0x%x, 0x%x, devices: 0x%x, 0x%x\n",
+	   modePipeA, modePipeB, devicesPipeA, devicesPipeB);
+
+   /* Only 8-bit mode numbers are supported. */
+   if ((modePipeA & 0x100) || (modePipeB & 0x100))
+      return 0;
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f28;
+   pVbe->pInt10->bx = (modePipeA & 0xff) | ((modePipeB & 0xff) << 8);
+   if ((devicesPipeA & 0x80) || (devicesPipeB & 0x80))
+      pVbe->pInt10->cx = 0x8000;
+   else
+      pVbe->pInt10->cx = (devicesPipeA & 0xff) | ((devicesPipeB & 0xff) << 8);
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f28, pVbe->pInt10->ax)) {
+      if (maxBandwidth)
+	 *maxBandwidth = pVbe->pInt10->cx;
+      if (bandwidthPipeA)
+	 *bandwidthPipeA = pVbe->pInt10->dx & 0xffff;
+      /* XXX For XFree86 4.2.0 and earlier, ->dx is truncated to 16 bits. */
+      if (bandwidthPipeB)
+	 *bandwidthPipeB = (pVbe->pInt10->dx >> 16) & 0xffff;
+      return TRUE;
+   } else
+      return FALSE;
+}
+
+static int
+GetLFPCompMode(ScrnInfoPtr pScrn)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "GetLFPCompMode\n");
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f61;
+   pVbe->pInt10->bx = 0x100;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f61, pVbe->pInt10->ax))
+      return pVbe->pInt10->cx & 0xffff;
+   else
+      return -1;
+}
+
+#if 0
+static Bool
+SetLFPCompMode(ScrnInfoPtr pScrn, int compMode)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "SetLFPCompMode: compMode %d\n", compMode);
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f61;
+   pVbe->pInt10->bx = 0;
+   pVbe->pInt10->cx = compMode;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   return Check5fStatus(pScrn, 0x5f61, pVbe->pInt10->ax);
+}
+#endif
+
+static int
+GetDisplayDevices(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+
+   DPRINTF(PFX, "GetDisplayDevices\n");
+
+#if 0
+   {
+      CARD32 temp;
+      ErrorF("ADPA is 0x%08x\n", INREG(ADPA));
+      ErrorF("DVOA is 0x%08x\n", INREG(DVOA));
+      ErrorF("DVOB is 0x%08x\n", INREG(DVOB));
+      ErrorF("DVOC is 0x%08x\n", INREG(DVOC));
+      ErrorF("LVDS is 0x%08x\n", INREG(LVDS));
+      temp = INREG(DVOA_SRCDIM);
+      ErrorF("DVOA_SRCDIM is 0x%08x (%d x %d)\n", temp,
+	     (temp >> 12) & 0xfff, temp & 0xfff);
+      temp = INREG(DVOB_SRCDIM);
+      ErrorF("DVOB_SRCDIM is 0x%08x (%d x %d)\n", temp,
+	     (temp >> 12) & 0xfff, temp & 0xfff);
+      temp = INREG(DVOC_SRCDIM);
+      ErrorF("DVOC_SRCDIM is 0x%08x (%d x %d)\n", temp,
+	     (temp >> 12) & 0xfff, temp & 0xfff);
+      ErrorF("SWF0 is 0x%08x\n", INREG(SWF0));
+      ErrorF("SWF4 is 0x%08x\n", INREG(SWF4));
+   }
+#endif
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f64;
+   pVbe->pInt10->bx = 0x100;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f64, pVbe->pInt10->ax))
+      return pVbe->pInt10->cx & 0xffff;
+   else
+      return -1;
+}
+
+static Bool
+SetDisplayDevices(ScrnInfoPtr pScrn, int devices)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+   CARD32 temp;
+
+   DPRINTF(PFX, "SetDisplayDevices: devices 0x%x\n", devices);
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f64;
+   pVbe->pInt10->bx = 0x1;
+   pVbe->pInt10->cx = devices;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f64, pVbe->pInt10->ax))
+      return TRUE;
+   else {
+      ErrorF("Writing config directly to SWF0\n");
+      temp = INREG(SWF0);
+      OUTREG(SWF0, (temp & ~(0xffff)) | (devices & 0xffff));
+      ErrorF("SetDisplayDevices failed.  devices is 0x%x instead of 0x%x\n",
+	     GetDisplayDevices(pScrn), devices);
+      return FALSE;
+   }
+}
+
+#if 0
+static Bool
+GetDevicePresence(ScrnInfoPtr pScrn, Bool *required, int *attached,
+		  int *encoderPresent)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "GetDevicePresence\n");
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f64;
+   pVbe->pInt10->bx = 0x200;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f64, pVbe->pInt10->ax)) {
+      if (required)
+	 *required = ((pVbe->pInt10->bx & 0x1) == 0);
+      if (attached)
+	 *attached = (pVbe->pInt10->cx >> 8) & 0xff;
+      if (encoderPresent)
+	 *encoderPresent = pVbe->pInt10->cx & 0xff;
+      return TRUE;
+   } else
+      return FALSE;
+}
+#endif
+
+static Bool
+GetDisplayInfo(ScrnInfoPtr pScrn, int device, Bool *attached, Bool *present,
+	       short *x, short *y)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "GetDisplayInfo: device: 0x%x\n", device);
+
+   switch (device & 0xff) {
+   case 0x01:
+   case 0x02:
+   case 0x04:
+   case 0x08:
+   case 0x10:
+   case 0x20:
+      break;
+   default:
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "GetDisplayInfo: invalid device: 0x%x\n", device & 0xff);
+      return FALSE;
+   }
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f64;
+   pVbe->pInt10->bx = 0x300;
+   pVbe->pInt10->cx = device & 0xff;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   if (Check5fStatus(pScrn, 0x5f64, pVbe->pInt10->ax)) {
+      if (attached)
+	 *attached = ((pVbe->pInt10->bx & 0x2) != 0);
+      if (present)
+	 *present = ((pVbe->pInt10->bx & 0x1) != 0);
+      if (pVbe->pInt10->cx != (device & 0xff)) {
+	 if (y) {
+	    *y = pVbe->pInt10->cx & 0xffff;
+	 }
+	 if (x) {
+	    *x = (pVbe->pInt10->cx >> 16) & 0xffff;
+	 }
+      }
+      return TRUE;
+   } else
+      return FALSE;
+}
+
+/*
+ * Returns a string matching the device corresponding to the first bit set
+ * in "device".  savedDevice is then set to device with that bit cleared.
+ * Subsequent calls with device == -1 will use savedDevice.
+ */
+
+static const char *displayDevices[] = {
+   "CRT",
+   "TV",
+   "DFP (digital flat panel)",
+   "LFP (local flat panel)",
+   "TV2 (second TV)",
+   "DFP2 (second digital flat panel)",
+   NULL
+};
+
+static const char *
+DeviceToString(int device)
+{
+   static int savedDevice = -1;
+   static int bit = 0;
+   const char *name;
+
+   if (device == -1) {
+      device = savedDevice;
+      bit = 0;
+   }
+
+   if (device == -1)
+      return NULL;
+
+   while (displayDevices[bit]) {
+      if (device & (1 << bit)) {
+	 name = displayDevices[bit];
+	 savedDevice = device & ~(1 << bit);
+	 bit++;
+	 return name;
+      }
+      bit++;
+   }
+   return NULL;
+}
+
+static void
+PrintDisplayDeviceInfo(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int pipe, n;
+   int displays;
+
+   DPRINTF(PFX, "PrintDisplayDeviceInfo\n");
+
+   displays = pI830->configuredDevices;
+   if (displays == -1) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "No active display devices.\n");
+      return;
+   }
+
+   /* Check for active devices connected to each display pipe. */
+   for (n = 0; n < pI830->availablePipes; n++) {
+      pipe = ((displays >> PIPE_SHIFT(n)) & PIPE_ACTIVE_MASK);
+      if (pipe) {
+	 const char *name;
+
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Currently active displays on Pipe %c:\n", PIPE_NAME(n));
+	 name = DeviceToString(pipe);
+	 do {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "\t%s\n", name);
+	    name = DeviceToString(-1);
+	 } while (name);
+
+	 if (pipe & PIPE_UNKNOWN_ACTIVE)
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "\tSome unknown display devices may also be present\n");
+
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "No active displays on Pipe %c.\n", PIPE_NAME(n));
+      }
+
+      if (pI830->pipeDisplaySize[n].x2 != 0) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Lowest common panel size for pipe %c is %d x %d\n",
+		    PIPE_NAME(n), pI830->pipeDisplaySize[n].x2,
+		    pI830->pipeDisplaySize[n].y2);
+      } else if (pI830->pipeEnabled[n] && pipe & ~PIPE_CRT_ACTIVE) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "No display size information available for pipe %c.\n",
+		    PIPE_NAME(n));
+      }
+   }
+}
+
+static void
+GetPipeSizes(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int pipe, n;
+   DisplayType i;
+
+   DPRINTF(PFX, "GetPipeSizes\n");
+
+
+   for (n = 0; n < pI830->availablePipes; n++) {
+      pipe = (pI830->configuredDevices >> PIPE_SHIFT(n)) & PIPE_ACTIVE_MASK;
+      pI830->pipeDisplaySize[n].x1 = pI830->pipeDisplaySize[n].y1 = 0;
+      pI830->pipeDisplaySize[n].x2 = pI830->pipeDisplaySize[n].y2 = 4096;
+      for (i = 0; i < NumKnownDisplayTypes; i++) {
+         if (pipe & (1 << i) & PIPE_SIZED_DISP_MASK) {
+	    if (pI830->displaySize[i].x2 != 0) {
+	       xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		          "Size of device %s is %d x %d\n",
+		          displayDevices[i],
+		          pI830->displaySize[i].x2,
+		          pI830->displaySize[i].y2);
+	       if (pI830->displaySize[i].x2 < pI830->pipeDisplaySize[n].x2)
+	          pI830->pipeDisplaySize[n].x2 = pI830->displaySize[i].x2;
+	       if (pI830->displaySize[i].y2 < pI830->pipeDisplaySize[n].y2)
+	          pI830->pipeDisplaySize[n].y2 = pI830->displaySize[i].y2;
+	    }
+         }
+      }
+
+      if (pI830->pipeDisplaySize[n].x2 == 4096)
+         pI830->pipeDisplaySize[n].x2 = 0;
+      if (pI830->pipeDisplaySize[n].y2 == 4096)
+         pI830->pipeDisplaySize[n].y2 = 0;
+   }
+}
+
+static Bool
+I830DetectDisplayDevice(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int pipe, n;
+   DisplayType i;
+
+   for (i = 0; i < NumKnownDisplayTypes; i++) {
+      if (GetDisplayInfo(pScrn, 1 << i, &pI830->displayAttached[i],
+			 &pI830->displayPresent[i],
+			 &pI830->displaySize[i].x2,
+			 &pI830->displaySize[i].y2)) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Display Info: %s: attached: %s, present: %s, size: "
+		    "(%d,%d)\n", displayDevices[i],
+		    BOOLTOSTRING(pI830->displayAttached[i]),
+		    BOOLTOSTRING(pI830->displayPresent[i]),
+		    pI830->displaySize[i].x2, pI830->displaySize[i].y2);
+      }
+   }
+
+   pI830->configuredDevices = GetDisplayDevices(pScrn);
+   if (pI830->configuredDevices == -1) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "Failed to detect active display devices\n");
+      return FALSE;
+   }
+
+   /* Check for active devices connected to each display pipe. */
+   for (n = 0; n < pI830->availablePipes; n++) {
+      pipe = ((pI830->configuredDevices >> PIPE_SHIFT(n)) & PIPE_ACTIVE_MASK);
+      if (pipe) {
+	 pI830->pipeEnabled[n] = TRUE;
+      }
+   }
+
+   GetPipeSizes(pScrn);
+   PrintDisplayDeviceInfo(pScrn);
+
+#if 0
+   /* A quick hack to change the set of enabled devices. */
+   enabledDevices = PIPE_CRT_ACTIVE;
+   if (!SetDisplayDevices(pScrn, enabledDevices)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Failed to switch to configured display devices\n");
+   }
+#endif
+
+   return TRUE;
+}
+
+static int
+I830DetectMemory(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   PCITAG bridge;
+   CARD16 gmch_ctrl;
+   int memsize = 0;
+
+   bridge = pciTag(0, 0, 0);		/* This is always the host bridge */
+   gmch_ctrl = pciReadWord(bridge, I830_GMCH_CTRL);
+
+   if (IS_I85X(pI830) || IS_I865G(pI830))
+   {
+      switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
+      case I855_GMCH_GMS_STOLEN_1M:
+	 memsize = MB(1) - KB(132);
+	 break;
+      case I855_GMCH_GMS_STOLEN_4M:
+	 memsize = MB(4) - KB(132);
+	 break;
+      case I855_GMCH_GMS_STOLEN_8M:
+	 memsize = MB(8) - KB(132);
+	 break;
+      case I855_GMCH_GMS_STOLEN_16M:
+	 memsize = MB(16) - KB(132);
+	 break;
+      case I855_GMCH_GMS_STOLEN_32M:
+	 memsize = MB(32) - KB(132);
+	 break;
+      }
+   } else
+   {
+      switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
+      case I830_GMCH_GMS_STOLEN_512:
+	 memsize = KB(512) - KB(132);
+	 break;
+      case I830_GMCH_GMS_STOLEN_1024:
+	 memsize = MB(1) - KB(132);
+	 break;
+      case I830_GMCH_GMS_STOLEN_8192:
+	 memsize = MB(8) - KB(132);
+	 break;
+      case I830_GMCH_GMS_LOCAL:
+	 memsize = 0;
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "Local memory found, but won't be used.\n");
+	 break;
+      }
+   }
+   if (memsize > 0) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "detected %d kB stolen memory.\n", memsize / 1024);
+   } else {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "no video memory detected.\n");
+   }
+   return memsize;
+}
+
+static Bool
+I830MapMMIO(ScrnInfoPtr pScrn)
+{
+   int mmioFlags;
+   I830Ptr pI830 = I830PTR(pScrn);
+
+#if !defined(__alpha__)
+   mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT;
+#else
+   mmioFlags = VIDMEM_MMIO | VIDMEM_READSIDEEFFECT | VIDMEM_SPARSE;
+#endif
+
+   pI830->MMIOBase = xf86MapPciMem(pScrn->scrnIndex, mmioFlags,
+				   pI830->PciTag,
+				   pI830->MMIOAddr, I810_REG_SIZE);
+   if (!pI830->MMIOBase)
+      return FALSE;
+   return TRUE;
+}
+
+static Bool
+I830MapMem(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned i;
+
+   for (i = 2; i < pI830->FbMapSize; i <<= 1) ;
+   pI830->FbMapSize = i;
+
+   if (!I830MapMMIO(pScrn))
+      return FALSE;
+
+   pI830->FbBase = xf86MapPciMem(pScrn->scrnIndex, VIDMEM_FRAMEBUFFER,
+				 pI830->PciTag,
+				 pI830->LinearAddr, pI830->FbMapSize);
+   if (!pI830->FbBase)
+      return FALSE;
+
+   pI830->LpRing.virtual_start = pI830->FbBase + pI830->LpRing.mem.Start;
+
+   return TRUE;
+}
+
+static void
+I830UnmapMMIO(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pI830->MMIOBase,
+		   I810_REG_SIZE);
+   pI830->MMIOBase = 0;
+}
+
+static Bool
+I830UnmapMem(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   xf86UnMapVidMem(pScrn->scrnIndex, (pointer) pI830->FbBase,
+		   pI830->FbMapSize);
+   pI830->FbBase = 0;
+   I830UnmapMMIO(pScrn);
+   return TRUE;
+}
+
+#ifndef HAVE_GET_PUT_BIOSMEMSIZE
+#define HAVE_GET_PUT_BIOSMEMSIZE 1
+#endif
+
+#if HAVE_GET_PUT_BIOSMEMSIZE
+/*
+ * Tell the BIOS how much video memory is available.  The BIOS call used
+ * here won't always be available.
+ */
+static Bool
+PutBIOSMemSize(ScrnInfoPtr pScrn, int memSize)
+{
+   vbeInfoPtr pVbe = I830PTR(pScrn)->pVbe;
+
+   DPRINTF(PFX, "PutBIOSMemSize: %d kB\n", memSize / 1024);
+
+   pVbe->pInt10->num = 0x10;
+   pVbe->pInt10->ax = 0x5f11;
+   pVbe->pInt10->bx = 0;
+   pVbe->pInt10->cx = memSize / GTT_PAGE_SIZE;
+
+   xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   return Check5fStatus(pScrn, 0x5f11, pVbe->pInt10->ax);
+}
+
+/*
+ * This reports what the previous VBEGetVBEInfo() found.  Be sure to call
+ * VBEGetVBEInfo() after changing the BIOS memory size view.  If
+ * a separate BIOS call is added for this, it can be put here.  Only
+ * return a valid value if the funtionality for PutBIOSMemSize()
+ * is available.
+ */
+static int
+GetBIOSMemSize(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int memSize = KB(pI830->vbeInfo->TotalMemory * 64);
+
+   DPRINTF(PFX, "GetBIOSMemSize\n");
+
+   if (PutBIOSMemSize(pScrn, memSize))
+      return memSize;
+   else
+      return -1;
+}
+#endif
+
+/*
+ * These three functions allow the video BIOS's view of the available video
+ * memory to be changed.  This is currently implemented only for the 830
+ * and 845G, which can do this via a BIOS scratch register that holds the
+ * BIOS's view of the (pre-reserved) memory size.  If another mechanism
+ * is available in the future, it can be plugged in here.  
+ *
+ * The mapping used for the 830/845G scratch register's low 4 bits is:
+ *
+ *             320k => 0
+ *             832k => 1
+ *            8000k => 8
+ *
+ * The "unusual" values are the 512k, 1M, 8M pre-reserved memory, less
+ * overhead, rounded down to the BIOS-reported 64k granularity.
+ */
+
+static Bool
+SaveBIOSMemSize(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "SaveBIOSMemSize\n");
+
+   pI830->useSWF1 = FALSE;
+
+#if HAVE_GET_PUT_BIOSMEMSIZE
+   if ((pI830->saveBIOSMemSize = GetBIOSMemSize(pScrn)) != -1)
+      return TRUE;
+#endif
+
+   if (IS_I830(pI830) || IS_845G(pI830)) {
+      pI830->useSWF1 = TRUE;
+      pI830->saveSWF1 = INREG(SWF1) & 0x0f;
+
+      /*
+       * This is for sample purposes only.  pI830->saveBIOSMemSize isn't used
+       * when pI830->useSWF1 is TRUE.
+       */
+      switch (pI830->saveSWF1) {
+      case 0:
+	 pI830->saveBIOSMemSize = KB(320);
+	 break;
+      case 1:
+	 pI830->saveBIOSMemSize = KB(832);
+	 break;
+      case 8:
+	 pI830->saveBIOSMemSize = KB(8000);
+	 break;
+      default:
+	 pI830->saveBIOSMemSize = 0;
+	 break;
+      }
+      return TRUE;
+   }
+   return FALSE;
+}
+
+static void
+RestoreBIOSMemSize(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   CARD32 swf1;
+
+   DPRINTF(PFX, "RestoreBIOSMemSize\n");
+
+   if (!pI830->overrideBIOSMemSize)
+      return;
+
+#if HAVE_GET_PUT_BIOSMEMSIZE
+   if (!pI830->useSWF1) {
+      PutBIOSMemSize(pScrn, pI830->saveBIOSMemSize);
+      return;
+   }
+#endif
+
+   if ((IS_I830(pI830) || IS_845G(pI830)) && pI830->useSWF1) {
+      swf1 = INREG(SWF1);
+      swf1 &= ~0x0f;
+      swf1 |= (pI830->saveSWF1 & 0x0f);
+      OUTREG(SWF1, swf1);
+   }
+}
+
+static void
+SetBIOSMemSize(ScrnInfoPtr pScrn, int newSize)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   CARD32 swf1;
+   Bool mapped;
+
+   DPRINTF(PFX, "SetBIOSMemSize: %d kB\n", newSize / 1024);
+
+   if (!pI830->overrideBIOSMemSize)
+      return;
+
+#if HAVE_GET_PUT_BIOSMEMSIZE
+   if (!pI830->useSWF1) {
+      PutBIOSMemSize(pScrn, newSize);
+      return;
+   }
+#endif
+
+   if ((IS_I830(pI830) || IS_845G(pI830)) && pI830->useSWF1) {
+      CARD32 newSWF1;
+
+      /* Need MMIO access here. */
+      mapped = (pI830->MMIOBase != NULL);
+      if (!mapped)
+	 I830MapMMIO(pScrn);
+
+      if (newSize <= KB(832))
+	 newSWF1 = 1;
+      else
+	 newSWF1 = 8;
+
+      swf1 = INREG(SWF1);
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Before: SWF1 is 0x%08x\n", swf1);
+      swf1 &= ~0x0f;
+      swf1 |= (newSWF1 & 0x0f);
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "After: SWF1 is 0x%08x\n", swf1);
+      OUTREG(SWF1, swf1);
+      if (!mapped)
+	 I830UnmapMMIO(pScrn);
+   }
+}
+
+/*
+ * Use the native method instead of the vgahw method.  So far this is
+ * only used for 8-bit mode.
+ *
+ * XXX Look into using the 10-bit gamma correction mode for 15/16/24 bit,
+ * and see if a DirectColor visual can be offered.
+ */
+static void
+I830LoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices,
+		LOCO * colors, VisualPtr pVisual)
+{
+   I830Ptr pI830;
+   int i, index;
+   unsigned char r, g, b;
+   CARD32 val, temp;
+
+   DPRINTF(PFX, "I830LoadPalette: numColors: %d\n", numColors);
+   pI830 = I830PTR(pScrn);
+
+   if (pI830->pipeEnabled[0]) {
+      /* It seems that an initial read is needed. */
+      temp = INREG(PALETTE_A);
+      for (i = 0; i < numColors; i++) {
+	 index = indices[i];
+	 r = colors[index].red;
+	 g = colors[index].green;
+	 b = colors[index].blue;
+	 val = (r << 16) | (g << 8) | b;
+	 OUTREG(PALETTE_A + index * 4, val);
+      }
+   }
+   if (pI830->pipeEnabled[1]) {
+      /* It seems that an initial read is needed. */
+      temp = INREG(PALETTE_B);
+      for (i = 0; i < numColors; i++) {
+	 index = indices[i];
+	 r = colors[index].red;
+	 g = colors[index].green;
+	 b = colors[index].blue;
+	 val = (r << 16) | (g << 8) | b;
+	 OUTREG(PALETTE_B + index * 4, val);
+      }
+   }
+}
+
+static void
+PreInitCleanup(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   RestoreBIOSMemSize(pScrn);
+   if (pI830->swfSaved) {
+      OUTREG(SWF0, pI830->saveSWF0);
+      OUTREG(SWF4, pI830->saveSWF4);
+   }
+   if (pI830->MMIOBase)
+      I830UnmapMMIO(pScrn);
+   I830BIOSFreeRec(pScrn);
+}
+
+static Bool
+I830BIOSPreInit(ScrnInfoPtr pScrn, int flags)
+{
+   vgaHWPtr hwp;
+   I830Ptr pI830;
+   MessageType from;
+   rgb defaultWeight = { 0, 0, 0 };
+   vbeInfoPtr pVbe;
+   EntityInfoPtr pEnt;
+   int mem, memsize;
+   int flags24;
+   int i, n;
+   pointer pDDCModule, pVBEModule;
+   Bool enable;
+   const char *chipname;
+
+   if (pScrn->numEntities != 1)
+      return FALSE;
+
+   /* Load int10 module */
+   if (!xf86LoadSubModule(pScrn, "int10"))
+      return FALSE;
+   xf86LoaderReqSymLists(I810int10Symbols, NULL);
+
+   /* Load vbe module */
+   if (!(pVBEModule = xf86LoadSubModule(pScrn, "vbe")))
+      return FALSE;
+   xf86LoaderReqSymLists(I810vbeSymbols, NULL);
+
+   pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
+
+   if (flags & PROBE_DETECT) {
+      I830BIOSProbeDDC(pScrn, pEnt->index);
+      return TRUE;
+   }
+
+   /* The vgahw module should be loaded here when needed */
+   if (!xf86LoadSubModule(pScrn, "vgahw"))
+      return FALSE;
+   xf86LoaderReqSymLists(I810vgahwSymbols, NULL);
+
+
+   /* Allocate a vgaHWRec */
+   if (!vgaHWGetHWRec(pScrn))
+      return FALSE;
+
+   /* Allocate driverPrivate */
+   if (!I830BIOSGetRec(pScrn))
+      return FALSE;
+
+   pI830 = I830PTR(pScrn);
+   pI830->pEnt = pEnt;
+
+   if (pI830->pEnt->location.type != BUS_PCI)
+      return FALSE;
+
+   pI830->PciInfo = xf86GetPciInfoForEntity(pI830->pEnt->index);
+   pI830->PciTag = pciTag(pI830->PciInfo->bus, pI830->PciInfo->device,
+			  pI830->PciInfo->func);
+
+   if (xf86RegisterResources(pI830->pEnt->index, 0, ResNone)) {
+      PreInitCleanup(pScrn);
+      return FALSE;
+
+   }
+
+   pScrn->racMemFlags = RAC_FB | RAC_COLORMAP;
+   pScrn->monitor = pScrn->confScreen->monitor;
+   pScrn->progClock = TRUE;
+   pScrn->rgbBits = 8;
+
+   flags24 = Support32bppFb | PreferConvert24to32 | SupportConvert24to32;
+
+   if (!xf86SetDepthBpp(pScrn, 0, 0, 0, flags24))
+      return FALSE;
+
+   switch (pScrn->depth) {
+   case 8:
+   case 15:
+   case 16:
+   case 24:
+      break;
+   default:
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "Given depth (%d) is not supported by I830 driver\n",
+		 pScrn->depth);
+      return FALSE;
+   }
+   xf86PrintDepthBpp(pScrn);
+
+   if (!xf86SetWeight(pScrn, defaultWeight, defaultWeight))
+      return FALSE;
+   if (!xf86SetDefaultVisual(pScrn, -1))
+      return FALSE;
+
+   hwp = VGAHWPTR(pScrn);
+   pI830->cpp = pScrn->bitsPerPixel / 8;
+
+   /* Process the options */
+   xf86CollectOptions(pScrn, NULL);
+   if (!(pI830->Options = xalloc(sizeof(I830BIOSOptions))))
+      return FALSE;
+   memcpy(pI830->Options, I830BIOSOptions, sizeof(I830BIOSOptions));
+   xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, pI830->Options);
+
+   /* We have to use PIO to probe, because we haven't mapped yet. */
+   I830SetPIOAccess(pI830);
+
+   /* Initialize VBE record */
+   if ((pI830->pVbe = VBEInit(NULL, pI830->pEnt->index)) == NULL) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "VBE initialization failed.\n");
+      return FALSE;
+   }
+
+   switch (pI830->PciInfo->chipType) {
+   case PCI_CHIP_I830_M:
+      chipname = "830M";
+      break;
+   case PCI_CHIP_845_G:
+      chipname = "845G";
+      break;
+   case PCI_CHIP_I855_GM:
+      /* Check capid register to find the chipset variant */
+      pI830->variant = (pciReadLong(pI830->PciTag, I85X_CAPID)
+				>> I85X_VARIANT_SHIFT) & I85X_VARIANT_MASK;
+      switch (pI830->variant) {
+      case I855_GM:
+	 chipname = "855GM";
+	 break;
+      case I855_GME:
+	 chipname = "855GME";
+	 break;
+      case I852_GM:
+	 chipname = "852GM";
+	 break;
+      case I852_GME:
+	 chipname = "852GME";
+	 break;
+      default:
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Unknown 852GM/855GM variant: 0x%x)\n", pI830->variant);
+	 chipname = "852GM/855GM (unknown variant)";
+	 break;
+      }
+      break;
+   case PCI_CHIP_I865_G:
+      chipname = "865G";
+      break;
+   default:
+      chipname = "unknown chipset";
+      break;
+   }
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+	      "Integrated Graphics Chipset: Intel(R) %s\n", chipname);
+
+   pVbe = pI830->pVbe;
+
+   pI830->vbeInfo = VBEGetVBEInfo(pVbe);
+
+   /* Set the Chipset and ChipRev, allowing config file entries to override. */
+   if (pI830->pEnt->device->chipset && *pI830->pEnt->device->chipset) {
+      pScrn->chipset = pI830->pEnt->device->chipset;
+      from = X_CONFIG;
+   } else if (pI830->pEnt->device->chipID >= 0) {
+      pScrn->chipset = (char *)xf86TokenToString(I830BIOSChipsets,
+						 pI830->pEnt->device->chipID);
+      from = X_CONFIG;
+      xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipID override: 0x%04X\n",
+		 pI830->pEnt->device->chipID);
+   } else {
+      from = X_PROBED;
+      pScrn->chipset = (char *)xf86TokenToString(I830BIOSChipsets,
+						 pI830->PciInfo->chipType);
+   }
+
+   if (pI830->pEnt->device->chipRev >= 0) {
+      xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "ChipRev override: %d\n",
+		 pI830->pEnt->device->chipRev);
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, from, "Chipset: \"%s\"\n",
+	      (pScrn->chipset != NULL) ? pScrn->chipset : "Unknown i8xx");
+
+   if (pI830->pEnt->device->MemBase != 0) {
+      pI830->LinearAddr = pI830->pEnt->device->MemBase;
+      from = X_CONFIG;
+   } else {
+      if (pI830->PciInfo->memBase[1] != 0) {
+	 /* XXX Check mask. */
+	 pI830->LinearAddr = pI830->PciInfo->memBase[0] & 0xFF000000;
+	 from = X_PROBED;
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "No valid FB address in PCI config space\n");
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, from, "Linear framebuffer at 0x%lX\n",
+	      (unsigned long)pI830->LinearAddr);
+
+   if (pI830->pEnt->device->IOBase != 0) {
+      pI830->MMIOAddr = pI830->pEnt->device->IOBase;
+      from = X_CONFIG;
+   } else {
+      if (pI830->PciInfo->memBase[1]) {
+	 pI830->MMIOAddr = pI830->PciInfo->memBase[1] & 0xFFF80000;
+	 from = X_PROBED;
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "No valid MMIO address in PCI config space\n");
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, from, "IO registers at addr 0x%lX\n",
+	      (unsigned long)pI830->MMIOAddr);
+
+   /* Some of the probing needs MMIO access, so map it here. */
+   I830MapMMIO(pScrn);
+
+#if 1
+   pI830->saveSWF0 = INREG(SWF0);
+   pI830->saveSWF4 = INREG(SWF4);
+   pI830->swfSaved = TRUE;
+
+   /* Set "extended desktop" */
+   OUTREG(SWF0, pI830->saveSWF0 | (1 << 21));
+
+   /* Set "driver loaded",  "OS unknown", "APM 1.2" */
+   OUTREG(SWF4, (pI830->saveSWF4 & ~((3 << 19) | (7 << 16))) |
+		(1 << 23) | (2 << 16));
+#endif
+
+   if (IS_I830(pI830) || IS_845G(pI830)) {
+      PCITAG bridge;
+      CARD16 gmch_ctrl;
+
+      bridge = pciTag(0, 0, 0);		/* This is always the host bridge */
+      gmch_ctrl = pciReadWord(bridge, I830_GMCH_CTRL);
+      if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_128M) {
+	 pI830->FbMapSize = 0x8000000;
+      } else {
+	 pI830->FbMapSize = 0x4000000;
+      }
+   }
+   else {
+      /* 128MB aperture for later chips */
+      pI830->FbMapSize = 0x8000000;
+   }
+
+   /*
+    * Get the pre-allocated (stolen) memory size.
+    */
+   pI830->StolenMemory.Size = I830DetectMemory(pScrn);
+   pI830->StolenMemory.Start = 0;
+   pI830->StolenMemory.End = pI830->StolenMemory.Size;
+
+   /* Sanity check: compare with what the BIOS thinks. */
+   if (pI830->vbeInfo->TotalMemory != pI830->StolenMemory.Size / 1024 / 64) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Detected stolen memory (%d kB) doesn't match what the BIOS"
+		 " reports (%d kB)\n",
+		 ROUND_DOWN_TO(pI830->StolenMemory.Size / 1024, 64),
+		 pI830->vbeInfo->TotalMemory * 64);
+   }
+
+   /* Find the maximum amount of agpgart memory available. */
+   mem = I830CheckAvailableMemory(pScrn);
+   pI830->StolenOnly = FALSE;
+
+   if (mem <= 0) {
+      if (pI830->StolenMemory.Size <= 0) {
+	 /* Shouldn't happen. */
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "/dev/agpgart is either not available, or no memory "
+		 "is available\nfor allocation, "
+		 "and no pre-allocated memory is available.\n");
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "/dev/agpgart is either not available, or no memory "
+		 "is available\nfor allocation.  "
+		 "Using pre-allocated memory only.\n");
+      mem = 0;
+      pI830->StolenOnly = TRUE;
+   }
+
+   if (xf86ReturnOptValBool(pI830->Options, OPTION_NOACCEL, FALSE)) {
+      pI830->noAccel = TRUE;
+   }
+   if (xf86ReturnOptValBool(pI830->Options, OPTION_SW_CURSOR, FALSE)) {
+      pI830->SWCursor = TRUE;
+   }
+
+   pI830->directRenderingDisabled =
+	!xf86ReturnOptValBool(pI830->Options, OPTION_DRI, TRUE);
+
+#ifdef XF86DRI
+   if (!pI830->directRenderingDisabled) {
+      if (pI830->noAccel || pI830->SWCursor) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "DRI is disabled because it "
+		    "needs HW cursor and 2D acceleration.\n");
+	 pI830->directRenderingDisabled = TRUE;
+      } else if (pScrn->depth != 16 && pScrn->depth != 24) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "DRI is disabled because it "
+		    "runs only at depths 16 and 24.\n");
+	 pI830->directRenderingDisabled = TRUE;
+      }
+   }
+#endif
+
+   /*
+    * The "VideoRam" config file parameter specifies the total amount of
+    * memory that will be used/allocated.  When agpgart support isn't
+    * available (StolenOnly == TRUE), this is limited to the amount of
+    * pre-allocated ("stolen") memory.
+    */
+
+   /*
+    * Default to I830_DEFAULT_VIDEOMEM_2D (8192KB) for 2D-only,
+    * or I830_DEFAULT_VIDEOMEM_3D (32768KB) for 3D.  If the stolen memory
+    * amount is higher, default to it rounded up to the nearest MB.  This
+    * guarantees that by default there will be at least some run-time
+    * space for things that need a physical address.
+    */
+   if (!pI830->pEnt->device->videoRam) {
+      from = X_DEFAULT;
+#ifdef XF86DRI
+      if (!pI830->directRenderingDisabled)
+	 pScrn->videoRam = I830_DEFAULT_VIDEOMEM_3D;
+      else
+#endif
+	 pScrn->videoRam = I830_DEFAULT_VIDEOMEM_2D;
+      if (pI830->StolenMemory.Size / 1024 > pScrn->videoRam)
+	 pScrn->videoRam = ROUND_TO(pI830->StolenMemory.Size / 1024, 1024);
+   } else {
+      from = X_CONFIG;
+      pScrn->videoRam = pI830->pEnt->device->videoRam;
+   }
+
+   DPRINTF(PFX,
+	   "Available memory: %dk\n"
+	   "Requested memory: %dk\n", mem, pScrn->videoRam);
+
+
+   if (mem + (pI830->StolenMemory.Size / 1024) < pScrn->videoRam) {
+      pScrn->videoRam = mem + (pI830->StolenMemory.Size / 1024);
+      from = X_PROBED;
+      if (mem + (pI830->StolenMemory.Size / 1024) <
+	  pI830->pEnt->device->videoRam) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "VideoRAM reduced to %d kByte "
+		    "(limited to available sysmem)\n", pScrn->videoRam);
+      }
+   }
+
+   if (pScrn->videoRam > pI830->FbMapSize / 1024) {
+      pScrn->videoRam = pI830->FbMapSize / 1024;
+      if (pI830->FbMapSize / 1024 < pI830->pEnt->device->videoRam)
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "VideoRam reduced to %d kByte (limited to aperture size)\n",
+		    pScrn->videoRam);
+   }
+      
+   if (mem > 0) {
+      /*
+       * If the reserved (BIOS accessible) memory is less than the desired
+       * amount, try to increase it.  So far this is only implemented for
+       * the 845G and 830, but those details are handled in SetBIOSMemSize().
+       * 
+       * The BIOS-accessible amount is only important for setting video
+       * modes.  The maximum amount we try to set is limited to what would
+       * be enough for 1920x1440 with a 2048 pitch.
+       *
+       * If ALLOCATE_ALL_BIOSMEM is enabled in i830_memory.c, all of the
+       * BIOS-aware memory will get allocated.  If it isn't then it may
+       * not be, and in that case there is an assumption that the video
+       * BIOS won't attempt to access memory beyond what is needed for
+       * modes that are actually used.  ALLOCATE_ALL_BIOSMEM is enabled by
+       * default.
+       */
+
+      /* Try to keep HW cursor and Overlay amounts separate from this. */
+      int reserve = (HWCURSOR_SIZE + OVERLAY_SIZE) / 1024;
+
+      if (pScrn->videoRam - reserve >= I830_MAXIMUM_VBIOS_MEM)
+	 pI830->newBIOSMemSize = KB(I830_MAXIMUM_VBIOS_MEM);
+      else 
+	 pI830->newBIOSMemSize =
+			KB(ROUND_DOWN_TO(pScrn->videoRam - reserve, 64));
+
+      if (pI830->vbeInfo->TotalMemory * 64 < pI830->newBIOSMemSize / 1024) {
+
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Will attempt to tell the BIOS that there is "
+		    "%d kB VideoRAM\n", pI830->newBIOSMemSize / 1024);
+
+	 if (SaveBIOSMemSize(pScrn)) {
+	    pI830->overrideBIOSMemSize = TRUE;
+	    SetBIOSMemSize(pScrn, pI830->newBIOSMemSize);
+
+	    VBEFreeVBEInfo(pI830->vbeInfo);
+	    vbeFree(pI830->pVbe);
+	    pI830->pVbe = VBEInit(NULL, pI830->pEnt->index);
+	    pVbe = pI830->pVbe;
+	    pI830->vbeInfo = VBEGetVBEInfo(pVbe);
+
+	    pI830->BIOSMemorySize = KB(pI830->vbeInfo->TotalMemory * 64);
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "BIOS now sees %d kB VideoRAM\n",
+		       pI830->BIOSMemorySize / 1024);
+	 } else {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "BIOS view of memory size can't be changed "
+		       "(this is not an error).\n");
+	 }
+      }
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Pre-allocated VideoRAM: %d kByte\n",
+	      pI830->StolenMemory.Size / 1024);
+   xf86DrvMsg(pScrn->scrnIndex, from, "VideoRAM: %d kByte\n", pScrn->videoRam);
+   pI830->TotalVideoRam = KB(pScrn->videoRam);
+
+   /*
+    * If the requested videoRam amount is less than the stolen memory size,
+    * reduce the stolen memory size accordingly.
+    */
+   if (pI830->StolenMemory.Size > pI830->TotalVideoRam) {
+      pI830->StolenMemory.Size = pI830->TotalVideoRam;
+      pI830->StolenMemory.End = pI830->TotalVideoRam;
+   }
+
+   if (xf86GetOptValInteger(pI830->Options, OPTION_CACHE_LINES,
+			    &(pI830->CacheLines))) {
+      xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Requested %d cache lines\n",
+		 pI830->CacheLines);
+   } else {
+      pI830->CacheLines = -1;
+   }
+
+   pI830->XvDisabled =
+	!xf86ReturnOptValBool(pI830->Options, OPTION_XVIDEO, TRUE);
+
+#ifdef I830_XV
+   if (xf86GetOptValInteger(pI830->Options, OPTION_VIDEO_KEY,
+			    &(pI830->colorKey))) {
+      from = X_CONFIG;
+   } else if (xf86GetOptValInteger(pI830->Options, OPTION_COLOR_KEY,
+			    &(pI830->colorKey))) {
+      from = X_CONFIG;
+   } else {
+      pI830->colorKey = (1 << pScrn->offset.red) |
+			(1 << pScrn->offset.green) |
+			(((pScrn->mask.blue >> pScrn->offset.blue) - 1) <<
+			 pScrn->offset.blue);
+      from = X_DEFAULT;
+   }
+   xf86DrvMsg(pScrn->scrnIndex, from, "video overlay key set to 0x%x\n",
+	      pI830->colorKey);
+#endif
+
+   pI830->allowPageFlip = FALSE;
+   enable = xf86ReturnOptValBool(pI830->Options, OPTION_PAGEFLIP, FALSE);
+#ifdef XF86DRI
+   if (!pI830->directRenderingDisabled) {
+      pI830->allowPageFlip = enable;
+      xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "page flipping %s\n",
+		 enable ? "enabled" : "disabled");
+   }
+#endif
+
+   /* Check if the HW cursor needs physical address. */
+   if (IS_MOBILE(pI830))
+      pI830->CursorNeedsPhysical = TRUE;
+   else
+      pI830->CursorNeedsPhysical = FALSE;
+
+   /* Force ring buffer to be in low memory for the 845G. */
+   if (IS_845G(pI830))
+      pI830->NeedRingBufferLow = TRUE;
+
+   /*
+    * XXX If we knew the pre-initialised GTT format for certain, we could
+    * probably figure out the physical address even in the StolenOnly case.
+    */
+   if (pI830->StolenOnly && pI830->CursorNeedsPhysical && !pI830->SWCursor) {
+      xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+		 "HW Cursor disabled because it needs agpgart memory.\n");
+      pI830->SWCursor = TRUE;
+   }
+
+   /*
+    * Reduce the maximum videoram available for video modes by the ring buffer,
+    * minimum scratch space and HW cursor amounts.
+    */
+   if (!pI830->SWCursor)
+      pScrn->videoRam -= (HWCURSOR_SIZE / 1024);
+   if (!pI830->XvDisabled)
+      pScrn->videoRam -= (OVERLAY_SIZE / 1024);
+   if (!pI830->noAccel) {
+      pScrn->videoRam -= (PRIMARY_RINGBUFFER_SIZE / 1024);
+      pScrn->videoRam -= (MIN_SCRATCH_BUFFER_SIZE / 1024);
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+	      "Maximum frambuffer space: %d kByte\n", pScrn->videoRam);
+
+   /*
+    * If the driver can do gamma correction, it should call xf86SetGamma() here.
+    */
+
+   {
+      Gamma zeros = { 0.0, 0.0, 0.0 };
+
+      if (!xf86SetGamma(pScrn, zeros))
+	 return FALSE;
+   }
+
+   if (IS_MOBILE(pI830))
+      pI830->availablePipes = 2;
+   else
+      pI830->availablePipes = 1;
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "%d display pipe%s available.\n",
+	      pI830->availablePipes, pI830->availablePipes > 1 ? "s" : "");
+
+   if (!I830DetectDisplayDevice(pScrn)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "Couldn't detect display devices.\n");
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+   if ((pDDCModule = xf86LoadSubModule(pScrn, "ddc")) == NULL) {
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+   if ((pI830->vesa->monitor = vbeDoEDID(pVbe, pDDCModule)) != NULL) {
+      xf86PrintEDID(pI830->vesa->monitor);
+   }
+   if ((pScrn->monitor->DDC = pI830->vesa->monitor) != NULL)
+      xf86SetDDCproperties(pScrn, pI830->vesa->monitor);
+   xf86UnloadSubModule(pDDCModule);
+
+   /* XXX Move this to a header. */
+#define VIDEO_BIOS_SCRATCH 0x18
+
+#if 1
+   /*
+    * XXX This should be in ScreenInit/EnterVT.  PreInit should not leave the
+    * state changed.
+    */
+   /* Enable hot keys by writing the proper value to GR18 */
+   {
+      CARD8 gr18;
+
+      gr18 = pI830->readControl(pI830, GRX, VIDEO_BIOS_SCRATCH);
+      gr18 &= ~0x80;			/*
+					 * Clear Hot key bit so that Video
+					 * BIOS performs the hot key
+					 * servicing
+					 */
+      pI830->writeControl(pI830, GRX, VIDEO_BIOS_SCRATCH, gr18);
+   }
+#endif
+
+   for (i = 0; i < pI830->availablePipes; i++) {
+      int pipe =
+	  (pI830->configuredDevices >> PIPE_SHIFT(i)) & PIPE_ACTIVE_MASK;
+      if (pipe & ~PIPE_CRT_ACTIVE) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+		    "A non-CRT device is attached to pipe %c.\n"
+		    "\tNo refresh rate overrides will be attempted.\n",
+		    PIPE_NAME(i));
+	 pI830->vesa->useDefaultRefresh = TRUE;
+      }
+      /*
+       * Some desktop platforms might not have 0x5f05, so useExtendedRefresh
+       * would need to be set to FALSE for those cases.
+       */
+      if (!pI830->vesa->useDefaultRefresh)
+	 pI830->useExtendedRefresh = TRUE;
+   }
+
+   if (pI830->useExtendedRefresh) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "Will use BIOS call 0x5f05 to set refresh rates for CRTs.\n");
+   }
+
+   /*
+    * Calling 0x5f64 can reset the refresh rate, so only do this when
+    * using 0x5f05, or when not overriding the default refresh rate.
+    * Also, 0x5f64 doesn't work correctly in i830 platforms.
+    */
+   pI830->enableDisplays = !IS_I830(pI830) && pI830->useExtendedRefresh;
+
+   if (pI830->enableDisplays) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "Will use BIOS call 0x5f64 to enable displays.\n");
+   }
+
+   /*
+    * Limit videoram available for mode selection to what the video
+    * BIOS can see.
+    */
+   if (pScrn->videoRam > (pI830->vbeInfo->TotalMemory * 64))
+      memsize = pI830->vbeInfo->TotalMemory * 64;
+   else
+      memsize = pScrn->videoRam;
+   xf86DrvMsg(pScrn->scrnIndex, X_PROBED,
+	      "Maximum space available for video modes: %d kByte\n", memsize);
+
+   /*
+    * Note: VBE modes (> 0x7f) won't work with Intel's extended BIOS
+    * functions.  For that reason it's important to set only
+    * V_MODETYPE_VGA in the flags for VBEGetModePool().
+    */
+   pScrn->modePool = VBEGetModePool(pScrn, pVbe, pI830->vbeInfo,
+				    V_MODETYPE_VGA);
+
+   if (!pScrn->modePool) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "No Video BIOS modes for chosen depth.\n");
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+   VBESetModeNames(pScrn->modePool);
+
+   /*
+    * XXX DDC information: There's code in xf86ValidateModes
+    * (VBEValidateModes) to set monitor defaults based on DDC information
+    * where available.  If we need something that does better than this,
+    * there's code in vesa/vesa.c.
+    */
+
+   /* XXX Need to get relevant modes and virtual parameters. */
+   /* Do the mode validation without regard to special scanline pitches. */
+   n = VBEValidateModes(pScrn, NULL, pScrn->display->modes, NULL,
+			NULL, 0, MAX_DISPLAY_PITCH, 1,
+			0, MAX_DISPLAY_HEIGHT,
+			pScrn->display->virtualX,
+			pScrn->display->virtualY,
+			memsize, LOOKUP_BEST_REFRESH);
+   if (n <= 0) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes.\n");
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+   xf86PruneDriverModes(pScrn);
+
+   pScrn->currentMode = pScrn->modes;
+
+   if (pScrn->modes == NULL) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No modes.\n");
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+#ifndef USE_PITCHES
+#define USE_PITCHES 1
+#endif
+
+   /*
+    * If DRI is potentially usable, check if there is enough memory available
+    * for it, and if there's also enough to allow tiling to be enabled.
+    */
+#if defined(XF86DRI)
+   if (!pI830->directRenderingDisabled) {
+      int savedDisplayWidth = pScrn->displayWidth;
+      int memNeeded = 0;
+      /* Good pitches to allow tiling.  Don't care about pitches < 256. */
+      static const int pitches[] = {
+	 128 * 2,
+	 128 * 4,
+	 128 * 8,
+	 128 * 16,
+	 128 * 32,
+	 128 * 64,
+	 0
+      };
+
+#ifdef I830_XV
+      /*
+       * Set this so that the overlay allocation is factored in when
+       * appropriate.
+       */
+      pI830->XvEnabled = !pI830->XvDisabled;
+#endif
+
+      for (i = 0; pitches[i] != 0; i++) {
+#if USE_PITCHES
+	 if (pitches[i] >= pScrn->displayWidth) {
+	    pScrn->displayWidth = pitches[i];
+	    break;
+	 }
+#else
+	 if (pitches[i] == pScrn->displayWidth)
+	    break;
+#endif
+      }
+
+      /*
+       * If the displayWidth is a tilable pitch, test if there's enough
+       * memory available to enable tiling.
+       */
+      if (pScrn->displayWidth == pitches[i]) {
+	 I830ResetAllocations(pScrn, 0);
+	 if (I830Allocate2DMemory(pScrn, ALLOCATE_DRY_RUN | ALLOC_INITIAL) &&
+	     I830Allocate3DMemory(pScrn, ALLOCATE_DRY_RUN)) {
+	    memNeeded = I830GetExcessMemoryAllocations(pScrn);
+	    if (memNeeded > 0 || pI830->MemoryAperture.Size < 0) {
+	       if (memNeeded > 0) {
+		  xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+			     "%d kBytes additional video memory is "
+			     "required to\n\tenable tiling mode for DRI.\n",
+			     (memNeeded + 1023) / 1024);
+	       }
+	       if (pI830->MemoryAperture.Size < 0) {
+		  xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+			     "Allocation with DRI tiling enabled would "
+			     "exceed the\n"
+			     "\tmemory aperture size (%d kB) by %d kB.\n"
+			     "\tReduce VideoRam amount to avoid this!\n",
+			     pI830->FbMapSize / 1024,
+			     -pI830->MemoryAperture.Size / 1024);
+	       }
+	       pScrn->displayWidth = savedDisplayWidth;
+	       pI830->allowPageFlip = FALSE;
+	    } else if (pScrn->displayWidth != savedDisplayWidth) {
+	       xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+			  "Increasing the scanline pitch to allow tiling mode "
+			  "(%d -> %d).\n",
+			  savedDisplayWidth, pScrn->displayWidth);
+	    }
+	 } else {
+	    memNeeded = 0;
+	    xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		       "Unexpected dry run allocation failure (1).\n");
+	 }
+      }
+      if (memNeeded > 0 || pI830->MemoryAperture.Size < 0) {
+	 /*
+	  * Tiling can't be enabled.  Check if there's enough memory for DRI
+	  * without tiling.
+	  */
+	 I830ResetAllocations(pScrn, 0);
+	 if (I830Allocate2DMemory(pScrn, ALLOCATE_DRY_RUN | ALLOC_INITIAL) &&
+	     I830Allocate3DMemory(pScrn, ALLOCATE_DRY_RUN | ALLOC_NO_TILING)) {
+	    memNeeded = I830GetExcessMemoryAllocations(pScrn);
+	    if (memNeeded > 0 || pI830->MemoryAperture.Size < 0) {
+	       if (memNeeded > 0) {
+		  xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+			     "%d kBytes additional video memory is required "
+			     "to enable DRI.\n",
+			     (memNeeded + 1023) / 1024);
+	       }
+	       if (pI830->MemoryAperture.Size < 0) {
+		  xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+			     "Allocation with DRI enabled would "
+			     "exceed the\n"
+			     "\tmemory aperture size (%d kB) by %d kB.\n"
+			     "\tReduce VideoRam amount to avoid this!\n",
+			     pI830->FbMapSize / 1024,
+			     -pI830->MemoryAperture.Size / 1024);
+	       }
+	       pI830->directRenderingDisabled = TRUE;
+	       xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Disabling DRI.\n");
+	    }
+	 } else {
+	    xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		       "Unexpected dry run allocation failure (2).\n");
+	 }
+      }
+   }
+#endif
+
+   VBEPrintModes(pScrn);
+
+   if (!pI830->vesa->useDefaultRefresh) {
+      /*
+       * This sets the parameters for the VBE modes according to the best
+       * usable parameters from the Monitor sections modes (usually the
+       * default VESA modes), allowing for better than default refresh rates.
+       * This only works for VBE 3.0 and later.  Also, we only do this
+       * if there are no non-CRT devices attached.
+       */
+      VBESetModeParameters(pScrn, pVbe);
+   }
+
+   /* PreInit shouldn't leave any state changes, so restore this. */
+   RestoreBIOSMemSize(pScrn);
+
+   /* Don't need MMIO access anymore. */
+   if (pI830->swfSaved) {
+      OUTREG(SWF0, pI830->saveSWF0);
+      OUTREG(SWF4, pI830->saveSWF4);
+   }
+   I830UnmapMMIO(pScrn);
+
+   /* Set display resolution */
+   xf86SetDpi(pScrn, 0, 0);
+
+   /* Load the required sub modules */
+   if (!xf86LoadSubModule(pScrn, "fb")) {
+      PreInitCleanup(pScrn);
+      return FALSE;
+   }
+
+   xf86LoaderReqSymLists(I810fbSymbols, NULL);
+
+   if (!pI830->noAccel) {
+      if (!xf86LoadSubModule(pScrn, "xaa")) {
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+      xf86LoaderReqSymLists(I810xaaSymbols, NULL);
+   }
+
+   if (!pI830->SWCursor) {
+      if (!xf86LoadSubModule(pScrn, "ramdac")) {
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+      xf86LoaderReqSymLists(I810ramdacSymbols, NULL);
+   }
+
+   /*  We won't be using the VGA access after the probe. */
+   I830SetMMIOAccess(pI830);
+   xf86SetOperatingState(resVgaIo, pI830->pEnt->index, ResUnusedOpr);
+   xf86SetOperatingState(resVgaMem, pI830->pEnt->index, ResDisableOpr);
+
+   VBEFreeVBEInfo(pI830->vbeInfo);
+   vbeFree(pVbe);
+
+#if defined(XF86DRI)
+   if (!pI830->directRenderingDisabled) {
+      if (!xf86LoadSubModule(pScrn, "shadow")) {
+	 PreInitCleanup(pScrn);
+	 return FALSE;
+      }
+      xf86LoaderReqSymLists(I810shadowSymbols, NULL);
+   }
+#endif
+
+   return TRUE;
+}
+
+/*
+ * As the name says.  Check that the initial state is reasonable.
+ * If any unrecoverable problems are found, bail out here.
+ */
+static Bool
+CheckInheritedState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int errors = 0, fatal = 0;
+   unsigned long temp, head, tail;
+
+   /* Check first for page table errors */
+   temp = INREG(PGE_ERR);
+   if (temp != 0) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "PGTBL_ER is 0x%08x\n", temp);
+      errors++;
+   }
+   temp = INREG(PGETBL_CTL);
+   if (!(temp & 1)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "PGTBL_CTL (0x%08x) indicates GTT is disabled\n", temp);
+      errors++;
+   }
+   temp = INREG(LP_RING + RING_LEN);
+   if (temp & 1) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "PRB0_CTL (0x%08x) indicates ring buffer enabled\n", temp);
+      errors++;
+   }
+   head = INREG(LP_RING + RING_HEAD);
+   tail = INREG(LP_RING + RING_TAIL);
+   if ((tail & I830_TAIL_MASK) != (head & I830_HEAD_MASK)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "PRB0_HEAD (0x%08x) and PRB0_TAIL (0x%08x) indicate "
+		 "ring buffer not flushed\n", head, tail);
+      errors++;
+   }
+#if 0
+   if (errors)
+      I830PrintErrorState(pScrn);
+#endif
+
+   if (fatal)
+      FatalError("CheckInheritedState: can't recover from the above\n");
+
+   return (errors != 0);
+}
+
+/*
+ * Reset registers that it doesn't make sense to save/restore to a sane state.
+ * This is basically the ring buffer and fence registers.  Restoring these
+ * doesn't make sense without restoring GTT mappings.  This is something that
+ * whoever gets control next should do.
+ */
+static void
+ResetState(ScrnInfoPtr pScrn, Bool flush)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int i;
+   unsigned long temp;
+
+   DPRINTF(PFX, "ResetState: flush is %s\n", BOOLTOSTRING(flush));
+
+   /* Reset the fence registers to 0 */
+   for (i = 0; i < 8; i++)
+      OUTREG(FENCE + i * 4, 0);
+
+   /* Flush the ring buffer (if enabled), then disable it. */
+   if (pI830->AccelInfoRec != NULL && flush) {
+      temp = INREG(LP_RING + RING_LEN);
+      if (temp & 1) {
+	 I830RefreshRing(pScrn);
+	 I830Sync(pScrn);
+	 DO_RING_IDLE();
+      }
+   }
+   OUTREG(LP_RING + RING_LEN, 0);
+   OUTREG(LP_RING + RING_HEAD, 0);
+   OUTREG(LP_RING + RING_TAIL, 0);
+   OUTREG(LP_RING + RING_START, 0);
+
+   if (pI830->CursorInfoRec && pI830->CursorInfoRec->HideCursor)
+       pI830->CursorInfoRec->HideCursor(pScrn);
+}
+
+static void
+SetFenceRegs(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int i;
+
+   DPRINTF(PFX, "SetFenceRegs\n");
+
+   for (i = 0; i < 8; i++) {
+      OUTREG(FENCE + i * 4, pI830->ModeReg.Fence[i]);
+      if (I810_DEBUG & DEBUG_VERBOSE_VGA)
+	 ErrorF("Fence Register : %x\n", pI830->ModeReg.Fence[i]);
+   }
+}
+
+static void
+SetRingRegs(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned int itemp;
+
+   DPRINTF(PFX, "SetRingRegs\n");
+
+   if (pI830->noAccel)
+      return;
+
+   OUTREG(LP_RING + RING_LEN, 0);
+   OUTREG(LP_RING + RING_TAIL, 0);
+   OUTREG(LP_RING + RING_HEAD, 0);
+
+   if ((pI830->LpRing.mem.Start & I830_RING_START_MASK) !=
+       pI830->LpRing.mem.Start) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "I830SetRingRegs: Ring buffer start (%x) violates its "
+		 "mask (%x)\n", pI830->LpRing.mem.Start, I830_RING_START_MASK);
+   }
+   /* Don't care about the old value.  Reserved bits must be zero anyway. */
+   itemp = pI830->LpRing.mem.Start & I830_RING_START_MASK;
+   OUTREG(LP_RING + RING_START, itemp);
+
+   if (((pI830->LpRing.mem.Size - 4096) & I830_RING_NR_PAGES) !=
+       pI830->LpRing.mem.Size - 4096) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "I830SetRingRegs: Ring buffer size - 4096 (%x) violates its "
+		 "mask (%x)\n", pI830->LpRing.mem.Size - 4096,
+		 I830_RING_NR_PAGES);
+   }
+   /* Don't care about the old value.  Reserved bits must be zero anyway. */
+   itemp = (pI830->LpRing.mem.Size - 4096) & I830_RING_NR_PAGES;
+   itemp |= (RING_NO_REPORT | RING_VALID);
+   OUTREG(LP_RING + RING_LEN, itemp);
+   I830RefreshRing(pScrn);
+}
+
+/*
+ * This should be called everytime the X server gains control of the screen,
+ * before any video modes are programmed (ScreenInit, EnterVT).
+ */
+static void
+SetHWOperatingState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "SetHWOperatingState\n");
+
+   if (!pI830->noAccel)
+      SetRingRegs(pScrn);
+   SetFenceRegs(pScrn);
+   if (!pI830->SWCursor)
+      I830InitHWCursor(pScrn);
+}
+
+static Bool
+SaveHWState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+   vgaHWPtr hwp = VGAHWPTR(pScrn);
+   vgaRegPtr vgaReg = &hwp->SavedReg;
+   VbeModeInfoBlock *modeInfo;
+   VESAPtr pVesa;
+
+   DPRINTF(PFX, "SaveHWState\n");
+
+   pVesa = pI830->vesa;
+   /* Make sure we save at least this information in case of failure. */
+   VBEGetVBEMode(pVbe, &pVesa->stateMode);
+   modeInfo = VBEGetModeInfo(pVbe, pVesa->stateMode);
+   pVesa->savedScanlinePitch = 0;
+   if (modeInfo) {
+      if (VBE_MODE_GRAPHICS(modeInfo)) {
+         VBEGetLogicalScanline(pVbe, &pVesa->savedScanlinePitch, NULL, NULL);
+      }
+      VBEFreeModeInfo(modeInfo);
+   }
+
+   vgaHWUnlock(hwp);
+   vgaHWSave(pScrn, vgaReg, VGA_SR_FONTS);
+
+#ifndef I845G_VBE_WORKAROUND
+#define I845G_VBE_WORKAROUND 1
+#endif
+
+   pVesa = pI830->vesa;
+   /* This save/restore method doesn't work for 845G BIOS */
+   /*
+    * XXX If it's fixed in production versions, this could be removed.
+    *
+    * KW: This may have been because of the behaviour I've found on my
+    * board: The 'save' command actually modifies the interrupt
+    * registers, turning off the irq & breaking the kernel module
+    * behaviour.
+    */
+   if (!I845G_VBE_WORKAROUND || !IS_845G(pI830)) {
+      CARD16 imr = INREG16(IMR);
+      CARD16 ier = INREG16(IER);
+      CARD16 hwstam = INREG16(HWSTAM);
+
+      if (!VBESaveRestore(pVbe, MODE_SAVE, &pVesa->state, &pVesa->stateSize,
+			  &pVesa->statePage)) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "SaveHWState: VBESaveRestore(MODE_SAVE) failed.\n");
+	 return FALSE;
+      }
+
+      OUTREG16(IMR, imr);
+      OUTREG16(IER, ier);
+      OUTREG16(HWSTAM, hwstam);
+   }
+
+   pVesa->savedPal = VBESetGetPaletteData(pVbe, FALSE, 0, 256,
+					     NULL, FALSE, FALSE);
+   if (!pVesa->savedPal) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "SaveHWState: VBESetGetPaletteData(GET) failed.\n");
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+static Bool
+RestoreHWState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+   vgaHWPtr hwp = VGAHWPTR(pScrn);
+   vgaRegPtr vgaReg = &hwp->SavedReg;
+   VESAPtr pVesa;
+   Bool restored = FALSE;
+
+   DPRINTF(PFX, "RestoreHWState\n");
+
+   pVesa = pI830->vesa;
+
+   /*
+    * Workaround for text mode restoration with some flat panels.
+    * Temporarily program a 640x480 mode before switching back to
+    * text mode.
+    */
+   if (pVesa->useDefaultRefresh) {
+      int mode = 0;
+
+      switch (pScrn->depth) {
+      case 8:
+	 mode = 0x30;
+	 break;
+      case 15:
+	 mode = 0x40;
+	 break;
+      case 16:
+	 mode = 0x41;
+	 break;
+      case 24:
+	 mode = 0x50;
+	 break;
+      }
+      mode |= (1 << 15) | (1 << 14);
+      I830VESASetVBEMode(pScrn, mode, NULL);
+   }
+
+   if (pVesa->state && pVesa->stateSize) {
+      CARD16 imr = INREG16(IMR);
+      CARD16 ier = INREG16(IER);
+      CARD16 hwstam = INREG16(HWSTAM);
+
+      /* Make a copy of the state.  Don't rely on it not being touched. */
+      if (!pVesa->pstate) {
+	 pVesa->pstate = xalloc(pVesa->stateSize);
+	 if (pVesa->pstate)
+	    memcpy(pVesa->pstate, pVesa->state, pVesa->stateSize);
+      }
+      restored = VBESaveRestore(pVbe, MODE_RESTORE, &pVesa->state,
+				   &pVesa->stateSize, &pVesa->statePage);
+      if (!restored) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "RestoreHWState: VBESaveRestore failed.\n");
+      }
+      /* Copy back */
+      if (pVesa->pstate)
+	 memcpy(pVesa->state, pVesa->pstate, pVesa->stateSize);
+
+      OUTREG16(IMR, imr);
+      OUTREG16(IER, ier);
+      OUTREG16(HWSTAM, hwstam);
+   }
+   /* If that failed, restore the original mode. */
+   if (!restored) {
+      xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		 "Setting the original video mode instead of restoring\n\t"
+		 "the saved state\n");
+      I830VESASetVBEMode(pScrn, pVesa->stateMode, NULL);
+   }
+   if (pVesa->savedScanlinePitch)
+       VBESetLogicalScanline(pVbe, pVesa->savedScanlinePitch);
+
+   if (pVesa->savedPal)
+      VBESetGetPaletteData(pVbe, TRUE, 0, 256, pVesa->savedPal, FALSE, TRUE);
+
+   vgaHWRestore(pScrn, vgaReg, VGA_SR_FONTS);
+   vgaHWLock(hwp);
+   return TRUE;
+}
+
+#ifndef USE_VBE
+#define USE_VBE 1
+#endif
+
+static Bool
+I830VESASetVBEMode(ScrnInfoPtr pScrn, int mode, VbeCRTCInfoBlock * block)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "Setting mode 0x%.8x\n", mode);
+#if USE_VBE
+   return VBESetVBEMode(pI830->pVbe, mode, block);
+#else
+   {
+      vbeInfoPtr pVbe = pI830->pVbe;
+      pVbe->pInt10->num = 0x10;
+      pVbe->pInt10->ax = 0x80 | (mode & 0x7f);
+      xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+      pVbe->pInt10->ax = 0x0f00;
+      xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+      if ((pVbe->pInt10->ax & 0x7f) == (mode & 0x7f))
+	 return TRUE;
+      else
+	 return FALSE;
+   }
+#endif
+}
+
+static Bool
+I830VESASetMode(ScrnInfoPtr pScrn, DisplayModePtr pMode)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+   VbeModeInfoData *data;
+   int mode, i;
+   CARD32 planeA, planeB, temp;
+   int refresh = 60;
+#ifdef XF86DRI
+   Bool didLock = FALSE;
+#endif
+
+   DPRINTF(PFX, "I830VESASetMode\n");
+
+   data = (VbeModeInfoData *) pMode->Private;
+
+   /* Always Enable Linear Addressing */
+   mode = data->mode | (1 << 15) | (1 << 14);
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled && !pI830->LockHeld) {
+      DRILock(screenInfo.screens[pScrn->scrnIndex], 0);
+      pI830->LockHeld = 1;
+      didLock = TRUE;
+   }
+#endif
+
+#ifndef MODESWITCH_RESET_STATE
+#define MODESWITCH_RESET_STATE 0
+#endif
+#if MODESWITCH_RESET_STATE
+   ResetState(pScrn, TRUE);
+#endif
+
+   /* XXX Add macros for the various mode parameter bits. */
+
+   if (pI830->vesa->useDefaultRefresh)
+      mode &= ~(1 << 11);
+
+   if (I830VESASetVBEMode(pScrn, mode, data->block) == FALSE) {
+      if ((data->block && (mode & (1 << 11))) &&
+	  I830VESASetVBEMode(pScrn, (mode & ~(1 << 11)), NULL) == TRUE) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "Set VBE Mode rejected this modeline.\n\t"
+		    "Trying standard mode instead!\n");
+	 DPRINTF(PFX, "OOPS!\n");
+	 xfree(data->block);
+	 data->block = NULL;
+	 data->mode &= ~(1 << 11);
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Set VBE Mode failed!\n");
+	 return FALSE;
+      }
+   }
+
+   /*
+    * The BIOS may not set a scanline pitch that would require more video
+    * memory than it's aware of.  We check for this later, and set it
+    * explicitly if necessary.
+    */
+   if (data->data->XResolution != pScrn->displayWidth)
+      VBESetLogicalScanline(pVbe, pScrn->displayWidth);
+
+   if (pScrn->bitsPerPixel >= 8 && pI830->vbeInfo->Capabilities[0] & 0x01)
+      VBESetGetDACPaletteFormat(pVbe, 8);
+
+   /*
+    * XXX This location of this isn't correct.
+    *
+    * Turn on the configured displays.  This has the effect of resetting
+    * the default refresh rates to values that the configured displays
+    * can handle.  This seems to be the safest way to make sure that this
+    * happens.  When it's safe to set higher values, we do that after this.
+    *
+    * Note: When a DFP is connected to an 830, this causes the mode setting
+    * to be trashed.  So, we don't do it on the 830.
+    *
+    * XXX Need to test an 830 with a LFP.
+    */
+   if (pI830->enableDisplays) {
+      if (!SetDisplayDevices(pScrn, pI830->configuredDevices)) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "Failed to switch to configured display devices\n");
+      }
+   }
+
+   /*
+    * When it's OK to set better than default refresh rates, set them here.
+    */
+   if (pI830->useExtendedRefresh && !pI830->vesa->useDefaultRefresh &&
+       (mode & (1 << 11)) && data && data->data && data->block) {
+      refresh = SetRefreshRate(pScrn, mode, data->block->RefreshRate / 100);
+      if (!refresh) {
+	 refresh = 60;
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "Failed to set refresh rate to %dHz.\n",
+		    data->block->RefreshRate / 100);
+      }
+   }
+
+
+   /* XXX Fix plane A with pipe A, and plane B with pipe B. */
+   planeA = INREG(DSPACNTR);
+   planeB = INREG(DSPBCNTR);
+
+   pI830->planeEnabled[0] = ((planeA & DISPLAY_PLANE_ENABLE) != 0);
+   pI830->planeEnabled[1] = ((planeB & DISPLAY_PLANE_ENABLE) != 0);
+
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Display plane A is %s.\n",
+	      pI830->planeEnabled[0] ? "enabled" : "disabled");
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Display plane B is %s.\n",
+	      pI830->planeEnabled[1] ? "enabled" : "disabled");
+
+   /*
+    * Sometimes it seems that no display planes are enabled at this point.
+    * For mobile platforms pick the plane(s) connected to enabled pipes.
+    * For others choose plane A.
+    */
+   if (!pI830->planeEnabled[0] && !pI830->planeEnabled[1]) {
+      if (IS_MOBILE(pI830)) {
+	 if ((pI830->pipeEnabled[0] &&
+	      ((planeA & DISPPLANE_SEL_PIPE_MASK) == DISPPLANE_SEL_PIPE_A)) ||
+	     (pI830->pipeEnabled[1] &&
+	      ((planeA & DISPPLANE_SEL_PIPE_MASK) == DISPPLANE_SEL_PIPE_B))) {
+	    pI830->planeEnabled[0] = TRUE;
+	 }
+	 if ((pI830->pipeEnabled[0] &&
+	      ((planeB & DISPPLANE_SEL_PIPE_MASK) == DISPPLANE_SEL_PIPE_A)) ||
+	     (pI830->pipeEnabled[1] &&
+	      ((planeB & DISPPLANE_SEL_PIPE_MASK) == DISPPLANE_SEL_PIPE_B))) {
+	    pI830->planeEnabled[1] = TRUE;
+	 }
+      } else {
+	 pI830->planeEnabled[0] = TRUE;
+      }
+      if (pI830->planeEnabled[0]) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Enabling plane A.\n");
+	 planeA |= DISPLAY_PLANE_ENABLE;
+	 OUTREG(DSPACNTR, planeA);
+	 /* flush the change. */
+	 temp = INREG(DSPABASE);
+	 OUTREG(DSPABASE, temp);
+      }
+      if (pI830->planeEnabled[1]) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Enabling plane B.\n");
+	 planeB |= DISPLAY_PLANE_ENABLE;
+	 OUTREG(DSPBCNTR, planeB);
+	 /* flush the change. */
+	 temp = INREG(DSPBADDR);
+	 OUTREG(DSPBADDR, temp);
+      }
+   }
+
+   /* XXX Plane C is ignored for now (overlay). */
+
+   /*
+    * Print out the PIPEACONF and PIPEBCONF registers.
+    */
+   temp = INREG(PIPEACONF);
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PIPEACONF is 0x%08x\n", temp);
+   if (IS_MOBILE(pI830)) {
+      temp = INREG(PIPEBCONF);
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "PIPEBCONF is 0x%08x\n", temp);
+   }
+
+#if PRINT_MODE_INFO
+   /* Print out some CRTC/display information. */
+   temp = INREG(HTOTAL_A);
+   ErrorF("Horiz active: %d, Horiz total: %d\n", temp & 0x7ff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(HBLANK_A);
+   ErrorF("Horiz blank start: %d, Horiz blank end: %d\n", temp & 0xfff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(HSYNC_A);
+   ErrorF("Horiz sync start: %d, Horiz sync end: %d\n", temp & 0xfff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(VTOTAL_A);
+   ErrorF("Vert active: %d, Vert total: %d\n", temp & 0x7ff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(VBLANK_A);
+   ErrorF("Vert blank start: %d, Vert blank end: %d\n", temp & 0xfff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(VSYNC_A);
+   ErrorF("Vert sync start: %d, Vert sync end: %d\n", temp & 0xfff,
+	  (temp >> 16) & 0xfff);
+   temp = INREG(PIPEASRC);
+   ErrorF("Image size: %dx%d (%dx%d)\n",
+          (temp >> 16) & 0x7ff, temp & 0x7ff,
+	  (((temp >> 16) & 0x7ff) + 1), ((temp & 0x7ff) + 1));
+   ErrorF("Pixel multiply is %d\n", (planeA >> 20) & 0x3);
+   temp = INREG(DSPABASE);
+   ErrorF("Plane A start offset is %d\n", temp);
+   temp = INREG(DSPASTRIDE);
+   ErrorF("Plane A stride is %d bytes (%d pixels)\n", temp, temp / pI830->cpp);
+#endif
+
+   for (i = 0; i < MAX_DISPLAY_PIPES; i++) {
+      CARD32 stridereg = i ? DSPBSTRIDE : DSPASTRIDE;
+      CARD32 basereg = i ? DSPBBASE : DSPABASE;
+
+      if (!pI830->planeEnabled[i])
+	 continue;
+
+      temp = INREG(stridereg);
+      if (temp / pI830->cpp != pScrn->displayWidth) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		    "Correcting plane %c stride (%d -> %d)\n", PIPE_NAME(i),
+		    temp / pI830->cpp, pScrn->displayWidth);
+	 OUTREG(stridereg, pScrn->displayWidth * pI830->cpp);
+	 /* Trigger update */
+	 temp = INREG(basereg);
+	 OUTREG(basereg, temp);
+      }
+   }
+
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Mode bandwidth is %d Mpixel/s\n",
+	      pMode->HDisplay * pMode->VDisplay * refresh / 1000000);
+
+   {
+      int maxBandwidth, bandwidthA, bandwidthB;
+
+      if (GetModeSupport(pScrn, 0x80, 0x80, 0x80, 0x80,
+			&maxBandwidth, &bandwidthA, &bandwidthB)) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "maxBandwidth is %d Mbyte/s, "
+		    "pipe bandwidths are %d Mbyte/s, %d Mbyte/s\n",
+		    maxBandwidth, bandwidthA, bandwidthB);
+      }
+   }
+
+   {
+      int ret;
+
+      ret = GetLFPCompMode(pScrn);
+      if (ret != -1) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "LFP compensation mode: 0x%x\n", ret);
+      }
+   }
+
+#if MODESWITCH_RESET_STATE
+   ResetState(pScrn, TRUE);
+   SetHWOperatingState(pScrn);
+#endif
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled && didLock) {
+      DRIUnlock(screenInfo.screens[pScrn->scrnIndex]);
+      pI830->LockHeld = 0;
+   }
+#endif
+
+   pScrn->vtSema = TRUE;
+   return TRUE;
+}
+
+static void
+InitRegisterRec(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   I830RegPtr i830Reg = &pI830->ModeReg;
+   int i;
+
+   for (i = 0; i < 8; i++)
+      i830Reg->Fence[i] = 0;
+}
+
+/* Famous last words
+ */
+void
+I830PrintErrorState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   ErrorF("pgetbl_ctl: 0x%lx pgetbl_err: 0x%lx\n",
+	  INREG(PGETBL_CTL), INREG(PGE_ERR));
+
+   ErrorF("ipeir: %lx iphdr: %lx\n", INREG(IPEIR), INREG(IPEHR));
+
+   ErrorF("LP ring tail: %lx head: %lx len: %lx start %lx\n",
+	  INREG(LP_RING + RING_TAIL),
+	  INREG(LP_RING + RING_HEAD) & HEAD_ADDR,
+	  INREG(LP_RING + RING_LEN), INREG(LP_RING + RING_START));
+
+   ErrorF("eir: %x esr: %x emr: %x\n",
+	  INREG16(EIR), INREG16(ESR), INREG16(EMR));
+
+   ErrorF("instdone: %x instpm: %x\n", INREG16(INST_DONE), INREG8(INST_PM));
+
+   ErrorF("memmode: %lx instps: %lx\n", INREG(MEMMODE), INREG(INST_PS));
+
+   ErrorF("hwstam: %x ier: %x imr: %x iir: %x\n",
+	  INREG16(HWSTAM), INREG16(IER), INREG16(IMR), INREG16(IIR));
+}
+
+#ifdef I830DEBUG
+static void
+dump_DSPACNTR(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned int tmp;
+
+   /* Display A Control */
+   tmp = INREG(0x70180);
+   ErrorF("Display A Plane Control Register (0x%.8x)\n", tmp);
+
+   if (tmp & BIT(31))
+      ErrorF("   Display Plane A (Primary) Enable\n");
+   else
+      ErrorF("   Display Plane A (Primary) Disabled\n");
+
+   if (tmp & BIT(30))
+      ErrorF("   Display A pixel data is gamma corrected\n");
+   else
+      ErrorF("   Display A pixel data bypasses gamma correction logic (default)\n");
+
+   switch ((tmp & 0x3c000000) >> 26) {	/* bit 29:26 */
+   case 0x00:
+   case 0x01:
+   case 0x03:
+      ErrorF("   Reserved\n");
+      break;
+   case 0x02:
+      ErrorF("   8-bpp Indexed\n");
+      break;
+   case 0x04:
+      ErrorF("   15-bit (5-5-5) pixel format (Targa compatible)\n");
+      break;
+   case 0x05:
+      ErrorF("   16-bit (5-6-5) pixel format (XGA compatible)\n");
+      break;
+   case 0x06:
+      ErrorF("   32-bit format (X:8:8:8)\n");
+      break;
+   case 0x07:
+      ErrorF("   32-bit format (8:8:8:8)\n");
+      break;
+   default:
+      ErrorF("   Unknown - Invalid register value maybe?\n");
+   }
+
+   if (tmp & BIT(25))
+      ErrorF("   Stereo Enable\n");
+   else
+      ErrorF("   Stereo Disable\n");
+
+   if (tmp & BIT(24))
+      ErrorF("   Display A, Pipe B Select\n");
+   else
+      ErrorF("   Display A, Pipe A Select\n");
+
+   if (tmp & BIT(22))
+      ErrorF("   Source key is enabled\n");
+   else
+      ErrorF("   Source key is disabled\n");
+
+   switch ((tmp & 0x00300000) >> 20) {	/* bit 21:20 */
+   case 0x00:
+      ErrorF("   No line duplication\n");
+      break;
+   case 0x01:
+      ErrorF("   Line/pixel Doubling\n");
+      break;
+   case 0x02:
+   case 0x03:
+      ErrorF("   Reserved\n");
+      break;
+   }
+
+   if (tmp & BIT(18))
+      ErrorF("   Stereo output is high during second image\n");
+   else
+      ErrorF("   Stereo output is high during first image\n");
+}
+
+static void
+dump_DSPBCNTR(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned int tmp;
+
+   /* Display B/Sprite Control */
+   tmp = INREG(0x71180);
+   ErrorF("Display B/Sprite Plane Control Register (0x%.8x)\n", tmp);
+
+   if (tmp & BIT(31))
+      ErrorF("   Display B/Sprite Enable\n");
+   else
+      ErrorF("   Display B/Sprite Disable\n");
+
+   if (tmp & BIT(30))
+      ErrorF("   Display B pixel data is gamma corrected\n");
+   else
+      ErrorF("   Display B pixel data bypasses gamma correction logic (default)\n");
+
+   switch ((tmp & 0x3c000000) >> 26) {	/* bit 29:26 */
+   case 0x00:
+   case 0x01:
+   case 0x03:
+      ErrorF("   Reserved\n");
+      break;
+   case 0x02:
+      ErrorF("   8-bpp Indexed\n");
+      break;
+   case 0x04:
+      ErrorF("   15-bit (5-5-5) pixel format (Targa compatible)\n");
+      break;
+   case 0x05:
+      ErrorF("   16-bit (5-6-5) pixel format (XGA compatible)\n");
+      break;
+   case 0x06:
+      ErrorF("   32-bit format (X:8:8:8)\n");
+      break;
+   case 0x07:
+      ErrorF("   32-bit format (8:8:8:8)\n");
+      break;
+   default:
+      ErrorF("   Unknown - Invalid register value maybe?\n");
+   }
+
+   if (tmp & BIT(25))
+      ErrorF("   Stereo is enabled and both start addresses are used in a two frame sequence\n");
+   else
+      ErrorF("   Stereo disable and only a single start address is used\n");
+
+   if (tmp & BIT(24))
+      ErrorF("   Display B/Sprite, Pipe B Select\n");
+   else
+      ErrorF("   Display B/Sprite, Pipe A Select\n");
+
+   if (tmp & BIT(22))
+      ErrorF("   Sprite source key is enabled\n");
+   else
+      ErrorF("   Sprite source key is disabled (default)\n");
+
+   switch ((tmp & 0x00300000) >> 20) {	/* bit 21:20 */
+   case 0x00:
+      ErrorF("   No line duplication\n");
+      break;
+   case 0x01:
+      ErrorF("   Line/pixel Doubling\n");
+      break;
+   case 0x02:
+   case 0x03:
+      ErrorF("   Reserved\n");
+      break;
+   }
+
+   if (tmp & BIT(18))
+      ErrorF("   Stereo output is high during second image\n");
+   else
+      ErrorF("   Stereo output is high during first image\n");
+
+   if (tmp & BIT(15))
+      ErrorF("   Alpha transfer mode enabled\n");
+   else
+      ErrorF("   Alpha transfer mode disabled\n");
+
+   if (tmp & BIT(0))
+      ErrorF("   Sprite is above overlay\n");
+   else
+      ErrorF("   Sprite is above display A (default)\n");
+}
+
+void
+I830_dump_registers(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned int i;
+
+   ErrorF("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
+
+   dump_DSPACNTR(pScrn);
+   dump_DSPBCNTR(pScrn);
+
+   ErrorF("0x71400 == 0x%.8x\n", INREG(0x71400));
+   ErrorF("0x70008 == 0x%.8x\n", INREG(0x70008));
+   for (i = 0x71410; i <= 0x71428; i += 4)
+      ErrorF("0x%x == 0x%.8x\n", i, INREG(i));
+
+   ErrorF("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
+}
+#endif
+
+static Bool
+I830BIOSScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
+{
+   ScrnInfoPtr pScrn;
+   vgaHWPtr hwp;
+   I830Ptr pI830;
+   VisualPtr visual;
+#ifdef XF86DRI
+   Bool driDisabled;
+#endif
+
+   pScrn = xf86Screens[pScreen->myNum];
+   pI830 = I830PTR(pScrn);
+   hwp = VGAHWPTR(pScrn);
+
+   pI830->starting = TRUE;
+
+   /*
+    * If we're changing the BIOS's view of the video memory size, do that
+    * first, then re-initialise the VBE information.
+    */
+   pI830->pVbe = VBEInit(NULL, pI830->pEnt->index);
+   SetBIOSMemSize(pScrn, pI830->newBIOSMemSize);
+   if (!pI830->pVbe)
+      return FALSE;
+   pI830->vbeInfo = VBEGetVBEInfo(pI830->pVbe);
+
+   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;
+
+#ifdef I830_XV
+   pI830->XvEnabled = !pI830->XvDisabled;
+   if (pI830->XvEnabled) {
+      if (pI830->noAccel || pI830->StolenOnly) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "Xv is disabled because it "
+		    "needs 2D accel and AGPGART.\n");
+	 pI830->XvEnabled = FALSE;
+      }
+   }
+#else
+   pI830->XvEnabled = FALSE;
+#endif
+
+   I830ResetAllocations(pScrn, 0);
+
+   I830Allocate2DMemory(pScrn, ALLOC_INITIAL);
+
+   if (!pI830->noAccel) {
+      if (pI830->LpRing.mem.Size == 0) {
+	  xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		     "Disabling acceleration because the ring buffer "
+		      "allocation failed.\n");
+	   pI830->noAccel = TRUE;
+      }
+   }
+
+   if (!pI830->SWCursor) {
+      if (pI830->CursorMem.Size == 0) {
+	  xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		     "Disabling HW cursor because the cursor memory "
+		      "allocation failed.\n");
+	   pI830->SWCursor = TRUE;
+      }
+   }
+
+#ifdef I830_XV
+   if (pI830->XvEnabled) {
+      if (pI830->noAccel) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Disabling Xv because it "
+		    "needs 2D acceleration.\n");
+	 pI830->XvEnabled = FALSE;
+      }
+      if (pI830->OverlayMem.Physical == 0) {
+	  xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
+		     "Disabling Xv because the overlay register buffer "
+		      "allocation failed.\n");
+	 pI830->XvEnabled = FALSE;
+      }
+   }
+#endif
+
+   InitRegisterRec(pScrn);
+
+#ifdef XF86DRI
+   /*
+    * pI830->directRenderingDisabled is set once in PreInit.  Reinitialise
+    * pI830->directRenderingEnabled based on it each generation.
+    */
+   pI830->directRenderingEnabled = !pI830->directRenderingDisabled;
+   /*
+    * Setup DRI after visuals have been established, but before fbScreenInit
+    * is called.   fbScreenInit will eventually call into the drivers
+    * InitGLXVisuals call back.
+    */
+
+   if (pI830->directRenderingEnabled) {
+      if (pI830->noAccel || pI830->SWCursor || pI830->StolenOnly) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_PROBED, "DRI is disabled because it "
+		    "needs HW cursor, 2D accel and AGPGART.\n");
+	 pI830->directRenderingEnabled = FALSE;
+      }
+   }
+
+   driDisabled = !pI830->directRenderingEnabled;
+
+   if (pI830->directRenderingEnabled)
+      pI830->directRenderingEnabled = I830DRIScreenInit(pScreen);
+
+   if (pI830->directRenderingEnabled)
+      if (!(pI830->directRenderingEnabled = I830Allocate3DMemory(pScrn, 0)))
+	  I830DRICloseScreen(pScreen);
+
+#else
+   pI830->directRenderingEnabled = FALSE;
+#endif
+
+   /*
+    * After the 3D allocations have been done, see if there's any free space
+    * that can be added to the framebuffer allocation.
+    */
+   I830Allocate2DMemory(pScrn, 0);
+
+   DPRINTF(PFX, "assert(if(!I830DoPoolAllocation(pScrn, pI830->StolenPool)))\n");
+   if (!I830DoPoolAllocation(pScrn, &(pI830->StolenPool)))
+      return FALSE;
+
+   DPRINTF(PFX, "assert( if(!I830FixupOffsets(pScrn)) )\n");
+   if (!I830FixupOffsets(pScrn))
+      return FALSE;
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled) {
+      I830SetupMemoryTiling(pScrn);
+      pI830->directRenderingEnabled = I830DRIDoMappings(pScreen);
+   }
+#endif
+
+   DPRINTF(PFX, "assert( if(!I830MapMem(pScrn)) )\n");
+   if (!I830MapMem(pScrn))
+      return FALSE;
+
+   pScrn->memPhysBase = (unsigned long)pI830->FbBase;
+   pScrn->fbOffset = pI830->FrontBuffer.Start;
+
+   vgaHWSetMmioFuncs(hwp, pI830->MMIOBase, 0);
+   vgaHWGetIOBase(hwp);
+   DPRINTF(PFX, "assert( if(!vgaHWMapMem(pScrn)) )\n");
+   if (!vgaHWMapMem(pScrn))
+      return FALSE;
+
+   /* Clear SavedReg */
+   memset(&pI830->SavedReg, 0, sizeof(pI830->SavedReg));
+
+   DPRINTF(PFX, "assert( if(!I830BIOSEnterVT(scrnIndex, 0)) )\n");
+   if (!I830BIOSEnterVT(scrnIndex, 0))
+      return FALSE;
+
+   DPRINTF(PFX, "assert( if(!fbScreenInit(pScreen, ...) )\n");
+   if (!fbScreenInit(pScreen, pI830->FbBase + pScrn->fbOffset,
+		     pScrn->virtualX, pScrn->virtualY,
+		     pScrn->xDpi, pScrn->yDpi,
+		     pScrn->displayWidth, pScrn->bitsPerPixel))
+      return FALSE;
+
+   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;
+	 }
+      }
+   }
+
+   fbPictureInit(pScreen, 0, 0);
+
+   xf86SetBlackWhitePixels(pScreen);
+
+#if 1
+   I830DGAInit(pScreen);
+#endif
+
+   DPRINTF(PFX,
+	   "assert( if(!xf86InitFBManager(pScreen, &(pI830->FbMemBox))) )\n");
+   if (!xf86InitFBManager(pScreen, &(pI830->FbMemBox))) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "Failed to init memory manager\n");
+      return FALSE;
+   }
+
+   if (!pI830->noAccel) {
+      if (!I830AccelInit(pScreen)) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Hardware acceleration initialization failed\n");
+      }
+   }
+
+   miInitializeBackingStore(pScreen);
+   xf86SetBackingStore(pScreen);
+   xf86SetSilkenMouse(pScreen);
+   miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
+
+   if (!pI830->SWCursor) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing HW Cursor\n");
+      if (!I830CursorInit(pScreen))
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Hardware cursor initialization failed\n");
+   } else
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Initializing SW Cursor!\n");
+
+   DPRINTF(PFX, "assert( if(!miCreateDefColormap(pScreen)) )\n");
+   if (!miCreateDefColormap(pScreen))
+      return FALSE;
+
+   DPRINTF(PFX, "assert( if(!xf86HandleColormaps(pScreen, ...)) )\n");
+   if (!xf86HandleColormaps(pScreen, 256, 8, I830LoadPalette, 0,
+			    CMAP_RELOAD_ON_MODE_SWITCH)) {
+      return FALSE;
+   }
+
+#ifdef DPMSExtension
+   xf86DPMSInit(pScreen, I830DisplayPowerManagementSet, 0);
+#endif
+
+#ifdef I830_XV
+   /* Init video */
+   if (pI830->XvEnabled)
+      I830InitVideo(pScreen);
+#endif
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled) {
+      pI830->directRenderingEnabled = I830DRIFinishScreenInit(pScreen);
+   }
+#endif
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled) {
+      pI830->directRenderingOpen = TRUE;
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "direct rendering: Enabled\n");
+      /* Setup 3D engine */
+      I830EmitInvarientState(pScrn);
+   } else {
+      if (driDisabled)
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "direct rendering: Disabled\n");
+      else
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "direct rendering: Failed\n");
+   }
+#else
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "direct rendering: Not available\n");
+#endif
+
+   pScreen->SaveScreen = I830BIOSSaveScreen;
+   pI830->CloseScreen = pScreen->CloseScreen;
+   pScreen->CloseScreen = I830BIOSCloseScreen;
+
+   if (serverGeneration == 1)
+      xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);
+#if 0
+#ifdef I830DEBUG
+   I830_dump_registers(pScrn);
+#endif
+#endif
+
+   pI830->starting = FALSE;
+   pI830->closing = FALSE;
+   pI830->suspended = FALSE;
+   return TRUE;
+}
+
+static void
+I830BIOSAdjustFrame(int scrnIndex, int x, int y, int flags)
+{
+   ScrnInfoPtr pScrn;
+   I830Ptr pI830;
+   vbeInfoPtr pVbe;
+   static int xoffset = 0, yoffset = 0;
+   static int adjustGeneration = -1;
+
+   pScrn = xf86Screens[scrnIndex];
+   pI830 = I830PTR(pScrn);
+   pVbe = pI830->pVbe;
+
+   DPRINTF(PFX, "I830BIOSAdjustFrame: y = %d (+ %d), x = %d (+ %d)\n",
+	   x, xoffset, y, yoffset);
+
+   /* Calculate the offsets once per server generation. */
+   if (adjustGeneration != serverGeneration) {
+      adjustGeneration = serverGeneration;
+      xoffset = (pScrn->fbOffset / pI830->cpp) % pScrn->displayWidth;
+      yoffset = (pScrn->fbOffset / pI830->cpp) / pScrn->displayWidth;
+   }
+
+   if (OffsetFrame) {
+      y = (pI830->FbMemBox.y2 - pScrn->currentMode->VDisplay);
+      ErrorF("AdjustFrame: OffsetFrame is set, setting y to %d\n", y);
+   }
+   x += xoffset;
+   y += yoffset;
+#if 0
+   x >>= 4;
+   x <<= 4;
+#endif
+   VBESetDisplayStart(pVbe, x, y, TRUE);
+}
+
+static void
+I830BIOSFreeScreen(int scrnIndex, int flags)
+{
+   I830BIOSFreeRec(xf86Screens[scrnIndex]);
+   if (xf86LoaderCheckSymbol("vgaHWFreeHWRec"))
+      vgaHWFreeHWRec(xf86Screens[scrnIndex]);
+}
+
+#ifndef SAVERESTORE_HWSTATE
+#define SAVERESTORE_HWSTATE 0
+#endif
+
+#if SAVERESTORE_HWSTATE
+static void
+SaveHWOperatingState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   I830RegPtr save = &pI830->SavedReg;
+
+   DPRINTF(PFX, "SaveHWOperatingState\n");
+
+   return;
+}
+
+static void
+RestoreHWOperatingState(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   I830RegPtr save = &pI830->SavedReg;
+
+   DPRINTF(PFX, "RestoreHWOperatingState\n");
+
+   return;
+}
+#endif
+
+static void
+I830BIOSLeaveVT(int scrnIndex, int flags)
+{
+   ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+#ifdef XF86DRI
+   I830Ptr pI830 = I830PTR(pScrn);
+#endif
+
+   DPRINTF(PFX, "Leave VT\n");
+
+#ifdef XF86DRI
+   if (pI830->directRenderingOpen) {
+      DPRINTF(PFX, "calling dri lock\n");
+      DRILock(screenInfo.screens[scrnIndex], 0);
+      pI830->LockHeld = 1;
+   }
+#endif
+
+#if SAVERESTORE_HWSTATE
+   if (!pI830->closing)
+      SaveHWOperatingState(pScrn);
+#endif
+
+   ResetState(pScrn, TRUE);
+   RestoreHWState(pScrn);
+   RestoreBIOSMemSize(pScrn);
+   I830UnbindGARTMemory(pScrn);
+}
+
+/*
+ * This gets called when gaining control of the VT, and from ScreenInit().
+ */
+static Bool
+I830BIOSEnterVT(int scrnIndex, int flags)
+{
+   ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+   I830Ptr pI830 = I830PTR(pScrn);
+   static int SaveGeneration = -1;
+
+   DPRINTF(PFX, "Enter VT\n");
+
+   if (!I830BindGARTMemory(pScrn))
+      return FALSE;
+
+   CheckInheritedState(pScrn);
+   SetBIOSMemSize(pScrn, pI830->newBIOSMemSize);
+
+   /*
+    * Only save state once per server generation since that's what most
+    * drivers do.  Could change this to save state at each VT enter.
+    */
+   if (SaveGeneration != serverGeneration) {
+      SaveGeneration = serverGeneration;
+      SaveHWState(pScrn);
+   }
+   ResetState(pScrn, FALSE);
+   SetHWOperatingState(pScrn);
+
+#if 1
+   /* Clear the framebuffer */
+   memset(pI830->FbBase + pScrn->fbOffset, 0,
+	  pScrn->virtualY * pScrn->displayWidth * pI830->cpp);
+#endif
+
+   if (!I830VESASetMode(pScrn, pScrn->currentMode))
+      return FALSE;
+#ifdef I830_XV
+   I830VideoSwitchModeAfter(pScrn, pScrn->currentMode);
+#endif
+
+   ResetState(pScrn, TRUE);
+   SetHWOperatingState(pScrn);
+
+   pScrn->AdjustFrame(scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
+
+#if SAVERESTORE_HWSTATE
+   RestoreHWOperatingState(pScrn);
+#endif
+
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled) {
+      if (!pI830->starting) {
+	 I830EmitInvarientState(pScrn);
+	 I830RefreshRing(pScrn);
+	 I830Sync(pScrn);
+	 DO_RING_IDLE();
+
+	 DPRINTF(PFX, "calling dri unlock\n");
+	 DRIUnlock(screenInfo.screens[scrnIndex]);
+      }
+      pI830->LockHeld = 0;
+   }
+#endif
+
+   return TRUE;
+}
+
+static Bool
+I830BIOSSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
+{
+
+   int _head;
+   int _tail;
+   ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+   I830Ptr pI830 = I830PTR(pScrn);
+   int ret = TRUE;
+
+   DPRINTF(PFX, "I830BIOSSwitchMode: mode == %p\n", mode);
+
+   /* Stops head pointer freezes for 845G */
+   if (!pI830->noAccel && (1 || IS_845G(pI830))) {
+      do {
+	 _head = INREG(LP_RING + RING_HEAD) & I830_HEAD_MASK;
+	 _tail = INREG(LP_RING + RING_TAIL) & I830_TAIL_MASK;
+	 DELAY(1000);
+      } while (_head != _tail);
+   }
+
+#if 0
+   OffsetFrame = !OffsetFrame;
+   pScrn->AdjustFrame(scrnIndex, 0, 0, 0);
+#endif
+
+#ifndef BINDUNBIND
+#define BINDUNBIND 0
+#endif
+#if BINDUNBIND
+   I830UnbindGARTMemory(pScrn);
+#endif
+#ifdef I830_XV
+   /* Give the video overlay code a chance to see the new mode. */
+   I830VideoSwitchModeBefore(pScrn, mode);
+#endif
+   if (!I830VESASetMode(pScrn, mode))
+      ret = FALSE;
+#ifdef I830_XV
+   /* Give the video overlay code a chance to see the new mode. */
+   I830VideoSwitchModeAfter(pScrn, mode);
+#endif
+#if BINDUNBIND
+   I830BindGARTMemory(pScrn);
+#endif
+
+   return ret;
+}
+
+static Bool
+I830BIOSSaveScreen(ScreenPtr pScreen, int mode)
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   I830Ptr pI830 = I830PTR(pScrn);
+   Bool on = xf86IsUnblank(mode);
+   CARD32 temp, ctrl, base, i;
+
+   DPRINTF(PFX, "I830BIOSSaveScreen: %d, on is %s\n", mode, BOOLTOSTRING(on));
+
+   for (i = 0; i < MAX_DISPLAY_PIPES; i++) {
+      if (i == 0) {
+	 ctrl = DSPACNTR;
+	 base = DSPABASE;
+      } else {
+	 ctrl = DSPBCNTR;
+	 base = DSPBADDR;
+      }
+      if (pI830->planeEnabled[i]) {
+	 temp = INREG(ctrl);
+	 if (on)
+	    temp |= DISPLAY_PLANE_ENABLE;
+	 else
+	    temp &= ~DISPLAY_PLANE_ENABLE;
+	 OUTREG(ctrl, temp);
+	 /* Flush changes */
+	 temp = INREG(base);
+	 OUTREG(base, temp);
+      }
+   }
+
+   if (pI830->CursorInfoRec && !pI830->SWCursor && pI830->cursorOn) {
+      if (on)
+	 pI830->CursorInfoRec->ShowCursor(pScrn);
+      else
+	 pI830->CursorInfoRec->HideCursor(pScrn);
+      pI830->cursorOn = TRUE;
+   }
+
+   return TRUE;
+}
+
+/* Use the VBE version when available. */
+static void
+I830DisplayPowerManagementSet(ScrnInfoPtr pScrn, int PowerManagementMode,
+			      int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   vbeInfoPtr pVbe = pI830->pVbe;
+
+   if (xf86LoaderCheckSymbol("VBEDPMSSet")) {
+      VBEDPMSSet(pVbe, PowerManagementMode);
+   } else {
+      pVbe->pInt10->num = 0x10;
+      pVbe->pInt10->ax = 0x4f10;
+      pVbe->pInt10->bx = 0x01;
+
+      switch (PowerManagementMode) {
+      case DPMSModeOn:
+	 break;
+      case DPMSModeStandby:
+	 pVbe->pInt10->bx |= 0x0100;
+	 break;
+      case DPMSModeSuspend:
+	 pVbe->pInt10->bx |= 0x0200;
+	 break;
+      case DPMSModeOff:
+	 pVbe->pInt10->bx |= 0x0400;
+	 break;
+      }
+      xf86ExecX86int10_wrapper(pVbe->pInt10, pScrn);
+   }
+}
+
+static Bool
+I830BIOSCloseScreen(int scrnIndex, ScreenPtr pScreen)
+{
+   ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+   I830Ptr pI830 = I830PTR(pScrn);
+   XAAInfoRecPtr infoPtr = pI830->AccelInfoRec;
+
+   pI830->closing = TRUE;
+#ifdef XF86DRI
+   if (pI830->directRenderingOpen) {
+      pI830->directRenderingOpen = FALSE;
+      I830DRICloseScreen(pScreen);
+   }
+#endif
+
+   if (pScrn->vtSema == TRUE) {
+      I830BIOSLeaveVT(scrnIndex, 0);
+   }
+
+   DPRINTF(PFX, "\nUnmapping memory\n");
+   I830UnmapMem(pScrn);
+   vgaHWUnmapMem(pScrn);
+
+   if (pI830->ScanlineColorExpandBuffers) {
+      xfree(pI830->ScanlineColorExpandBuffers);
+      pI830->ScanlineColorExpandBuffers = 0;
+   }
+
+   if (infoPtr) {
+      if (infoPtr->ScanlineColorExpandBuffers)
+	 xfree(infoPtr->ScanlineColorExpandBuffers);
+      XAADestroyInfoRec(infoPtr);
+      pI830->AccelInfoRec = NULL;
+   }
+
+   if (pI830->CursorInfoRec) {
+      xf86DestroyCursorInfoRec(pI830->CursorInfoRec);
+      pI830->CursorInfoRec = 0;
+   }
+
+   xf86GARTCloseScreen(scrnIndex);
+
+   pScrn->vtSema = FALSE;
+   pI830->closing = FALSE;
+   pScreen->CloseScreen = pI830->CloseScreen;
+   return (*pScreen->CloseScreen) (scrnIndex, pScreen);
+}
+
+static int
+I830ValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
+{
+   if (mode->Flags & V_INTERLACE) {
+      if (verbose) {
+	 xf86DrvMsg(scrnIndex, X_PROBED,
+		    "Removing interlaced mode \"%s\"\n", mode->name);
+      }
+      return MODE_BAD;
+   }
+   return MODE_OK;
+}
+
+#ifndef SUSPEND_SLEEP
+#define SUSPEND_SLEEP 0
+#endif
+#ifndef RESUME_SLEEP
+#define RESUME_SLEEP 0
+#endif
+
+/*
+ * This function is only required if we need to do anything differently from
+ * DoApmEvent() in common/xf86PM.c, including if we want to see events other
+ * than suspend/resume.
+ */
+static Bool
+I830PMEvent(int scrnIndex, pmEvent event, Bool undo)
+{
+   ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "Enter VT, event %d, undo: %s\n", event, BOOLTOSTRING(undo));
+
+   switch(event) {
+   case XF86_APM_SYS_SUSPEND:
+   case XF86_APM_CRITICAL_SUSPEND: /*do we want to delay a critical suspend?*/
+   case XF86_APM_USER_SUSPEND:
+   case XF86_APM_SYS_STANDBY:
+   case XF86_APM_USER_STANDBY:
+      if (!undo && !pI830->suspended) {
+	 pScrn->LeaveVT(scrnIndex, 0);
+	 pI830->suspended = TRUE;
+	 sleep(SUSPEND_SLEEP);
+      } else if (undo && pI830->suspended) {
+	 sleep(RESUME_SLEEP);
+	 pScrn->EnterVT(scrnIndex, 0);
+	 pI830->suspended = FALSE;
+      }
+      break;
+   case XF86_APM_STANDBY_RESUME:
+   case XF86_APM_NORMAL_RESUME:
+   case XF86_APM_CRITICAL_RESUME:
+      if (pI830->suspended) {
+	 sleep(RESUME_SLEEP);
+	 pScrn->EnterVT(scrnIndex, 0);
+	 pI830->suspended = FALSE;
+	 /*
+	  * Turn the screen saver off when resuming.  This seems to be
+	  * needed to stop xscreensaver kicking in (when used).
+	  *
+	  * XXX DoApmEvent() should probably call this just like
+	  * xf86VTSwitch() does.  Maybe do it here only in 4.2
+	  * compatibility mode.
+	  */
+	 SaveScreens(SCREEN_SAVER_FORCER, ScreenSaverReset);
+      }
+      break;
+   default:
+      ErrorF("I830PMEvent: received APM event %d\n", event);
+   }
+   return TRUE;
+}
+
+void
+I830InitpScrn(ScrnInfoPtr pScrn)
+{
+   pScrn->PreInit = I830BIOSPreInit;
+   pScrn->ScreenInit = I830BIOSScreenInit;
+   pScrn->SwitchMode = I830BIOSSwitchMode;
+   pScrn->AdjustFrame = I830BIOSAdjustFrame;
+   pScrn->EnterVT = I830BIOSEnterVT;
+   pScrn->LeaveVT = I830BIOSLeaveVT;
+   pScrn->FreeScreen = I830BIOSFreeScreen;
+   pScrn->ValidMode = I830ValidMode;
+   pScrn->PMEvent = I830PMEvent;
+}