Driver restructuring for irq dma

6 files changed, 418 insertions, 228 deletions

diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/Imakefile b/xc/programs/Xserver/hw/xfree86/drivers/i810/Imakefile
index 8c1ed8cc4..f0f5ed12e 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/Imakefile
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/Imakefile
@@ -6,22 +6,37 @@ XCOMM
 #define IHaveModules
 #include <Server.tmpl>
 
-SRCS = i810_driver.c i810_cursor.c i810_accel.c i810_io.c i810_memory.c i810_wmark.c 
+#
+# Uncomment these to build with DRI support when available
+#
+#if BuildXF86DRI
+DRISRCS = i810_dri.c i810_drm.c
+DRIOBJS = i810_dri.o i810_drm.o
+DRIINCLUDES = -I$(SERVERSRC)/GL/dri -I$(LIBSRC)/GL/dri \
+	-I$(XF86OSSRC)/linux/drm/kernel
+DRIDEFINES = $(GLX_DEFINES)
+#endif
+
+SRCS = 	i810_driver.c i810_cursor.c i810_accel.c i810_io.c	\
+	i810_memory.c i810_wmark.c $(DRISRCS)
 
-OBJS = i810_driver.o i810_cursor.o i810_accel.o i810_io.o i810_memory.o i810_wmark.o
+OBJS = 	i810_driver.o i810_cursor.o i810_accel.o i810_io.o	\
+	i810_memory.o i810_wmark.o $(DRIOBJS)
 
 #if defined(XF86DriverSDK)
 INCLUDES = -I. -I../../include
 #else
-INCLUDES = -I. -I$(XF86COMSRC) -I$(XF86OSSRC) \
-           -I$(SERVERSRC)/mfb -I$(SERVERSRC)/mi \
-	   -I$(XF86SRC)/xaa -I$(XF86SRC)/rac \
-           -I$(SERVERSRC)/cfb -I$(XF86SRC)/xaa -I$(XF86SRC)/ramdac \
-	   -I$(XF86SRC)/vgahw -I$(XF86SRC)/ddc -I$(XF86SRC)/i2c \
-	   -I$(SERVERSRC)/Xext \
-           -I$(FONTINCSRC) -I$(SERVERSRC)/include -I$(XINCLUDESRC) \
-	   -I$(EXTINCSRC)
+INCLUDES = -I. -I$(XF86COMSRC) -I$(XF86OSSRC)				\
+           -I$(SERVERSRC)/mfb -I$(SERVERSRC)/mi				\
+	   -I$(XF86SRC)/xaa -I$(XF86SRC)/rac				\
+           -I$(SERVERSRC)/cfb -I$(XF86SRC)/xaa -I$(XF86SRC)/ramdac	\
+	   -I$(XF86SRC)/vgahw -I$(XF86SRC)/ddc -I$(XF86SRC)/i2c		\
+	   -I$(SERVERSRC)/Xext						\
+           -I$(FONTINCSRC) -I$(SERVERSRC)/include -I$(XINCLUDESRC)	\
+	   -I$(EXTINCSRC)						\
+	   $(DRIINCLUDES)
 #endif
+DEFINES = $(DRIDEFINES)
 
 #if MakeHasPosixVariableSubstitutions
 SubdirLibraryRule($(OBJS))
@@ -44,6 +59,9 @@ InstallDriverSDKNonExecFile(i810.h,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_accel.c,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_cursor.c,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_driver.c,$(DRIVERSDKDIR)/drivers/i810)
+InstallDriverSDKNonExecFile(i810_dri.c,$(DRIVERSDKDIR)/drivers/i810)
+InstallDriverSDKNonExecFile(i810_dri.h,$(DRIVERSDKDIR)/drivers/i810)
+InstallDriverSDKNonExecFile(i810_dripriv.h,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_io.c,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_memory.c,$(DRIVERSDKDIR)/drivers/i810)
 InstallDriverSDKNonExecFile(i810_wmark.c,$(DRIVERSDKDIR)/drivers/i810)
diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810.h b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810.h
index 59370fc55..d5d32d2d5 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810.h
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810.h
@@ -142,11 +142,17 @@ typedef struct _I810Rec {
    int MaxClock;
 
    unsigned int bufferOffset;	/* for I810SelectBuffer */
-
+   Bool DoneFrontAlloc;
+   BoxRec FbMemBox;
    I810MemRange FrontBuffer;
    I810MemRange BackBuffer;   
    I810MemRange DepthBuffer;
    I810MemRange TexMem;
+   I810MemRange Scratch;
+   I810MemRange BufferMem;
+   drmHandle buffer_map;
+   drmHandle ring_map;
+   
 
    int auxPitch;
    int auxPitchBits;
@@ -219,6 +225,8 @@ typedef struct _I810Rec {
 extern Bool I810DRIScreenInit(ScreenPtr pScreen);
 extern void I810DRICloseScreen(ScreenPtr pScreen);
 extern Bool I810DRIFinishScreenInit(ScreenPtr pScreen);
+extern Bool I810drmInitDma(ScrnInfoPtr pScrn);
+extern Bool I810drmCleanupDma(ScrnInfoPtr pScrn);
 
 #define I810PTR(p) ((I810Ptr)((p)->driverPrivate))
 #define I810REGPTR(p) (&(I810PTR(p)->ModeReg))
@@ -236,6 +244,7 @@ extern unsigned long I810LocalToPhysical( ScrnInfoPtr pScrn,
 					  unsigned long local );
 extern int I810AllocLow( I810MemRange *result, I810MemRange *pool, int size );
 extern int I810AllocHigh( I810MemRange *result, I810MemRange *pool, int size );
+extern Bool I810AllocateFront(ScrnInfoPtr pScrn);
 
 extern void I810SetCursorPosition(ScrnInfoPtr pScrn, int x, int y);
 
diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_accel.c b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_accel.c
index 8ea98c9cd..bb5f28464 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_accel.c
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_accel.c
@@ -116,7 +116,6 @@ I810AccelInit( ScreenPtr pScreen )
    XAAInfoRecPtr infoPtr;
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    I810Ptr pI810 = I810PTR(pScrn);
-   I810MemRange scratch;	/* push into pI810 */
 
    if (I810_DEBUG & DEBUG_VERBOSE_ACCEL)
       ErrorF( "I810AccelInit\n");
@@ -181,15 +180,12 @@ I810AccelInit( ScreenPtr pScreen )
    /* Scanline color expansion - Use the same scheme as the 3.3 driver.  
     *
     */
-   if ( I810AllocLow( &scratch, &(pI810->SysMem), 64*1024 ) || 
-	I810AllocLow( &scratch, &(pI810->SysMem), 16*1024 ) )
-   {
+   if(pI810->Scratch.Size != 0) {
       int i;
       int width = ((pScrn->displayWidth + 31) & ~31) / 8; 
-      int nr_buffers = scratch.Size / width;
-      unsigned char *ptr = pI810->FbBase + scratch.Start;
+      int nr_buffers = pI810->Scratch.Size / width;
+      unsigned char *ptr = pI810->FbBase + pI810->Scratch.Start;
       
-
       pI810->NumScanlineColorExpandBuffers = nr_buffers;
       pI810->ScanlineColorExpandBuffers = (unsigned char **) 
 	 xnfcalloc( nr_buffers,  sizeof (unsigned char *) );
@@ -219,8 +215,7 @@ I810AccelInit( ScreenPtr pScreen )
 	 I810SubsequentScanlineCPUToScreenColorExpandFill;
        
       infoPtr->SubsequentColorExpandScanline = 
-	 I810SubsequentColorExpandScanline;
-	  
+	 I810SubsequentColorExpandScanline;	  
    }
 
    /* Possible todo: Image writes w/ non-GXCOPY rop.
diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.c b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.c
index 962b3f313..a7714d8a0 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.c
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.c
@@ -46,7 +46,21 @@ extern void GlxSetVisualConfigs(int nconfigs,
 				__GLXvisualConfig *configs,
 				void **configprivs);
 
-
+static int i810_pitches[] = {
+   512,
+   1024,
+   2048,
+   4096,
+   0
+};
+
+static int i810_pitch_flags[] = {
+    0x0,
+    0x1,
+    0x2,
+    0x3,
+    0
+};
 
 static Bool
 I810InitVisualConfigs(ScreenPtr pScreen)
@@ -229,8 +243,16 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
    I810DRIPtr pI810DRI;
    unsigned long tom;
    unsigned long agpHandle;
-/*     int bufs; */
+   unsigned long dcacheHandle;
+   int sysmem_size = 0;
+   int back_size = 0;
+   int i = 0;
+   int bufs;
+   int width = pScrn->displayWidth * pI810->cpp;
+   
+   /* ToDo : save agpHandles? */
 
+   
    pDRIInfo = DRICreateInfoRec();
    if (!pDRIInfo) {
       ErrorF("DRICreateInfoRec failed\n");
@@ -251,7 +273,10 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
    pDRIInfo->ddxDriverMinorVersion = 1;
    pDRIInfo->ddxDriverPatchVersion = 0;
    pDRIInfo->frameBufferPhysicalAddress = pI810->LinearAddr;
-   pDRIInfo->frameBufferSize = pI810->FbMapSize;
+   pDRIInfo->frameBufferSize = (((pScrn->displayWidth * 
+				  pScrn->virtualY * pI810->cpp) + 
+				 4096 - 1) / 4096) * 4096;
+
    pDRIInfo->frameBufferStride = pScrn->displayWidth*pI810->cpp;
    pDRIInfo->ddxDrawableTableEntry = I810_MAX_DRAWABLES;
 
@@ -277,15 +302,15 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
    pDRIInfo->devPrivate = pI810DRI;
    pDRIInfo->devPrivateSize = sizeof(I810DRIRec);
    pDRIInfo->contextSize = sizeof(I810DRIContextRec);
-
+   
    pDRIInfo->CreateContext = I810CreateContext;
    pDRIInfo->DestroyContext = I810DestroyContext;
    pDRIInfo->SwapContext = I810DRISwapContext;
    pDRIInfo->InitBuffers = I810DRIInitBuffers;
    pDRIInfo->MoveBuffers = I810DRIMoveBuffers;
    pDRIInfo->bufferRequests = DRI_ALL_WINDOWS;
-
-
+   
+   
    /* This adds the framebuffer as a drm map *before* we have asked agp
     * to allocate it.  Scary stuff, hold on...
     */
@@ -297,7 +322,7 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
       pI810->pDRIInfo=0;
       return FALSE;
    }
-
+   
    pI810DRI->regsSize=I810_REG_SIZE;
    if (drmAddMap(pI810->drmSubFD, (drmHandle)pI810->MMIOAddr, 
 		 pI810DRI->regsSize, DRM_REGISTERS, 0, &pI810DRI->regs)<0) {
@@ -307,9 +332,7 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
    }
    xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] Registers = 0x%08lx\n",
 	      pI810DRI->regs);
-
-
-
+   
    /* Agp Support - Need this just to get the framebuffer.
     */
    if(drmAgpAcquire(pI810->drmSubFD) < 0) {
@@ -317,102 +340,268 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
       DRICloseScreen(pScreen);
       return FALSE;
    }
-
-
-
-   /* Now allocate and bind the agp space.  This memory will include the
-    * regular framebuffer as well as back and texture memory.
-    *
-    * --> What about the dcache??? 
-    */
-   agpHandle = drmAgpAlloc(pI810->drmSubFD, pScrn->videoRam * 1024, 0, NULL);
-   if(agpHandle == 0) {
-      ErrorF("drmAgpAlloc failed\n");
-      DRICloseScreen(pScreen);
-      return FALSE;
-   }
-
-   if(drmAgpBind(pI810->drmSubFD, agpHandle, 0) != 0) {
-      ErrorF("drmAgpBind failed\n");
+   
+   if (drmAgpEnable(pI810->drmSubFD, 0) < 0) {
+      ErrorF("drmAgpEnable failed\n");
       DRICloseScreen(pScreen);
       return FALSE;
    }
-
-   pI810->SysMem.Start = 0;
-   pI810->SysMem.Size = pScrn->videoRam * 1024;
-   pI810->SysMem.End = pScrn->videoRam * 1024;
-   pI810->SavedSysMem = pI810->SysMem;
-
-   tom = pI810->SysMem.End;
-
    xf86memset (&pI810->DcacheMem, 0, sizeof(I810MemRange));
+   xf86memset (&pI810->BackBuffer, 0, sizeof(I810MemRange));
+   xf86memset (&pI810->DepthBuffer, 0, sizeof(I810MemRange));
    pI810->CursorPhysical = 0;
-
+   
    /* Dcache - half the speed of normal ram, but has use as a Z buffer
     * under the DRI.  
     */
 
+   dcacheHandle = drmAgpAlloc(pI810->drmSubFD, 4096 * 1024, 1, NULL);
+   ErrorF("dcacheHandle : %p\n", dcacheHandle);
+   
+#define Elements(x) sizeof(x)/sizeof(*x)
+   for (i = 0 ; i < Elements(i810_pitches) ; i++) 
+     if (width <= i810_pitches[i]) 
+       break;
+   
+   if (i == Elements(i810_pitches)) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
+		 "Couldn't find depth/back buffer pitch");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   else {
+      back_size = i810_pitches[i] * pScrn->virtualY;
+      ErrorF("back_size: %d\n", back_size);
+      /* Round to 4k */
+      back_size = ((back_size + 4096 - 1) / 4096) * 4096;
+      ErrorF("back_size 2 : %d\n", back_size);
+   }
+   sysmem_size = pScrn->videoRam * 1024;
+   if(dcacheHandle != 0) sysmem_size = sysmem_size - back_size;
+   else sysmem_size = sysmem_size - 2*back_size;
+   ErrorF("sysmem_size : %d\n", sysmem_size);
+   
+   tom = sysmem_size + 4096;
+   pI810->SysMem.Start = 0;
+   pI810->SysMem.Size = sysmem_size;
+   pI810->SysMem.End = sysmem_size;
+   pI810->SavedSysMem = pI810->SysMem;
 
-   /* Keep it 512K aligned for the sake of tiled regions.
-    */
-   tom += 0x7ffff;
-   tom &= ~0x7ffff;
-
-   agpHandle = drmAgpAlloc(pI810->drmSubFD, 4096 * 1024, 1, NULL);
-   if (agpHandle != 0) {
-      if(drmAgpBind(pI810->drmSubFD, agpHandle, tom) == 0) {
+   if (dcacheHandle != 0) {
+      tom = ((tom + 524288 - 1) / 524288) * 524288;
+      
+      ErrorF("dcacheHandle : %p, tom : %lx\n", dcacheHandle, tom);
+      if(drmAgpBind(pI810->drmSubFD, dcacheHandle, tom) == 0) {
+	 xf86memset (&pI810->DcacheMem, 0, sizeof(I810MemRange));
 	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
 		    "GART: Found 4096K Z buffer memory\n");
 	 pI810->DcacheMem.Start = tom;
 	 pI810->DcacheMem.Size = 1024 * 4096;
 	 pI810->DcacheMem.End = pI810->DcacheMem.Start + pI810->DcacheMem.Size;
 	 tom = pI810->DcacheMem.End;
+	 if(I810AllocLow(&(pI810->DepthBuffer), &(pI810->DcacheMem), back_size) == FALSE) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Depth buffer allocation failed\n");
+	    DRICloseScreen(pScreen);
+	    return FALSE;
+	 }
       } else {
 	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "GART: dcache bind failed\n");
-      } 
+      }   
    } else {
       xf86DrvMsg(pScrn->scrnIndex, X_INFO, "GART: no dcache memory found\n");
    }
