Initial revisionXORG-STABLE

1 files changed, 1458 insertions, 0 deletions

diff --git a/src/i830_memory.c b/src/i830_memory.c
new file mode 100644
index 00000000..16693d4a
--- /dev/null
+++ b/src/i830_memory.c
@@ -0,0 +1,1458 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/i810/i830_memory.c,v 1.6 2003/02/08 02:26:56 dawes Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 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:
+ *   Keith Whitwell <keith@tungstengraphics.com>
+ *   David Dawes <dawes@tungstengraphics.com>
+ *
+ */
+
+#include "xf86.h"
+#include "xf86_ansic.h"
+#include "xf86_OSproc.h"
+
+#include "i830.h"
+#include "i810_reg.h"
+
+/*
+ * Allocate memory from the given pool.  Grow the pool if needed and if
+ * possible.
+ */
+static unsigned long
+AllocFromPool(ScrnInfoPtr pScrn, I830MemRange *result, I830MemPool *pool,
+	      unsigned long size, unsigned long alignment, int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long needed, start, end;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+
+   if (!result || !pool || !size)
+      return 0;
+
+   /* Calculate how much space is needed. */
+   if (alignment <= GTT_PAGE_SIZE)
+      needed = size;
+   else {
+      if (flags & ALLOCATE_AT_BOTTOM) {
+	 start = ROUND_TO(pool->Free.Start, alignment);
+	 if (flags & ALIGN_BOTH_ENDS)
+	    end = ROUND_TO(start + size, alignment);
+	 else
+	    end = start + size;
+	 needed = end - pool->Free.Start;
+      } else {				/* allocate at top */
+	 if (flags & ALIGN_BOTH_ENDS)
+	    end = ROUND_DOWN_TO(pool->Free.End, alignment);
+	 else
+	    end = pool->Free.End;
+
+	 start = ROUND_DOWN_TO(end - size, alignment);
+	 needed = pool->Free.End - start;
+      }
+   }
+   if (needed > pool->Free.Size) {
+      unsigned long extra;
+      /* See if the pool can be grown. */
+      if (pI830->StolenOnly && !dryrun)
+	 return 0;
+      extra = needed - pool->Free.Size;
+      extra = ROUND_TO_PAGE(extra);
+      if (extra > pI830->FreeMemory) {
+	 if (dryrun)
+	    pI830->FreeMemory = extra;
+	 else
+	    return 0;
+      }
+
+      if (!dryrun && (extra > pI830->MemoryAperture.Size))
+	 return 0;
+
+      pool->Free.Size += extra;
+      pool->Free.End += extra;
+      pool->Total.Size += extra;
+      pool->Total.End += extra;
+      pI830->FreeMemory -= extra;
+      pI830->MemoryAperture.Start += extra;
+      pI830->MemoryAperture.Size -= extra;
+   }
+   if (flags & ALLOCATE_AT_BOTTOM) {
+      result->Start = ROUND_TO(pool->Free.Start, alignment);
+      pool->Free.Start += needed;
+      result->End = pool->Free.Start;
+   } else {
+      result->Start = ROUND_DOWN_TO(pool->Free.End - size, alignment) -
+			pool->Total.End;
+      result->End = pool->Free.End - pool->Total.End;
+      pool->Free.End -= needed;
+   }
+   pool->Free.Size = pool->Free.End - pool->Free.Start;
+   result->Size = result->End - result->Start;
+   result->Pool = pool;
+   result->Alignment = alignment;
+   return needed;
+}
+
+static unsigned long
+AllocFromAGP(ScrnInfoPtr pScrn, I830MemRange *result, unsigned long size,
+	     unsigned long alignment, int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long start, end;
+   unsigned long newApStart, newApEnd;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+
+   if (!result || !size)
+      return 0;
+
+   if ((flags & ALLOCATE_AT_BOTTOM) && pI830->StolenMemory.Size != 0) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "AllocFromAGP(): can't allocate from "
+		 "bottom when there is stolen memory\n");
+      return 0;
+   }
+
+   if (size > pI830->FreeMemory) {
+      if (dryrun)
+	 pI830->FreeMemory = size;
+      else
+	 return 0;
+   }
+
+   /* Calculate offset */
+   if (flags & ALLOCATE_AT_BOTTOM) {
+      start = ROUND_TO(pI830->MemoryAperture.Start, alignment);
+      if (flags & ALIGN_BOTH_ENDS)
+	 end = ROUND_TO(start + size, alignment);
+      else
+	 end = start + size;
+      newApStart = end;
+      newApEnd = pI830->MemoryAperture.End;
+   } else {
+      if (flags & ALIGN_BOTH_ENDS)
+	 end = ROUND_DOWN_TO(pI830->MemoryAperture.End, alignment);
+      else
+	 end = pI830->MemoryAperture.End;
+      start = ROUND_DOWN_TO(end - size, alignment);
+      newApStart = pI830->MemoryAperture.Start;
+      newApEnd = start;
+   }
+
+   if (!dryrun) {
+      if (newApStart > newApEnd)
+	 return 0;
+
+      if (flags & NEED_PHYSICAL_ADDR) {
+	 result->Key = xf86AllocateGARTMemory(pScrn->scrnIndex, size, 2,
+					      &(result->Physical));
+      } else {
+	 result->Key = xf86AllocateGARTMemory(pScrn->scrnIndex, size, 0, NULL);
+      }
+      if (result->Key == -1)
+	 return 0;
+   }
+
+   pI830->allocatedMemory += size;
+   pI830->MemoryAperture.Start = newApStart;
+   pI830->MemoryAperture.End = newApEnd;
+   pI830->MemoryAperture.Size = newApEnd - newApStart;
+   pI830->FreeMemory -= size;
+   result->Start = start;
+   result->End = start + size;
+   result->Size = size;
+   result->Offset = start;
+   result->Alignment = alignment;
+   result->Pool = NULL;
+
+   return size;
+}
+
+
+unsigned long
+I830AllocVidMem(ScrnInfoPtr pScrn, I830MemRange *result, I830MemPool *pool,
+		unsigned long size, unsigned long alignment, int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+
+   if (!result)
+      return 0;
+
+   /* Make sure these are initialised. */
+   result->Size = 0;
+   result->Key = -1;
+
+   if (!size) {
+      return 0;
+   }
+
+   switch (flags & FROM_MASK) {
+   case FROM_POOL_ONLY:
+      return AllocFromPool(pScrn, result, pool, size, alignment, flags);
+   case FROM_NEW_ONLY:
+      if (!dryrun && (pI830->StolenOnly || (pI830->FreeMemory <= 0)))
+	 return 0;
+      return AllocFromAGP(pScrn, result, size, alignment, flags);
+   case FROM_ANYWHERE:
+      if ((!(flags & ALLOCATE_AT_BOTTOM) && (pI830->FreeMemory >= size)) ||
+	  (flags & NEED_PHYSICAL_ADDR))
+	 return AllocFromAGP(pScrn, result, size, alignment, flags);
+      else
+	 return AllocFromPool(pScrn, result, pool, size, alignment, flags);
+   default:
+      /* Shouldn't happen. */
+      return 0;
+   }
+}
+
+static Bool
+AllocateRingBuffer(ScrnInfoPtr pScrn, int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long size, alloced;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+   int verbosity = dryrun ? 4 : 1;
+   const char *s = dryrun ? "[dryrun] " : "";
+
+   /* Clear ring buffer  info */
+   memset(&(pI830->LpRing), 0, sizeof(pI830->LpRing));
+   pI830->LpRing.mem.Key = -1;
+
+   if (pI830->noAccel)
+      return TRUE;
+
+   /* Ring buffer */
+   size = PRIMARY_RINGBUFFER_SIZE;
+   if (flags & FORCE_LOW)
+      flags |= FROM_POOL_ONLY | ALLOCATE_AT_BOTTOM;
+   else
+      flags |= FROM_ANYWHERE | ALLOCATE_AT_TOP;
+
+   alloced = I830AllocVidMem(pScrn, &(pI830->LpRing.mem),
+				&(pI830->StolenPool), size,
+				GTT_PAGE_SIZE, flags);
+   if (alloced < size) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Failed to allocate Ring Buffer space\n");
+      }
+      return FALSE;
+   }
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		  "%sAllocated %d kB for the ring buffer at 0x%x\n", s,
+		  alloced / 1024, pI830->LpRing.mem.Start);
+   pI830->LpRing.tail_mask = pI830->LpRing.mem.Size - 1;
+   return TRUE;
+}
+
+#ifdef I830_XV
+/*
+ * Note, the FORCE_LOW flag is currently not used or supported.
+ */
+static Bool
+AllocateOverlay(ScrnInfoPtr pScrn, int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long size, alloced;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+   int verbosity = dryrun ? 4 : 1;
+   const char *s = dryrun ? "[dryrun] " : "";
+
+   /* Clear overlay info */
+   memset(&(pI830->OverlayMem), 0, sizeof(pI830->OverlayMem));
+   pI830->OverlayMem.Key = -1;
+
+   if (!pI830->XvEnabled)
+      return TRUE;
+
+   /*
+    * The overlay register space needs a physical address in
+    * system memory.  We get this from the agpgart module using
+    * a special memory type.
+    */
+
+   size = OVERLAY_SIZE;
+   if (flags & FORCE_LOW)
+      flags |= FROM_POOL_ONLY | ALLOCATE_AT_BOTTOM | NEED_PHYSICAL_ADDR;
+   else
+      flags |= FROM_ANYWHERE | ALLOCATE_AT_TOP | NEED_PHYSICAL_ADDR;
+
+   alloced = I830AllocVidMem(pScrn, &(pI830->OverlayMem),
+			     &(pI830->StolenPool), size, GTT_PAGE_SIZE, flags);
+
+   /*
+    * XXX For testing only.  Don't enable this unless you know how to set
+    * physBase.
+    */
+   if (flags & FORCE_LOW) {
+      ErrorF("AllocateOverlay() doesn't support setting FORCE_LOW\n");
+      return FALSE;
+   }
+
+   if (!dryrun && (alloced < size)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "Failed to allocate Overlay register space.\n");
+	 /* This failure isn't fatal. */
+   } else {
+      xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		     "%sAllocated %d kB for Overlay registers at 0x%x "
+		     "(0x%08x).\n", s,
+		     alloced / 1024, pI830->OverlayMem.Start,
+		     pI830->OverlayMem.Physical);
+   }
+   return TRUE;
+}
+#endif
+
+static unsigned long
+GetFreeSpace(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long extra = 0;
+
+   /* First check for free space in StolenPool. */
+   if (pI830->StolenPool.Free.Size > 0)
+      extra = pI830->StolenPool.Free.Size;
+   /* Next check for unallocated space. */
+   if (pI830->FreeMemory > 0)
+      extra += pI830->FreeMemory;
+
+   return extra;
+}
+
+static Bool
+IsTileable(int pitch)
+{
+   /*
+    * Allow tiling for pitches that are a power of 2 multiple of 128 bytes,
+    * up to 64 * 128 (= 8192) bytes.
+    */
+   switch (pitch) {
+   case 128 * 1:
+   case 128 * 2:
+   case 128 * 4:
+   case 128 * 8:
+   case 128 * 16:
+   case 128 * 32:
+   case 128 * 64:
+      return TRUE;
+   default:
+      return FALSE;
+   }
+}
+
+/*
+ * Allocate memory for 2D operation.  This includes the (front) framebuffer,
+ * ring buffer, scratch memory, HW cursor.
+ */
+
+Bool
+I830Allocate2DMemory(ScrnInfoPtr pScrn, const int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long size, alloced;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+   int verbosity = dryrun ? 4 : 1;
+   const char *s = dryrun ? "[dryrun] " : "";
+   Bool tileable;
+   int align, alignflags;
+
+   DPRINTF(PFX, "I830Allocate2DMemory: inital is %s\n",
+	   BOOLTOSTRING(flags & ALLOC_INITIAL));
+
+   if (!pI830->StolenOnly &&
+       (!xf86AgpGARTSupported() || !xf86AcquireGART(pScrn->scrnIndex))) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "AGP GART support is either not available or cannot "
+		    "be used.\n"
+		    "\tMake sure your kernel has agpgart support or has the\n"
+		    "\tagpgart module loaded.\n");
+      }
+      return FALSE;
+   }
+
+
+   /*
+    * The I830 is slightly different from the I830/I815, it has no
+    * dcache and it has stolen memory by default in its gtt.  All
+    * additional memory must go after it.
+    */
+
+   DPRINTF(PFX,
+	   "size == %luk (%lu bytes == pScrn->videoRam)\n"
+	   "pI830->StolenSize == %luk (%lu bytes)\n",
+	   pScrn->videoRam, pScrn->videoRam * 1024,
+	   pI830->StolenPool.Free.Size / 1024,
+	   pI830->StolenPool.Free.Size);
+
+   if (flags & ALLOC_INITIAL) {
+      unsigned long minspace, avail, lineSize;
+      int cacheLines, maxCacheLines;
+
+      if (pI830->NeedRingBufferLow)
+	 AllocateRingBuffer(pScrn, flags | FORCE_LOW);
+
+      /* Clear everything first. */
+      memset(&(pI830->FbMemBox), 0, sizeof(pI830->FbMemBox));
+      memset(&(pI830->FrontBuffer), 0, sizeof(pI830->FrontBuffer));
+      pI830->FrontBuffer.Key = -1;
+
+      pI830->FbMemBox.x1 = 0;
+      pI830->FbMemBox.x2 = pScrn->displayWidth;
+      pI830->FbMemBox.y1 = 0;
+      pI830->FbMemBox.y2 = pScrn->virtualY;
+
+      /*
+       * Calculate how much framebuffer memory to allocate.  For the
+       * initial allocation, calculate a reasonable minimum.  This is
+       * enough for the virtual screen size, plus some pixmap cache
+       * space.
+       */
+
+      lineSize = pScrn->displayWidth * pI830->cpp;
+      minspace = lineSize * pScrn->virtualY;
+      avail = pScrn->videoRam * 1024;
+      maxCacheLines = (avail - minspace) / lineSize;
+      /* This shouldn't happen. */
+      if (maxCacheLines < 0) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Internal Error: "
+		    "maxCacheLines < 0 in I830Allocate2DMemory()\n");
+	 maxCacheLines = 0;
+      }
+      if (maxCacheLines > (MAX_DISPLAY_HEIGHT - pScrn->virtualY))
+	 maxCacheLines = MAX_DISPLAY_HEIGHT - pScrn->virtualY;
+
+      if (pI830->CacheLines >= 0) {
+	 cacheLines = pI830->CacheLines;
+      } else {
+#if 1
+	 /* Make sure there is enough for two DVD sized YUV buffers */
+	 cacheLines = (pScrn->depth == 24) ? 256 : 384;
+	 if (pScrn->displayWidth <= 1024)
+	    cacheLines *= 2;
+#else
+	 /*
+	  * Make sure there is enough for two DVD sized YUV buffers.
+	  * Make that 1.5MB, which is around what was allocated with
+	  * the old algorithm
+	  */
+	 cacheLines = (MB(1) + KB(512)) / pI830->cpp / pScrn->displayWidth;
+#endif
+      }
+      if (cacheLines > maxCacheLines)
+	 cacheLines = maxCacheLines;
+
+      pI830->FbMemBox.y2 += cacheLines;
+
+      xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		     "%sAllocating at least %d scanlines for pixmap cache\n",
+		     s, cacheLines);
+
+      tileable = !(flags & ALLOC_NO_TILING) && pI830->allowPageFlip &&
+		 IsTileable(pScrn->displayWidth * pI830->cpp);
+      if (tileable) {
+	 align = KB(512);
+	 alignflags = ALIGN_BOTH_ENDS;
+      } else {
+	 align = KB(64);
+	 alignflags = 0;
+      }
+
+      size = lineSize * (pScrn->virtualY + cacheLines);
+      size = ROUND_TO_PAGE(size);
+      xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		     "%sInitial framebuffer allocation size: %d kByte\n", s,
+		     size / 1024);
+      alloced = I830AllocVidMem(pScrn, &(pI830->FrontBuffer),
+				&(pI830->StolenPool), size, align,
+				flags | alignflags |
+				FROM_ANYWHERE | ALLOCATE_AT_BOTTOM);
+      if (alloced < size) {
+	 if (!dryrun) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Failed to allocate framebuffer.\n");
+	 }
+	 return FALSE;
+      }
+   } else {
+      unsigned long lineSize;
+      unsigned long extra = 0;
+      unsigned long maxFb = 0;
+
+      /*
+       * XXX Need to "free" up any 3D allocations if the DRI ended up
+       * and make them available for 2D.  The best way to do this would
+       * be position all of those regions contiguously at the end of the
+       * StolenPool.
+       */
+      extra = GetFreeSpace(pScrn);
+
+      if (extra == 0)
+	 return TRUE;
+
+      maxFb = pI830->FrontBuffer.Size + extra;
+      lineSize = pScrn->displayWidth * pI830->cpp;
+      maxFb = ROUND_DOWN_TO(maxFb, lineSize);
+      if (maxFb > lineSize * MAX_DISPLAY_HEIGHT)
+	 maxFb = lineSize * MAX_DISPLAY_HEIGHT;
+      if (maxFb > pI830->FrontBuffer.Size) {
+	 unsigned long oldsize;
+	 /*
+	  * Sanity check -- the fb should be the last thing allocated at
+	  * the bottom of the stolen pool.
+	  */
+	 if (pI830->StolenPool.Free.Start != pI830->FrontBuffer.End) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Internal error in I830Allocate2DMemory():\n\t"
+		       "Framebuffer isn't the last allocation at the bottom"
+		       " of StolenPool\n\t(%x != %x).\n",
+		       pI830->FrontBuffer.End,
+		       pI830->StolenPool.Free.Start);
+	    return FALSE;
+	 }
+	 /*
+	  * XXX Maybe should have a "Free" function.  This should be
+	  * the only place where a region is resized, and we know that
+	  * the fb is always at the bottom of the aperture/stolen pool,
+	  * and is the only region that is allocated bottom-up.
+	  * Allowing for more general realloction would require a smarter
+	  * allocation system.
+	  */
+	 oldsize = pI830->FrontBuffer.Size;
+	 pI830->StolenPool.Free.Size += pI830->FrontBuffer.Size;
+	 pI830->StolenPool.Free.Start -= pI830->FrontBuffer.Size;
+	 xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+			"%sUpdated framebuffer allocation size from %d "
+			"to %d kByte\n", s, oldsize / 1024, maxFb / 1024);
+	 xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+			"%sUpdated pixmap cache from %d scanlines to %d "
+			"scanlines\n", s,
+			oldsize / lineSize - pScrn->virtualY,
+			maxFb / lineSize - pScrn->virtualY);
+	 pI830->FbMemBox.y2 = maxFb / lineSize;
+	 tileable = !(flags & ALLOC_NO_TILING) && pI830->allowPageFlip &&
+		 IsTileable(pScrn->displayWidth * pI830->cpp);
+	 if (tileable) {
+	    align = KB(512);
+	    alignflags = ALIGN_BOTH_ENDS;
+	 } else {
+	    align = KB(64);
+	    alignflags = 0;
+	 }
+	 alloced = I830AllocVidMem(pScrn, &(pI830->FrontBuffer),
+				   &(pI830->StolenPool), maxFb, align,
+				   flags | alignflags |
+				   FROM_ANYWHERE | ALLOCATE_AT_BOTTOM);
+	 if (alloced < maxFb) {
+	    if (!dryrun) {
+	       xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+			  "Failed to re-allocate framebuffer\n");
+	    }
+	    return FALSE;
+	 }
+      }
+      return TRUE;
+   }
+
+#if REMAP_RESERVED
+   /*
+    * Allocate a dummy page to pass when attempting to rebind the
+    * pre-allocated region.
+    */
+   if (!dryrun) {
+      memset(&(pI830->Dummy), 0, sizeof(pI830->Dummy));
+      pI830->Dummy.Key =
+	   xf86AllocateGARTMemory(pScrn->scrnIndex, size, 0, NULL);
+      pI830->Dummy.Offset = 0;
+   }
+#endif
+
+   /* Clear cursor info */
+   memset(&(pI830->CursorMem), 0, sizeof(pI830->CursorMem));
+   pI830->CursorMem.Key = -1;
+
+   if (!pI830->SWCursor) {
+      int cursFlags = 0;
+      /*
+       * Mouse cursor -- The i810-i830 need a physical address in system
+       * memory from which to upload the cursor.  We get this from
+       * the agpgart module using a special memory type.
+       */
+
+      size = HWCURSOR_SIZE;
+      cursFlags = FROM_ANYWHERE | ALLOCATE_AT_TOP;
+      if (pI830->CursorNeedsPhysical)
+	 cursFlags |= NEED_PHYSICAL_ADDR;
+
+      alloced = I830AllocVidMem(pScrn, &(pI830->CursorMem),
+				&(pI830->StolenPool), size,
+				GTT_PAGE_SIZE, flags | cursFlags);
+      if (alloced < size) {
+	 if (!dryrun) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Failed to allocate HW cursor space.\n");
+	 }
+      } else {
+	 xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+			"%sAllocated %d kB for HW cursor at 0x%x", s,
+			alloced / 1024, pI830->CursorMem.Start);
+	 if (pI830->CursorNeedsPhysical)
+	    xf86ErrorFVerb(verbosity, " (0x%08x)", pI830->CursorMem.Physical);
+	 xf86ErrorFVerb(verbosity, "\n");
+      }
+   }
+
+#ifdef I830_XV
+   AllocateOverlay(pScrn, flags);
+#endif
+
+   if (!pI830->NeedRingBufferLow)
+      AllocateRingBuffer(pScrn, flags);
+
+   /* Clear scratch info */
+   memset(&(pI830->Scratch), 0, sizeof(pI830->Scratch));
+   pI830->Scratch.Key = -1;
+
+   if (!pI830->noAccel) {
+      size = MAX_SCRATCH_BUFFER_SIZE;
+      alloced = I830AllocVidMem(pScrn, &(pI830->Scratch), &(pI830->StolenPool),
+				size, GTT_PAGE_SIZE,
+				flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+      if (alloced < size) {
+	 size = MIN_SCRATCH_BUFFER_SIZE;
+         alloced = I830AllocVidMem(pScrn, &(pI830->Scratch),
+				   &(pI830->StolenPool), size,
+				   GTT_PAGE_SIZE,
+				   flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+      }
+      if (alloced < size) {
+	 if (!dryrun) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Failed to allocate scratch buffer space\n");
+	 }
+	 return FALSE;
+      }
+      xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		    "%sAllocated %d kB for the scratch buffer at 0x%x\n", s,
+		    alloced / 1024, pI830->Scratch.Start);
+   }
+   return TRUE;
+}
+
+#ifndef ALLOCATE_ALL_BIOSMEM
+#define ALLOCATE_ALL_BIOSMEM 1
+#endif
+
+void
+I830ResetAllocations(ScrnInfoPtr pScrn, const int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   pI830->MemoryAperture.Start = pI830->StolenMemory.End;
+   pI830->MemoryAperture.End = pI830->FbMapSize;
+   pI830->MemoryAperture.Size = pI830->FbMapSize - pI830->StolenMemory.Size;
+   pI830->StolenPool.Fixed = pI830->StolenMemory;
+   pI830->StolenPool.Total = pI830->StolenMemory;
+#if ALLOCATE_ALL_BIOSMEM
+   if (pI830->overrideBIOSMemSize &&
+       pI830->BIOSMemorySize > pI830->StolenMemory.Size) {
+      pI830->StolenPool.Total.End = pI830->BIOSMemorySize;
+      pI830->StolenPool.Total.Size = pI830->BIOSMemorySize;
+   }
+#endif
+   pI830->StolenPool.Free = pI830->StolenPool.Total;
+   pI830->FreeMemory = pI830->TotalVideoRam - pI830->StolenPool.Total.Size;
+   pI830->allocatedMemory = 0;
+}
+
+long
+I830GetExcessMemoryAllocations(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long allocated;
+
+   allocated = pI830->StolenPool.Total.Size + pI830->allocatedMemory;
+   if (allocated > pI830->TotalVideoRam)
+      return allocated - pI830->TotalVideoRam;
+   else
+      return 0;
+}
+
+#ifdef XF86DRI
+static unsigned long
+GetBestTileAlignment(unsigned long size)
+{
+   unsigned long i;
+
+   for (i = KB(512); i < size; i <<= 1)
+      ;
+
+   if (i > MB(64))
+      i = MB(64);
+
+   return i;
+}
+
+static unsigned int
+myLog2(unsigned int n)
+{
+   unsigned int log2 = 1;
+
+   while (n > 1) {
+      n >>= 1;
+      log2++;
+   }
+   return log2;
+}
+
+Bool
+I830Allocate3DMemory(ScrnInfoPtr pScrn, const int flags)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   unsigned long size, alloced, align = 0;
+   int i;
+   Bool tileable;
+   Bool dryrun = ((flags & ALLOCATE_DRY_RUN) != 0);
+   int verbosity = dryrun ? 4 : 1;
+   const char *s = dryrun ? "[dryrun] " : "";
+   int lines;
+
+   DPRINTF(PFX, "I830Allocate3DMemory\n");
+
+   /* Back Buffer */
+   memset(&(pI830->BackBuffer), 0, sizeof(pI830->BackBuffer));
+   pI830->BackBuffer.Key = -1;
+   tileable = !(flags & ALLOC_NO_TILING) &&
+	      IsTileable(pScrn->displayWidth * pI830->cpp);
+   if (tileable) {
+      /* Make the height a multiple of the tile height (16) */
+      lines = (pScrn->virtualY + 15) / 16 * 16;
+   } else {
+      lines = pScrn->virtualY;
+   }
+
+   size = ROUND_TO_PAGE(pScrn->displayWidth * lines * pI830->cpp);
+   /*
+    * Try to allocate on the best tile-friendly boundaries.
+    */
+   alloced = 0;
+   if (tileable) {
+      align = GetBestTileAlignment(size);
+      for (align = GetBestTileAlignment(size); align >= KB(512); align >>= 1) {
+	 alloced = I830AllocVidMem(pScrn, &(pI830->BackBuffer),
+				   &(pI830->StolenPool), size, align,
+				   flags | FROM_ANYWHERE | ALLOCATE_AT_TOP |
+				   ALIGN_BOTH_ENDS);
+	 if (alloced >= size)
+	    break;
+      }
+   }
+   if (alloced < size) {
+      /* Give up on trying to tile */
+      tileable = FALSE;
+      size = ROUND_TO_PAGE(pScrn->displayWidth * pScrn->virtualY * pI830->cpp);
+      align = GTT_PAGE_SIZE;
+      alloced = I830AllocVidMem(pScrn, &(pI830->BackBuffer),
+				&(pI830->StolenPool), size, align,
+				flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+   }
+   if (alloced < size) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Failed to allocate back buffer space.\n");
+      }
+      return FALSE;
+   }
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		  "%sAllocated %d kB for the back buffer at 0x%x.\n", s,
+		  alloced / 1024, pI830->BackBuffer.Start);
+
+   /* Depth Buffer -- same size as the back buffer */
+   memset(&(pI830->DepthBuffer), 0, sizeof(pI830->DepthBuffer));
+   pI830->DepthBuffer.Key = -1;
+   /*
+    * Try to allocate on the best tile-friendly boundaries.
+    */
+   alloced = 0;
+   if (tileable) {
+      /* Start with the previous align value. */
+      for (; align >= KB(512); align >>= 1) {
+	 alloced = I830AllocVidMem(pScrn, &(pI830->DepthBuffer),
+				   &(pI830->StolenPool), size, align,
+				   flags | FROM_ANYWHERE | ALLOCATE_AT_TOP |
+				   ALIGN_BOTH_ENDS);
+	 if (alloced >= size)
+	    break;
+      }
+   }
+   if (alloced < size) {
+      /* Give up on trying to tile */
+      tileable = FALSE;
+      size = ROUND_TO_PAGE(pScrn->displayWidth * pScrn->virtualY * pI830->cpp);
+      align = GTT_PAGE_SIZE;
+      alloced = I830AllocVidMem(pScrn, &(pI830->DepthBuffer),
+				&(pI830->StolenPool), size, align,
+				flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+   }
+   if (alloced < size) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Failed to allocate depth buffer space.\n");
+      }
+      return FALSE;
+   }
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		  "%sAllocated %d kB for the depth buffer at 0x%x.\n", s,
+		  alloced / 1024, pI830->DepthBuffer.Start);
+
+   /* Space for logical context.  32k is fine for right now. */
+   memset(&(pI830->ContextMem), 0, sizeof(pI830->ContextMem));
+   pI830->ContextMem.Key = -1;
+   size = KB(32);
+   alloced = I830AllocVidMem(pScrn, &(pI830->ContextMem),
+			     &(pI830->StolenPool), size, GTT_PAGE_SIZE,
+			     flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+   if (alloced < size) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Failed to allocate logical context space.\n");
+      }
+      return FALSE;
+   }
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		  "%sAllocated %d kB for the logical context at 0x%x.\n", s,
+		  alloced / 1024, pI830->ContextMem.Start);
+
+   /*
+    * Space for DMA buffers, only if there's enough free for at least 1MB
+    * of texture space.
+    */
+   memset(&(pI830->BufferMem), 0, sizeof(pI830->BufferMem));
+   pI830->BufferMem.Key = -1;
+   /* This should already be a page multiple */
+   size = I830_DMA_BUF_NR * I830_DMA_BUF_SZ;
+   if (dryrun || (GetFreeSpace(pScrn) >= size + MB(1))) {
+      alloced = I830AllocVidMem(pScrn, &(pI830->BufferMem),
+				&(pI830->StolenPool), size,
+				GTT_PAGE_SIZE,
+				flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+      if (alloced < size) {
+	 if (!dryrun) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		       "Failed to allocate DMA buffer space.\n");
+	 }
+	 return FALSE;
+      }
+      xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		     "%sAllocated %d kB for the DMA buffers at 0x%x.\n", s,
+		     alloced / 1024, pI830->BufferMem.Start);
+   } else {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Not enough free space for DMA buffers.\n");
+      }
+      return FALSE;
+   }
+
+   /* Allocate the remaining space for textures. */
+   memset(&(pI830->TexMem), 0, sizeof(pI830->TexMem));
+   pI830->TexMem.Key = -1;
+   size = GetFreeSpace(pScrn);
+   if (dryrun && (size < MB(1)))
+      size = MB(1);
+   i = myLog2(size / I830_NR_TEX_REGIONS);
+   if (i < I830_LOG_MIN_TEX_REGION_SIZE)
+      i = I830_LOG_MIN_TEX_REGION_SIZE;
+   pI830->TexGranularity = i;
+   /* Truncate size */
+   size >>= i;
+   size <<= i;
+   if (size < KB(512)) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Less than %d kBytes for texture space.\n", size / 1024);
+      }
+      return FALSE;
+   }
+   alloced = I830AllocVidMem(pScrn, &(pI830->TexMem),
+			     &(pI830->StolenPool), size, GTT_PAGE_SIZE,
+			     flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
+   if (alloced < size) {
+      if (!dryrun) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		    "Failed to allocate texture space.\n");
+      }
+      return FALSE;
+   }
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
+		  "%sAllocated %d kB for textures at 0x%x\n", s,
+		  alloced / 1024, pI830->TexMem.Start);
+
+   return TRUE;
+}
+#endif
+
+/* Allocate pool space that isn't pre-allocated */
+Bool
+I830DoPoolAllocation(ScrnInfoPtr pScrn, I830MemPool *pool)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "I830DoPoolAllocation\n");
+
+   if (!pool)
+      return FALSE;
+
+   /*
+    * Sanity check: there shouldn't be an allocation required when
+    * there is only stolen memory.
+    */
+   if (pI830->StolenOnly && (pool->Total.Size > pool->Fixed.Size)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
+		 "I830DoPoolAllocation(): pool size is greater than the "
+		 "preallocated size,\n\t"
+		 "and there is no allocatable memory.\n");
+      return FALSE;
+   }
+
+   if (pool->Total.Size > pool->Fixed.Size) {
+      pool->Allocated.Size = pool->Total.Size - pool->Fixed.Size;
+      pool->Allocated.Key =
+	    xf86AllocateGARTMemory(pScrn->scrnIndex, pool->Allocated.Size,
+				   0, NULL);
+      if (pool->Allocated.Key == -1) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Pool allocation failed\n");
+	 return FALSE;
+      }
+      pool->Allocated.Start = pool->Fixed.End;
+      pool->Allocated.End = pool->Total.Size;
+      pool->Allocated.Offset = pool->Allocated.Start;
+   } else
+      pool->Allocated.Key = -1;
+   return TRUE;
+}
+
+static unsigned long topOfMem = 0;
+
+/*
+ * These modify the way memory is positioned within the aperture.
+ *
+ * By default, memory allocated from the bottom or specifically within
+ * the pool at the bottom gets allocated from the "stolen pool", which is
+ * actually the stolen memory plus any extra allocated to make it a larger
+ * contiguous region.  Memory allocated from the AGP is allocated top-down
+ * from the end of the aperture space.  Memory allocated "from top" defaults
+ * to AGP if there is enough "free space".  The total allocation (stolen +
+ * extra) doesn't exceed the orignal pScrn->videoRam amount (this isn't true
+ * when memory allocated from AGP gets moved into the pool by one of the
+ * following options.
+ *
+ * XXX Write a better description.
+ *
+ */
+#define PACK_RANGES 0
+#define POOL_RANGES 0
+
+static Bool
+FixOffset(ScrnInfoPtr pScrn, I830MemRange *mem)
+{
+#if POOL_RANGES
+   I830Ptr pI830 = I830PTR(pScrn);
+#endif
+
+   if (!mem)
+      return FALSE;
+
+   if (mem->Pool && mem->Key == -1 && mem->Start < 0) {
+      mem->Start = mem->Pool->Total.End + mem->Start;
+      mem->End = mem->Start + mem->Size;
+   }
+#if PACK_RANGES
+   /*
+    * Map AGP-allocated areas at the top of the stolen area, resulting in
+    * a contiguous region in the aperture.  Normally most AGP-allocated areas
+    * will be at the top of the aperture, making alignment requirements
+    * easier to achieve.  This optin is primarily for debugging purposes,
+    * and using this option can break any special alignment requirements.
+    */
+   if (!mem->Pool && mem->Start != 0 && mem->Key != -1 && mem->Physical == 0 &&
+	mem->Offset != 0) {
+      long diff;
+      if (mem->Offset != mem->Start)
+	 ErrorF("mem %p, Offset != Start\n", mem);
+      diff = mem->Offset - topOfMem;
+      mem->Start -= diff;
+      mem->End -= diff;
+      mem->Offset -= diff;
+      topOfMem += mem->Size;
+   }
+#elif POOL_RANGES
+   /*
+    * Move AGP-allocated regions (that don't need a physical address) into
+    * the pre-allocated pool when there's enough space to do so.  Note: the
+    * AGP-allocated areas aren't freed.  This option is primarily for
+    * debugging purposes, and using it can break any special alignment
+    * requirements.
+    */
+   if (!mem->Pool && mem->Start >= pI830->StolenPool.Free.End &&
+       mem->Key != -1 && mem->Physical == 0 && mem->Offset != 0 &&
+       pI830->StolenPool.Free.Size >= mem->Size) {
+      long diff;
+      if (mem->Offset != mem->Start)
+	 ErrorF("mem %p, Offset != Start\n", mem);
+      diff = mem->Offset - pI830->StolenPool.Free.Start;
+      mem->Start -= diff;
+      mem->End -= diff;
+      mem->Offset -= diff;
+      mem->Key = -1;
+      pI830->StolenPool.Free.Start += mem->Size;
+      pI830->StolenPool.Free.Size -= mem->Size;
+   }
+#endif
+   xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+	      "%p: Memory at offset 0x%08x, size %d kBytes\n", mem,
+	      mem->Start, mem->Size / 1024);
+   return TRUE;
+}
+
+Bool
+I830FixupOffsets(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX, "I830FixupOffsets\n");
+
+   topOfMem = pI830->StolenPool.Total.End;
+   FixOffset(pScrn, &(pI830->FrontBuffer));
+   FixOffset(pScrn, &(pI830->CursorMem));
+   FixOffset(pScrn, &(pI830->LpRing.mem));
+   FixOffset(pScrn, &(pI830->Scratch));
+#ifdef I830_XV
+   if (pI830->XvEnabled) {
+      FixOffset(pScrn, &(pI830->OverlayMem));
+   }
+#endif
+#ifdef XF86DRI
+   if (pI830->directRenderingEnabled) {
+      FixOffset(pScrn, &(pI830->BackBuffer));
+      FixOffset(pScrn, &(pI830->DepthBuffer));
+      FixOffset(pScrn, &(pI830->ContextMem));
+      FixOffset(pScrn, &(pI830->BufferMem));
+      FixOffset(pScrn, &(pI830->TexMem));
+   }
+#endif
+   return TRUE;
+}
+
+#ifdef XF86DRI
+/* Tiled memory is good... really, really good...
+ *
+ * Need to make it less likely that we miss out on this - probably
+ * need to move the frontbuffer away from the 'guarenteed' alignment
+ * of the first memory segment, or perhaps allocate a discontigous
+ * framebuffer to get more alignment 'sweet spots'.
+ */
+static void
+SetFence(ScrnInfoPtr pScrn, int nr, unsigned int start, unsigned int pitch,
+         unsigned int size)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   I830RegPtr i830Reg = &pI830->ModeReg;
+   CARD32 val;
+   CARD32 fence_mask = 0;
+
+   DPRINTF(PFX, "SetFence: %d, 0x%08x, %d, %d kByte\n",
+	   nr, start, pitch, size / 1024);
+
+   if (nr < 0 || nr > 7) {
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: fence %d out of range\n");
+      return;
+   }
+
+   i830Reg->Fence[nr] = 0;
+
+   fence_mask = ~I830_FENCE_START_MASK;
+
+   if (start & fence_mask) {
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: %d: start (0x%08x) is not 512k aligned\n",
+		 nr, start);
+      return;
+   }
+
+   if (start % size) {
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: %d: start (0x%08x) is not size (%dk) aligned\n",
+		 nr, start, size / 1024);
+      return;
+   }
+
+   if (pitch & 127) {
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: %d: pitch (%d) not a multiple of 128 bytes\n",
+		 nr, pitch);
+      return;
+   }
+
+   val = (start | FENCE_X_MAJOR | FENCE_VALID);
+
+   switch (size) {
+   case KB(512):
+      val |= FENCE_SIZE_512K;
+      break;
+   case MB(1):
+      val |= FENCE_SIZE_1M;
+      break;
+   case MB(2):
+      val |= FENCE_SIZE_2M;
+      break;
+   case MB(4):
+      val |= FENCE_SIZE_4M;
+      break;
+   case MB(8):
+      val |= FENCE_SIZE_8M;
+      break;
+   case MB(16):
+      val |= FENCE_SIZE_16M;
+      break;
+   case MB(32):
+      val |= FENCE_SIZE_32M;
+      break;
+   case MB(64):
+      val |= FENCE_SIZE_64M;
+      break;
+   default:
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: %d: illegal size (%d kByte)\n", nr, size / 1024);
+      return;
+   }
+
+   switch (pitch / 128) {
+   case 1:
+      val |= FENCE_PITCH_1;
+      break;
+   case 2:
+      val |= FENCE_PITCH_2;
+      break;
+   case 4:
+      val |= FENCE_PITCH_4;
+      break;
+   case 8:
+      val |= FENCE_PITCH_8;
+      break;
+   case 16:
+      val |= FENCE_PITCH_16;
+      break;
+   case 32:
+      val |= FENCE_PITCH_32;
+      break;
+   case 64:
+      val |= FENCE_PITCH_64;
+      break;
+   default:
+      xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+		 "SetFence: %d: illegal pitch (%d)\n", nr, pitch);
+      return;
+   }
+
+   i830Reg->Fence[nr] = val;
+}
+
+static Bool
+MakeTiles(ScrnInfoPtr pScrn, I830MemRange *pMem)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+   int pitch, ntiles, i;
+   static int nextTile = 0;
+   static int tileGeneration = -1;
+
+#if 0
+   /* Hack to "improve" the alignment of the front buffer.
+    */
+   while (!(pMem->Start & ~pMem->Alignment) && pMem->Alignment < 0x00400000 )
+      pMem->Alignment <<= 1;
+#endif
+
+   if (tileGeneration != serverGeneration) {
+      tileGeneration = serverGeneration;
+      nextTile = 0;
+   }
+
+   pitch = pScrn->displayWidth * pI830->cpp;
+   /*
+    * Simply try to break the region up into at most four pieces of size
+    * equal to the alignment.
+    */
+   ntiles = ROUND_TO(pMem->Size, pMem->Alignment) / pMem->Alignment;
+   if (ntiles >= 4) {
+      return FALSE;
+   }
+
+   for (i = 0; i < ntiles; i++, nextTile++) {
+      SetFence(pScrn, nextTile, pMem->Start + i * pMem->Alignment,
+	       pitch, pMem->Alignment);
+   }
+   return TRUE;
+}
+
+void
+I830SetupMemoryTiling(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   /* We currently only attempt to tile the back and depth buffers. */
+   if (!pI830->directRenderingEnabled)
+      return;
+
+   if (!IsTileable(pScrn->displayWidth * pI830->cpp)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "I830SetupMemoryTiling: Not tileable 0x%x\n",
+		 pScrn->displayWidth * pI830->cpp);
+      pI830->allowPageFlip = FALSE;
+      return;
+   }
+
+   if (pI830->allowPageFlip) {
+      if (pI830->allowPageFlip && pI830->FrontBuffer.Alignment >= KB(512)) {
+	 if (MakeTiles(pScrn, &(pI830->FrontBuffer))) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "Activating tiled memory for the FRONT buffer\n");
+	 } else {
+	    pI830->allowPageFlip = FALSE;
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "MakeTiles failed for the FRONT buffer\n");
+	 }
+      } else {
+	 pI830->allowPageFlip = FALSE;
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "Alignment bad for the FRONT buffer\n");
+      }
+   }
+
+   /*
+    * We tried to get the best alignment during the allocation.  Check
+    * the alignment values to tell.  If well-aligned allocations were
+    * successful, the address range reserved is a multiple of the align
+    * value.
+    */
+   if (pI830->BackBuffer.Alignment >= KB(512)) {
+      if (MakeTiles(pScrn, &(pI830->BackBuffer))) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Activating tiled memory for the back buffer.\n");
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "MakeTiles failed for the back buffer.\n");
+	 pI830->allowPageFlip = FALSE;
+      }
+   }
+
+   if (pI830->DepthBuffer.Alignment >= KB(512)) {
+      if (MakeTiles(pScrn, &(pI830->DepthBuffer))) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Activating tiled memory for the depth buffer.\n");
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "MakeTiles failed for the back buffer.\n");
+      }
+   }
+	
+}
+#endif /* XF86DRI */
+
+static Bool
+BindMemRange(ScrnInfoPtr pScrn, I830MemRange *mem)
+{
+   if (!mem)
+      return FALSE;
+
+   if (mem->Key == -1)
+      return TRUE;
+
+   return xf86BindGARTMemory(pScrn->scrnIndex, mem->Key, mem->Offset);
+}
+
+Bool
+I830BindGARTMemory(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX,
+	   "I830BindGARTMemory: StolenOnly is %s, pI830->GttBound is %s\n",
+	   BOOLTOSTRING(pI830->StolenOnly), BOOLTOSTRING(pI830->GttBound));
+
+   if (pI830->StolenOnly == TRUE)
+      return TRUE;
+
+   if (xf86AgpGARTSupported() && !pI830->GttBound) {
+      if (!xf86AcquireGART(pScrn->scrnIndex))
+	 return FALSE;
+
+#if REMAP_RESERVED
+      /* Rebind the pre-allocated region. */
+      BindMemRange(pScrn, &(pI830->Dummy));
+#endif
+
+      if (!BindMemRange(pScrn, &(pI830->StolenPool.Allocated)))
+	 return FALSE;
+      if (!BindMemRange(pScrn, &(pI830->FrontBuffer)))
+	 return FALSE;
+      if (!BindMemRange(pScrn, &(pI830->CursorMem)))
+	 return FALSE;
+      if (!BindMemRange(pScrn, &(pI830->LpRing.mem)))
+	 return FALSE;
+      if (!BindMemRange(pScrn, &(pI830->Scratch)))
+	 return FALSE;
+#ifdef I830_XV
+      if (!BindMemRange(pScrn, &(pI830->OverlayMem)))
+	 return FALSE;
+#endif
+#ifdef XF86DRI
+      if (pI830->directRenderingEnabled) {
+	 if (!BindMemRange(pScrn, &(pI830->BackBuffer)))
+	    return FALSE;
+	 if (!BindMemRange(pScrn, &(pI830->DepthBuffer)))
+	    return FALSE;
+	 if (!BindMemRange(pScrn, &(pI830->ContextMem)))
+	    return FALSE;
+	 if (!BindMemRange(pScrn, &(pI830->BufferMem)))
+	    return FALSE;
+	 if (!BindMemRange(pScrn, &(pI830->TexMem)))
+	    return FALSE;
+      }
+#endif
+      pI830->GttBound = 1;
+   }
+
+   return TRUE;
+}
+
+static Bool
+UnbindMemRange(ScrnInfoPtr pScrn, I830MemRange *mem)
+{
+   if (!mem)
+      return FALSE;
+
+   if (mem->Key == -1)
+      return TRUE;
+
+   return xf86UnbindGARTMemory(pScrn->scrnIndex, mem->Key);
+}
+
+
+Bool
+I830UnbindGARTMemory(ScrnInfoPtr pScrn)
+{
+   I830Ptr pI830 = I830PTR(pScrn);
+
+   DPRINTF(PFX,
+	   "I830UnbindGARTMemory: StolenOnly is %s, pI830->GttBound is %s\n",
+	   BOOLTOSTRING(pI830->StolenOnly), BOOLTOSTRING(pI830->GttBound));
+
+   if (pI830->StolenOnly == TRUE)
+      return TRUE;
+
+   if (xf86AgpGARTSupported() && pI830->GttBound) {
+
+#if REMAP_RESERVED
+      /* "unbind" the pre-allocated region. */
+      UnbindMemRange(pScrn, &(pI830->Dummy));
+#endif
+
+      if (!UnbindMemRange(pScrn, &(pI830->StolenPool.Allocated)))
+	 return FALSE;
+      if (!UnbindMemRange(pScrn, &(pI830->FrontBuffer)))
+	 return FALSE;
+      if (!UnbindMemRange(pScrn, &(pI830->CursorMem)))
+	 return FALSE;
+      if (!UnbindMemRange(pScrn, &(pI830->LpRing.mem)))
+	 return FALSE;
+      if (!UnbindMemRange(pScrn, &(pI830->Scratch)))
+	 return FALSE;
+#ifdef I830_XV
+      if (!UnbindMemRange(pScrn, &(pI830->OverlayMem)))
+	 return FALSE;
+#endif
+#ifdef XF86DRI
+      if (pI830->directRenderingEnabled) {
+	 if (!UnbindMemRange(pScrn, &(pI830->BackBuffer)))
+	    return FALSE;
+	 if (!UnbindMemRange(pScrn, &(pI830->DepthBuffer)))
+	    return FALSE;
+	 if (!UnbindMemRange(pScrn, &(pI830->ContextMem)))
+	    return FALSE;
+	 if (!UnbindMemRange(pScrn, &(pI830->BufferMem)))
+	    return FALSE;
+	 if (!UnbindMemRange(pScrn, &(pI830->TexMem)))
+	    return FALSE;
+      }
+#endif
+      if (!xf86ReleaseGART(pScrn->scrnIndex))
+	 return FALSE;
+
+      pI830->GttBound = 0;
+   }
+
+   return TRUE;
+}
+
+long
+I830CheckAvailableMemory(ScrnInfoPtr pScrn)
+{
+   AgpInfoPtr agpinf;
+   int maxPages;
+
+   if (!xf86AgpGARTSupported() ||
+       !xf86AcquireGART(pScrn->scrnIndex) ||
+       (agpinf = xf86GetAGPInfo(pScrn->scrnIndex)) == NULL ||
+       !xf86ReleaseGART(pScrn->scrnIndex))
+      return -1;
+
+   maxPages = agpinf->totalPages - agpinf->usedPages;
+   xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "%s: %d kB available\n",
+		  "I830CheckAvailableMemory", maxPages * 4);
+
+   return maxPages * 4;
+}