-      
 
-
-   pI810->SavedDcacheMem = pI810->DcacheMem;
-
-   /* Mouse cursor - needs the physical address for hardware.
+   agpHandle = drmAgpAlloc(pI810->drmSubFD, back_size, 0,
+			   NULL);
+   
+   if(agpHandle != 0) {
+      tom = ((tom + 524288 - 1) / 524288) * 524288;
+      
+      if(drmAgpBind(pI810->drmSubFD, agpHandle, tom) == 0) {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Bound backbuffer memory\n");
+	 
+	 pI810->BackBuffer.Start = tom;
+	 pI810->BackBuffer.Size = back_size;
+	 pI810->BackBuffer.End = pI810->BackBuffer.Start + pI810->BackBuffer.Size;
+	 tom = pI810->BackBuffer.End;
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Unable to bind backbuffer\n");
+	 DRICloseScreen(pScreen);
+	 return FALSE;
+      }
+   } else {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		 "Unable to allocate backbuffer memory\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+      
+   if(dcacheHandle == 0) {
+      tom += 0x7ffff;
+      tom &= 0x7ffff;
+      agpHandle = drmAgpAlloc(pI810->drmSubFD, back_size, 0,
+			      NULL);
+      if(agpHandle != 0) {
+	 if(drmAgpBind(pI810->drmSubFD, agpHandle, tom) == 0) {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		       "Bound depthbuffer memory\n");
+	    pI810->DepthBuffer.Start = tom;
+	    pI810->DepthBuffer.Size = back_size;
+	    pI810->DepthBuffer.End = pI810->DepthBuffer.Start + pI810->DepthBuffer.Size;
+	    tom = pI810->DepthBuffer.End;
+	 } else {
+	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Unable to bind depthbuffer\n");
+	    DRICloseScreen(pScreen);
+	    return FALSE;
+	 }
+      } else {
+	 xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+		    "Unable to allocate depthbuffer memory\n");
+	 DRICloseScreen(pScreen);
+	 return FALSE;
+      }
+   }	 
+   
+   /* Now allocate and bind the agp space.  This memory will include the
+    * regular framebuffer as well as texture memory.
     */
+   
+   agpHandle = drmAgpAlloc(pI810->drmSubFD, sysmem_size, 0, NULL);
+   if(agpHandle == 0) {
+      ErrorF("drmAgpAlloc failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+
+   if(drmAgpBind(pI810->drmSubFD, agpHandle, 0) != 0) {
+      ErrorF("drmAgpBind failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   
    agpHandle = drmAgpAlloc(pI810->drmSubFD, 4096, 2, 
 			   (unsigned long *)&pI810->CursorPhysical); 
    if (agpHandle != 0) {
+      int old_tom = tom;
+      tom = sysmem_size;
+
       if(drmAgpBind(pI810->drmSubFD, agpHandle, tom) == 0) { 
 	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
 		    "GART: Allocated 4K for mouse cursor image\n");
 	 pI810->CursorStart = tom;	 
-	 tom += 4096;
+	 tom = old_tom;
+	 ErrorF("tom : %lx\n", tom);
       } else {
 	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "GART: cursor bind failed\n");
+	 tom = old_tom;
 	 pI810->CursorPhysical = 0;    
       } 
    } else {
       xf86DrvMsg(pScrn->scrnIndex, X_INFO, "GART: cursor alloc failed\n");
       pI810->CursorPhysical = 0;
    }
+         
+   I810SetTiledMemory(pScrn, 1,
+		      pI810->DepthBuffer.Start,
+		      i810_pitches[i],
+		      back_size);
+   
+   I810SetTiledMemory(pScrn, 2,
+		      pI810->BackBuffer.Start,
+		      i810_pitches[i],
+		      back_size);
+   
+   pI810->auxPitch = i810_pitches[i];
+   pI810->auxPitchBits = i810_pitch_flags[i];
+   
+   pI810->SavedDcacheMem = pI810->DcacheMem;
+   
+   pI810DRI->backbufferSize = pI810->BackBuffer.Size;
+   ErrorF("Backbuffer map : %lx\n", pI810->BackBuffer.Start);
+   if (drmAddMap(pI810->drmSubFD, (drmHandle)pI810->BackBuffer.Start,
+		 pI810->BackBuffer.Size, DRM_AGP, 0, 
+		 &pI810DRI->backbuffer) < 0) {
+      ErrorF("drmAddMap(backbuffer) failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   
+   ErrorF("Depth map : %lx\n", pI810->DepthBuffer.Start);
+   pI810DRI->depthbufferSize = pI810->DepthBuffer.Size;
+   if (drmAddMap(pI810->drmSubFD, (drmHandle)pI810->DepthBuffer.Start,
+		 pI810->DepthBuffer.Size, DRM_AGP, 0, 
+		 &pI810DRI->depthbuffer) < 0) {
+      ErrorF("drmAddMap(depthbuffer) failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   
+   /* Allocate FrontBuffer etc. */
+   I810AllocateFront(pScrn);
+
+   /* Allocate buffer memory */
+   I810AllocHigh( &(pI810->BufferMem), &(pI810->SysMem), 
+		32 * 16384);
+   
+   ErrorF("Buffer map : %lx\n", pI810->BufferMem.Start);
+   if(drmAddMap(pI810->drmSubFD, (drmHandle)pI810->BufferMem.Start,
+		pI810->BufferMem.Size, DRM_AGP, 0,
+		&pI810->buffer_map) < 0) {
+      ErrorF("drmAddMap(buffer_map) failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
 
+   pI810DRI->agp_buffers = pI810->buffer_map;
+   pI810DRI->agp_buf_size = pI810->BufferMem.Size;
 
-#if 0
+   ErrorF("Ring map : %lx\n", pI810->LpRing.mem.Start);
+   if (drmAddMap(pI810->drmSubFD, (drmHandle)pI810->LpRing.mem.Start,
+		 pI810->LpRing.mem.Size, DRM_AGP, 0,
+		 &pI810->ring_map) < 0) {
+      ErrorF("drmAddMap(ring_map) failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   
+   /* Use the rest of memory for textures. */
+   
+   if(pI810->SysMem.Size < 524288) {
+      ErrorF("Less then 512k for textures\n");
+      DRICloseScreen(pScreen);
+   }
+   
+   I810AllocLow( &(pI810->TexMem), &(pI810->SysMem),
+		pI810->SysMem.Size);
+   
+   ErrorF("Texture map : %lx\n", pI810->LpRing.mem.Start);
+   if (drmAddMap(pI810->drmSubFD, (drmHandle)pI810->TexMem.Start,
+		 pI810->TexMem.Size, DRM_AGP, 0,
+		 &pI810DRI->textures) < 0) {
+      ErrorF("drmAddMap(textures) failed\n");
+      DRICloseScreen(pScreen);
+      return FALSE;
+   }
+   
+   ErrorF("pI810->BufferMem.Start : %lx\n", pI810->BufferMem.Start);
    if((bufs = drmAddBufs(pI810->drmSubFD,
-			 63,
-			 65536,
-			 DRM_AGP_BUFFER)) <= 0) {
+			 32,
+			 16384,
+			 DRM_AGP_BUFFER, pI810->BufferMem.Start)) <= 0) {
       xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 		 "[drm] failure adding %d %d byte DMA buffers\n",
-		 63,
-		 65536);
+		 32,
+		 16384);
       DRICloseScreen(pScreen);
       return FALSE;
    }
 
    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "[drm] added %d %d byte DMA buffers\n",
-	      bufs, 65536);
+	      bufs, 16384);
+
+   I810drmInitDma(pScrn);
+   
 
    if (!(pI810DRI->drmBufs = drmMapBufs(pI810->drmSubFD))) { 
       xf86DrvMsg(pScrn->scrnIndex, X_INFO,
@@ -425,6 +614,8 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
 	      pI810DRI->drmBufs);
    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "[drm] %d DMA buffers mapped\n",
 	      pI810DRI->drmBufs->count);
+   
+   /* Okay now initialize the dma engine */
 
    if (!pI810DRI->irq) {
       pI810DRI->irq = drmGetInterruptFromBusID(pI810->drmSubFD,
@@ -434,22 +625,46 @@ Bool I810DRIScreenInit(ScreenPtr pScreen)
 						->thisCard)->devnum,
 					       ((pciConfigPtr)pI810->PciInfo
 						->thisCard)->funcnum);
+      drmCtlInstHandler(pI810->drmSubFD, pI810DRI->irq);
    }
 
    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 	      "[drm] dma control initialized, using IRQ %d\n",
 	      pI810DRI->irq);
    
-#endif
+   pI810DRI=(I810DRIPtr)pI810->pDRIInfo->devPrivate;
+   pI810DRI->deviceID=pI810->PciInfo->chipType;
+   pI810DRI->width=pScrn->virtualX;
+   pI810DRI->height=pScrn->virtualY;
+   pI810DRI->mem=pScrn->videoRam*1024;
+   pI810DRI->cpp=pI810->cpp;
+   
+   pI810DRI->fbOffset=pI810->FrontBuffer.Start;
+   pI810DRI->fbStride=pI810->auxPitch;
+   
+   pI810DRI->bitsPerPixel = pScrn->bitsPerPixel;
+   
+   
+   pI810DRI->textureOffset=pI810->TexMem.Start;
+   pI810DRI->textureSize=pI810->TexMem.Size;
+   
+   pI810DRI->backOffset=pI810->BackBuffer.Start;
+   pI810DRI->depthOffset=pI810->DepthBuffer.Start;
+   
+   pI810DRI->ringOffset=pI810->LpRing.mem.Start;
+   pI810DRI->ringSize=pI810->LpRing.mem.Size;
+   
+   pI810DRI->auxPitch = pI810->auxPitch;
+   pI810DRI->auxPitchBits = pI810->auxPitchBits;
 
    if (!(I810InitVisualConfigs(pScreen))) {
       ErrorF("I810InitVisualConfigs failed\n");
       DRICloseScreen(pScreen);
       return FALSE;
    }
-   xf86DrvMsg(pScrn->scrnIndex, X_INFO, "visual configs initialized\n" );
-
-   return TRUE;
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, "visual configs initialized\n" );
+      
+      return TRUE;
 }
 
 void
@@ -458,6 +673,8 @@ I810DRICloseScreen(ScreenPtr pScreen)
   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
   I810Ptr pI810 = I810PTR(pScrn);
 
+   I810drmCleanupDma(pScrn);
+
   DRICloseScreen(pScreen);
 
   if (pI810->pDRIInfo) {
@@ -506,7 +723,7 @@ I810DRIFinishScreenInit(ScreenPtr pScreen)
    I810DRIPtr pI810DRI = (I810DRIPtr) pI810->pDRIInfo->devPrivate;
    I810SAREAPriv *sPriv = (I810SAREAPriv *)DRIGetSAREAPrivate(pScreen);
    int i;
-
+   
    pI810->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT;
 
    pI810DRI->deviceID=pI810->PciInfo->chipType;
@@ -526,7 +743,6 @@ I810DRIFinishScreenInit(ScreenPtr pScreen)
    pI810DRI->auxPitch = pI810->auxPitch;
    pI810DRI->auxPitchBits = pI810->auxPitchBits;
 
-
 #define I810_LOG_MIN_TEX_REGION_SIZE 18
 
    i = mylog2(pI810DRI->textureSize / I810_NR_TEX_REGIONS);
@@ -545,7 +761,6 @@ I810DRIFinishScreenInit(ScreenPtr pScreen)
    return DRIFinishScreenInit(pScreen);
 }
 
-
 void
 I810DRISwapContext(ScreenPtr pScreen, DRISyncType syncType, 
 		   DRIContextType oldContextType, void *oldContext,
diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.h b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.h
index 3d090ab7f..9745f5516 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.h
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_dri.h
@@ -12,6 +12,14 @@ typedef struct {
    drmHandle regs;
    drmSize regsSize;
    drmAddress regsMap;
+   drmSize backbufferSize;
+   drmHandle backbuffer;
+   drmSize depthbufferSize;
+   drmHandle depthbuffer;
+   drmHandle textures;
+   drmHandle agp_buffers;
+   drmSize agp_buf_size;
+   
    int deviceID;
    int width;
    int height;
diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c
index 2557f22aa..ff5e66b75 100644
--- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c
+++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c
@@ -255,23 +255,6 @@ static const char *driSymbols[] = {
 #endif
 
 
-static int i810_pitches[] = {
-   512,
-   1024,
-   2048,
-   4096,
-   0
-};
-
-static int i810_pitch_flags[] = {
-    0x0,
-    0x1,
-    0x2,
-    0x3,
-    0
-};
-
-
 #ifndef I810_DEBUG
 int I810_DEBUG = (0
 /*     		  | DEBUG_ALWAYS_SYNC  */
@@ -285,7 +268,15 @@ int I810_DEBUG = (0
    );
 #endif
 
-
+#ifdef XF86DRI
+static int i810_pitches[] = {
+   512,
+   1024,
+   2048,
+   4096,
+   0
+};
+#endif
 
 #ifdef XFree86LOADER
 
@@ -1175,6 +1166,7 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
    temp |= i810Reg->PixelPipeCfg1;
    OUTREG8( PIXPIPE_CONFIG_1, temp );
 
+#if 0
    stemp = INREG16(HWSTAM);
    stemp &= INTR_RESERVED;
    stemp |= i810Reg->IntrHwStatMask;
@@ -1189,14 +1181,15 @@ DoRestore(ScrnInfoPtr pScrn, vgaRegPtr vgaReg, I810RegPtr i810Reg,
    stemp &= INTR_RESERVED;
    stemp |= i810Reg->IntrMask;
    OUTREG16(IMR, stemp);
-
+#endif
+   
    OUTREG16(EIR, 0);
-
+#if 0
    stemp = INREG16(EMR);
    stemp &= ERROR_RESERVED;
    stemp |= i810Reg->ErrorMask;
    OUTREG16(EMR, stemp);
-
+#endif
 
    itemp = INREG(FWATER_BLC);
    itemp &= ~(LM_BURST_LENGTH | LM_FIFO_WATERMARK | 
@@ -1444,12 +1437,12 @@ I810SetMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
 
    /* Calculate the FIFO Watermark and Burst Length. */
    i810Reg->LMI_FIFO_Watermark = I810CalcWatermark(pScrn, dclk, FALSE);
-
+#if 0
    i810Reg->IntrHwStatMask = ~INTR_RESERVED;
    i810Reg->IntrEnabled = 0x0000;
    i810Reg->IntrIdentity = 0x0000;
    i810Reg->IntrMask = ~INTR_RESERVED;	/* unmask all interrupts */
-  
+#endif
    i810Reg->ErrorMask = 0;
     
    /* Setup the ring buffer */
@@ -1568,8 +1561,72 @@ I810LoadPalette24(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors,
    }
 }
 
+Bool
+I810AllocateFront(ScrnInfoPtr pScrn) {
+   I810Ptr pI810 = I810PTR(pScrn);
+   BoxRec MemBox;
+
+   if(pI810->DoneFrontAlloc == TRUE) {
+      return TRUE;
+   }
+   
+   memset(&(pI810->FbMemBox), 0, sizeof(BoxRec));
+   /* Alloc FrontBuffer/Ring/Accel memory */
+   pI810->FbMemBox.x1=0;
+   pI810->FbMemBox.x2=pScrn->displayWidth;
+   pI810->FbMemBox.y1=0;
+   pI810->FbMemBox.y2=pScrn->virtualY;
+   
+   /* Make sure there is room for pixcache either beside or below
+    * the screen.
+    */
+   if (pScrn->displayWidth < pScrn->virtualX + 64) 
+      MemBox.y2 += 64;
 
+   /* Reserve room for the framebuffer and pixcache.  Put at the top
+    * of memory so we can have nice alignment for the tiled regions at
+    * the start of memory.
+    */
+   I810AllocLow( &(pI810->FrontBuffer), 
+		 &(pI810->SysMem), 
+		 ((pI810->FbMemBox.x2 * pI810->FbMemBox.y2 * pI810->cpp) + 4095) & ~4095);
+   
+   fprintf(stderr, "Framebuffer %x, size %x\n", 
+	   pI810->FrontBuffer.Start,
+	   pI810->FrontBuffer.Size);
+   
+   fprintf(stderr, "DisplayWidth %x, virtualX %x\n", 
+	   pScrn->displayWidth,
+	   pScrn->virtualX);
+   
+   memset( &(pI810->LpRing), 0, sizeof( I810RingBuffer ) );
+   if(
+#ifdef XF86DRI
+      I810AllocLow( &(pI810->LpRing.mem), &(pI810->SysMem), 64*4096 )||
+#endif
+      I810AllocLow( &(pI810->LpRing.mem), &(pI810->SysMem), 4096 )
+      ) {
 
+	 if (I810_DEBUG & DEBUG_VERBOSE_MEMORY)
+	    ErrorF( "ring buffer at local %lx\n", 
+		    pI810->LpRing.mem.Start);
+
+	 pI810->LpRing.tail_mask = pI810->LpRing.mem.Size - 1;
+	 pI810->LpRing.virtual_start = pI810->FbBase + pI810->LpRing.mem.Start;
+	 pI810->LpRing.head = 0;
+	 pI810->LpRing.tail = 0;      
+	 pI810->LpRing.space = 0;		 
+   }
+   
+   if ( I810AllocLow( &pI810->Scratch, &(pI810->SysMem), 64*1024 ) || 
+	I810AllocLow( &pI810->Scratch, &(pI810->SysMem), 16*1024 ) ) {
+      xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
+		 "Allocated Scratch Memory\n");
+   }
+   
+   pI810->DoneFrontAlloc = TRUE;
+   return TRUE;
+}
 
 static Bool
 I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) {
@@ -1577,7 +1634,6 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) {
    vgaHWPtr hwp;
    I810Ptr pI810;
    VisualPtr visual;
-   BoxRec MemBox;
 
    pScrn = xf86Screens[pScreen->myNum];
    pI810 = I810PTR(pScrn);
@@ -1712,70 +1768,25 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) {
       }
    }
 #endif
-
    
-   MemBox.x1=0;
-   MemBox.x2=pScrn->displayWidth;
-   MemBox.y1=0;
-   MemBox.y2=pScrn->virtualY;
-   
-   /* Make sure there is room for pixcache either beside or below
-    * the screen.
-    */
-   if (pScrn->displayWidth < pScrn->virtualX + 64) 
-      MemBox.y2 += 64;
-
-
-   /* Reserve room for the framebuffer and pixcache.  Put at the start
-    * of memory because it's difficult to put it anywhere else.
-    */
-   I810AllocLow( &(pI810->FrontBuffer), 
-		 &(pI810->SysMem), 
-		 ((MemBox.x2 * MemBox.y2 * pI810->cpp) + 4095) & ~4095);
-
-   
-   ErrorF("Framebuffer 0x%x, size 0x%x\n", 
-	   pI810->FrontBuffer.Start,
-	   pI810->FrontBuffer.Size);
+   if (pI810->directRenderingEnabled == FALSE) {
+      pI810->DoneFrontAlloc = FALSE;
+      I810AllocateFront(pScrn);
+   }
    
-   ErrorF("DisplayWidth %d, virtualX %d\n", 
-	   pScrn->displayWidth,
-	   pScrn->virtualX);
-
-
-   if (!xf86InitFBManager(pScreen, &MemBox)) {
+   if (!xf86InitFBManager(pScreen, &(pI810->FbMemBox))) {
       xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 
 		 "Failed to init memory manager\n");
       return FALSE;
    }
 
-
-
-   xf86memset( &(pI810->LpRing), 0, sizeof( I810RingBuffer ) );
-
    if (!xf86ReturnOptValBool(I810Options, OPTION_NOACCEL, FALSE)) {     
-      if (
-#ifdef XF86DRI
-	 I810AllocLow( &(pI810->LpRing.mem), &(pI810->SysMem), 64*4096 ) ||
-#endif
-	 I810AllocLow( &(pI810->LpRing.mem), &(pI810->SysMem), 4096 )
-	 ) {
-
-	 if (I810_DEBUG & DEBUG_VERBOSE_MEMORY)
-	    ErrorF( "ring buffer at local %lx\n", 
-		    pI810->LpRing.mem.Start);
-
-	 pI810->LpRing.tail_mask = pI810->LpRing.mem.Size - 1;
-	 pI810->LpRing.virtual_start = pI810->FbBase + pI810->LpRing.mem.Start;
-	 pI810->LpRing.head = 0;
-	 pI810->LpRing.tail = 0;      
-	 pI810->LpRing.space = 0;		 
-
+      if (pI810->LpRing.mem.Size != 0) {
 	 I810SetRingRegs( pScrn );
-
+	 
 	 if (!I810AccelInit(pScreen)) {
 	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
-		       "Hardware acceleration initialization failed\n");
+		       "Hardware acceleration initialization failed\n");  
 	 }
       }
    }
@@ -1787,70 +1798,10 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) {
       }
    }
 
-
-#ifdef XF86DRI
-#define Elements(x) sizeof(x)/sizeof(*x)
    if (pI810->LpRing.mem.Start == 0) {
       pI810->directRenderingEnabled = 0;
       I810DRICloseScreen(pScreen);
    }
-
-   if (pI810->directRenderingEnabled) {
-      int width = MemBox.x2 * pI810->cpp;
-      int i;
-      
-      for (i = 0 ; i < Elements(i810_pitches) ; i++) 
-	 if (width <= i810_pitches[i]) 
-	    break;
-
-      if (i == Elements(i810_pitches)) {
-	 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
-		    "Couldn't find depth/back buffer pitch");
-	 pI810->directRenderingEnabled = 0;
-	 I810DRICloseScreen(pScreen);
-      }
-      else {
-	 int sz = i810_pitches[i] * pScrn->virtualY;
-
-	 /* Round to 512K for tiling - potentially wasteful.
-	  */
-	 sz += 0x7ffff;
-	 sz &= ~0x7ffff;
-	 
-	 if (I810AllocHigh(&(pI810->BackBuffer), &(pI810->SysMem), sz) &&
-	     (I810AllocLow(&(pI810->DepthBuffer), &(pI810->DcacheMem), sz) || 
-	      I810AllocHigh(&(pI810->DepthBuffer), &(pI810->SysMem), sz)))
-	 {	    
-	    /* Set up tiled regions for depth and back buffers.
-	     */
-	    if (1) {
-	       I810SetTiledMemory( pScrn, 1,
-				   pI810->DepthBuffer.Start,
-				   i810_pitches[i],
-				   sz );
-	       
-	       I810SetTiledMemory( pScrn, 2,
-				   pI810->BackBuffer.Start,
-				   i810_pitches[i],
-				   sz );
-	    }
-	    
-	    /* Use the rest of memory for textures.
-	     */
-	    I810AllocLow( &(pI810->TexMem), &(pI810->SysMem),
-			  pI810->SysMem.Size);
-	    pI810->auxPitch = i810_pitches[i];
-	    pI810->auxPitchBits = i810_pitch_flags[i];
-	 }
-	 else 
-	 {
-	    xf86DrvMsg(pScrn->scrnIndex, X_INFO, 
-		       "Insufficient memory for back and/or depth buffers\n");
-	    pI810->directRenderingEnabled = 0;
-	    I810DRICloseScreen(pScreen);
-	 }
-      }
-   } 
 	 
    if (pI810->directRenderingEnabled) {
       /* Now that mi, cfb, drm and others have done their thing, 
@@ -1867,12 +1818,6 @@ I810ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) {
 	 return FALSE;	 
    }
 
-#else
-   if (!I810AllocateGARTMemory( pScrn )) {
-      return FALSE;
-   }
-#endif
-
    pScreen->SaveScreen = I810SaveScreen;
    pI810->CloseScreen = pScreen->CloseScreen;
    pScreen->CloseScreen = I810CloseScreen;