Pull XORG-6_8_0 to CYGWIN branchCYGWIN-6_8_2-MERGECYGWIN-6_8_1-MERGECYGWIN-6_8_0-MERGECYGWIN

17 files changed, 4274 insertions, 817 deletions

diff --git a/src/savage_accel.c b/src/savage_accel.c
index e995a6e..680ae1e 100644
--- a/src/savage_accel.c
+++ b/src/savage_accel.c
@@ -23,6 +23,7 @@
 #include "savage_driver.h"
 #include "savage_regs.h"
 #include "savage_bci.h"
+#include "savage_streams.h"
 
 /* Forward declaration of functions used in the driver */
 
@@ -47,7 +48,7 @@ static void SavageSetupForSolidFill(
     ScrnInfoPtr pScrn,
     int color, 
     int rop,
-    unsigned planemask);
+    unsigned int planemask);
 
 static void SavageSubsequentSolidFillRect(
     ScrnInfoPtr pScrn,
@@ -82,7 +83,7 @@ static void SavageSetupForScreenToScreenColorExpand(
     int bg,
     int fg,
     int rop,
-    unsigned planemask);
+    unsigned int planemask);
 
 static void SavageSubsequentScreenToScreenColorExpand(
     ScrnInfoPtr pScrn,
@@ -98,7 +99,7 @@ static void SavageSetupForCPUToScreenColorExpandFill(
     int fg,
     int bg,
     int rop,
-    unsigned planemask);
+    unsigned int planemask);
 
 static void SavageSubsequentScanlineCPUToScreenColorExpandFill(
     ScrnInfoPtr pScrn,
@@ -119,7 +120,7 @@ static void SavageSetupForMono8x8PatternFill(
     int fg, 
     int bg,
     int rop,
-    unsigned planemask);
+    unsigned int planemask);
 
 static void SavageSubsequentMono8x8PatternFillRect(
     ScrnInfoPtr pScrn,
@@ -421,7 +422,10 @@ SavageInitAccel(ScreenPtr pScreen)
 #if 1
     xaaptr->SetupForScreenToScreenCopy = SavageSetupForScreenToScreenCopy;
     xaaptr->SubsequentScreenToScreenCopy = SavageSubsequentScreenToScreenCopy;
-    xaaptr->ScreenToScreenCopyFlags = NO_TRANSPARENCY | NO_PLANEMASK | ROP_NEEDS_SOURCE;
+    xaaptr->ScreenToScreenCopyFlags = 0
+	| NO_TRANSPARENCY
+	| NO_PLANEMASK
+	| ROP_NEEDS_SOURCE;
 #endif
 
 
@@ -492,7 +496,7 @@ SavageInitAccel(ScreenPtr pScreen)
     xaaptr->SubsequentSolidFillTrap = SavageSubsequentSolidFillTrap; 
 #endif
 
-    xaaptr->SolidBresenhamLineErrorTermBits = 14;
+    xaaptr->SolidBresenhamLineErrorTermBits = 13;
 #endif
 
     /* ImageWrite */
@@ -594,7 +598,7 @@ SavageAccelSync(ScrnInfoPtr pScrn)
  */
 
 static int
-SavageHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
+SavageHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, unsigned int pm, int *rop)
 {
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int ret = 0;
@@ -604,7 +608,7 @@ SavageHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
     if(pm == infoRec->FullPlanemask) {
 	if(!NO_SRC_ROP(*rop)) 
 	   ret |= ROP_PAT;
-	*rop = XAACopyROP[*rop];
+	*rop = XAAGetCopyROP(*rop);
     } else {	
 	switch(*rop) {
 	case GXnoop:
@@ -621,7 +625,7 @@ SavageHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
 	    ret |= ROP_PAT | ROP_SRC;
 	    break;
 	}
-	*rop = XAACopyROP_PM[*rop];
+	*rop = XAAGetCopyROP_PM(*rop);
     }
 
     return ret;
@@ -629,7 +633,7 @@ SavageHelpPatternROP(ScrnInfoPtr pScrn, int *fg, int *bg, int pm, int *rop)
 
 
 static int
-SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg, int pm, int *rop)
+SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg, unsigned int pm, int *rop)
 {
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int ret = 0;
@@ -639,7 +643,7 @@ SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg, int pm, int *rop)
     if(pm == infoRec->FullPlanemask) {
 	if(!NO_SRC_ROP(*rop)) 
 	   ret |= ROP_PAT;
-	*rop = XAACopyROP[*rop];
+	*rop = XAAGetCopyROP(*rop);
     } else {	
 	switch(*rop) {
 	case GXnoop:
@@ -654,7 +658,7 @@ SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg, int pm, int *rop)
 	    ret |= ROP_PAT | ROP_SRC;
 	    break;
 	}
-	*rop = XAACopyROP_PM[*rop];
+	*rop = XAAGetCopyROP_PM(*rop);
     }
 
     return ret;
@@ -682,7 +686,7 @@ SavageSetupForScreenToScreenCopy(
     int cmd;
 
     cmd = BCI_CMD_RECT | BCI_CMD_DEST_GBD | BCI_CMD_SRC_GBD;
-    BCI_CMD_SET_ROP( cmd, XAACopyROP[rop] );
+    BCI_CMD_SET_ROP( cmd, XAAGetCopyROP(rop) );
     if (transparency_color != -1)
         cmd |= BCI_CMD_SEND_COLOR | BCI_CMD_SRC_TRANSPARENT;
 
@@ -722,7 +726,7 @@ SavageSubsequentScreenToScreenCopy(
 
     psav->WaitQueue(psav,6);
     BCI_SEND(psav->SavedBciCmd);
-    if (psav->SavedBgColor != -1) 
+    if (psav->SavedBgColor != 0xffffffff) 
 	BCI_SEND(psav->SavedBgColor);
     BCI_SEND(BCI_X_Y(x1, y1));
     BCI_SEND(BCI_X_Y(x2, y2));
@@ -739,7 +743,7 @@ SavageSetupForSolidFill(
     ScrnInfoPtr pScrn,
     int color, 
     int rop,
-    unsigned planemask)
+    unsigned int planemask)
 {
     SavagePtr psav = SAVPTR(pScrn);
     XAAInfoRecPtr xaaptr = GET_XAAINFORECPTR_FROM_SCRNINFOPTR( pScrn );
@@ -756,7 +760,7 @@ SavageSetupForSolidFill(
     {
 	if( color == 0 )
 	    rop = GXclear;
-	else if( color == xaaptr->FullPlanemask )
+	else if( (unsigned int)color == xaaptr->FullPlanemask )
 	    rop = GXset;
     }
 
@@ -802,7 +806,7 @@ SavageSetupForScreenToScreenColorExpand(
     int bg,
     int fg,
     int rop,
-    unsigned planemask)
+    unsigned int planemask)
 {
 /*    SavagePtr psav = SAVPTR(pScrn); */
 }
@@ -827,7 +831,7 @@ SavageSetupForCPUToScreenColorExpandFill(
     int fg,
     int bg,
     int rop,
-    unsigned planemask)
+    unsigned int planemask)
 {
     SavagePtr psav = SAVPTR(pScrn);
     int cmd;
@@ -877,7 +881,7 @@ SavageSubsequentScanlineCPUToScreenColorExpandFill(
     w = (w + 31) & ~31;
     if( psav->SavedBciCmd & BCI_CMD_SEND_COLOR )
 	BCI_SEND(psav->SavedFgColor);
-    if( psav->SavedBgColor != -1 )
+    if( psav->SavedBgColor != 0xffffffff )
 	BCI_SEND(psav->SavedBgColor);
     BCI_SEND(BCI_X_Y(x, y));
     BCI_SEND(BCI_W_H(w, 1));
@@ -929,7 +933,7 @@ SavageSetupForMono8x8PatternFill(
     int fg, 
     int bg,
     int rop,
-    unsigned planemask)
+    unsigned int planemask)
 {
     SavagePtr psav = SAVPTR(pScrn);
     int cmd;
@@ -980,7 +984,7 @@ SavageSubsequentMono8x8PatternFillRect(
     BCI_SEND(psav->SavedBciCmd);
     if( psav->SavedBciCmd & BCI_CMD_SEND_COLOR )
 	BCI_SEND(psav->SavedFgColor);
-    if( psav->SavedBgColor != -1 )
+    if( psav->SavedBgColor != 0xffffffff )
 	BCI_SEND(psav->SavedBgColor);
     BCI_SEND(BCI_X_Y(x, y));
     BCI_SEND(BCI_W_H(w, h));
diff --git a/src/savage_bci.h b/src/savage_bci.h
index f5d44e3..0c57957 100644
--- a/src/savage_bci.h
+++ b/src/savage_bci.h
@@ -10,10 +10,10 @@
     dword |= (temp & 0xFF0000) >> 8; \
     dword |= (temp & 0xFF000000) >> 24; }
 
-#define BCI_GET_PTR volatile unsigned int * bci_ptr = (unsigned int *) psav->BciMem
-#define BCI_RESET bci_ptr = (unsigned int *) psav->BciMem
+#define BCI_GET_PTR volatile CARD32 * bci_ptr = (CARD32 *) psav->BciMem
+#define BCI_RESET bci_ptr = (CARD32 *) psav->BciMem
 
-#define BCI_SEND(dw)   (*bci_ptr++ = (unsigned int)(dw))
+#define BCI_SEND(dw)   (*bci_ptr++ = (CARD32)(dw))
 
 #define BCI_CMD_NOP                  0x40000000
 #define BCI_CMD_RECT                 0x48000000
diff --git a/src/savage_cursor.c b/src/savage_cursor.c
index 60fa45d..ad4aa9f 100644
--- a/src/savage_cursor.c
+++ b/src/savage_cursor.c
@@ -81,7 +81,7 @@ SavageHWCursorInit(ScreenPtr pScreen)
 		     HARDWARE_CURSOR_AND_SOURCE_WITH_MASK |
 		     HARDWARE_CURSOR_BIT_ORDER_MSBFIRST |
 	             HARDWARE_CURSOR_INVERT_MASK;
-
+#if 0
     /*
      * The /MX family is apparently unique among the Savages, in that
      * the cursor color is always straight RGB.  The rest of the Savages
@@ -94,7 +94,10 @@ SavageHWCursorInit(ScreenPtr pScreen)
 	||
 	S3_SAVAGE_MOBILE_SERIES(psav->Chipset)
       )
-         infoPtr->Flags |= HARDWARE_CURSOR_TRUECOLOR_AT_8BPP; 
+	infoPtr->Flags |= HARDWARE_CURSOR_TRUECOLOR_AT_8BPP; 
+#endif
+    /* With streams engine the Cursor seems to be ALWAYS TrueColor */
+    infoPtr->Flags |= HARDWARE_CURSOR_TRUECOLOR_AT_8BPP; 
 
     infoPtr->SetCursorColors = SavageSetCursorColors;
     infoPtr->SetCursorPosition = SavageSetCursorPosition;
@@ -144,8 +147,8 @@ SavageLoadCursorImage(
     SavagePtr psav = SAVPTR(pScrn);
 
     /* Set cursor location in frame buffer.  */
-    outCRReg( 0x4d, (0xff & psav->CursorKByte));
-    outCRReg( 0x4c, (0xff00 & psav->CursorKByte) >> 8);
+    outCRReg( 0x4d, (0xff & (CARD32)psav->CursorKByte));
+    outCRReg( 0x4c, (0xff00 & (CARD32)psav->CursorKByte) >> 8);
 
     /* Upload the cursor image to the frame buffer. */
     memcpy(psav->FBBase + psav->CursorKByte * 1024, src, 1024);
@@ -225,11 +228,14 @@ SavageSetCursorColors(
     bNeedExtra =
         (psav->CursorInfoRec->Flags & HARDWARE_CURSOR_TRUECOLOR_AT_8BPP);
 
-    if(
-        S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
-	(pScrn->depth == 24) ||
-	((pScrn->depth == 8) && bNeedExtra)
-    )
+    /* With the streams engine on HW Cursor seems to be 24bpp ALWAYS */
+    if( 1 
+#if 0
+	|| S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
+ 	(pScrn->depth == 24) ||
+ 	((pScrn->depth == 8) && bNeedExtra)
+#endif
+	) 
     {
 	/* Do it straight, full 24 bit color. */
       
@@ -247,6 +253,7 @@ SavageSetCursorColors(
 	outCRReg(0x4b, bg >> 16);
 	return;
     }
+#if 0
     else if( (pScrn->depth == 15) || (pScrn->depth == 16) )
     {
 	if (pScrn->depth == 15) {
@@ -296,4 +303,5 @@ SavageSetCursorColors(
 	outCRReg(0x4b, bg);
 	outCRReg(0x4b, bg);
     }
+#endif
 }
diff --git a/src/savage_dri.c b/src/savage_dri.c
new file mode 100644
index 0000000..08fa24d
--- /dev/null
+++ b/src/savage_dri.c
@@ -0,0 +1,2172 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+#ifdef XF86DRI
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+#include "xf86Priv.h"
+
+#include "xaalocal.h"
+#include "xaarop.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#include "xf86fbman.h"
+
+#if 0
+#define PSZ 8
+#include "cfb.h"
+#undef PSZ
+#include "cfb16.h"
+#include "cfb32.h"
+#endif
+
+#include "miline.h"
+
+
+/*#include "savage_vbe.h"*/
+#include "savage_regs.h"
+#include "savage_driver.h"
+#include "savage_bci.h"
+
+#define _XF86DRI_SERVER_
+#include "GL/glxtokens.h"
+#include "sarea.h"
+#include "savage_dri.h"
+#include "savage_sarea.h"
+
+static char SAVAGEKernelDriverName[] = "savage";
+static char SAVAGEClientDriverName[] = "savage";
+
+static Bool SAVAGEDRIOpenFullScreen(ScreenPtr pScreen);
+static Bool SAVAGEDRICloseFullScreen(ScreenPtr pScreen);
+/* DRI buffer management
+ */
+void SAVAGEDRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+				CARD32 index );
+void SAVAGEDRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+				RegionPtr prgnSrc, CARD32 index );
+
+/*        almost the same besides set src/desc to */
+/*        Primary Bitmap Description              */
+
+static void 
+SAVAGEDRISetupForScreenToScreenCopy(
+    ScrnInfoPtr pScrn, int xdir, int ydir,
+    int rop, unsigned planemask, int transparency_color);
+
+
+static void 
+SAVAGEDRISubsequentScreenToScreenCopy(
+    ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2,
+    int w, int h);
+
+
+static void 
+SAVAGEDRISetupForSolidFill(
+    ScrnInfoPtr pScrn, int color, int rop, unsigned planemask);
+
+
+static void 
+SAVAGEDRISubsequentSolidFillRect(
+    ScrnInfoPtr pScrn, int x, int y, int w, int h);
+
+#if 0
+extern int
+SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg,int pm,int *rop);
+#endif
+unsigned long SAVAGEDRIGetPhyAddress(ScrnInfoPtr pScrn,void * pointer);
+
+/* Initialize the visual configs that are supported by the hardware.
+ * These are combined with the visual configs that the indirect
+ * rendering core supports, and the intersection is exported to the
+ * client.
+ */
+static Bool SAVAGEInitVisualConfigs( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   int numConfigs = 0;
+   __GLXvisualConfig *pConfigs = 0;
+   SAVAGEConfigPrivPtr pSAVAGEConfigs = 0;
+   SAVAGEConfigPrivPtr *pSAVAGEConfigPtrs = 0;
+   int i, db, depth, stencil, accum;
+
+   switch ( pScrn->bitsPerPixel ) {
+   case 8:
+   case 24:
+      break;
+
+   case 16:
+      numConfigs = 8;
+
+      pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig),
+						numConfigs );
+      if ( !pConfigs ) {
+	 return FALSE;
+      }
+
+      pSAVAGEConfigs = (SAVAGEConfigPrivPtr)xcalloc( sizeof(SAVAGEConfigPrivRec),
+						 numConfigs );
+      if ( !pSAVAGEConfigs ) {
+	 xfree( pConfigs );
+	 return FALSE;
+      }
+
+      pSAVAGEConfigPtrs = (SAVAGEConfigPrivPtr*)xcalloc( sizeof(SAVAGEConfigPrivPtr),
+						     numConfigs );
+      if ( !pSAVAGEConfigPtrs ) {
+	 xfree( pConfigs );
+	 xfree( pSAVAGEConfigs );
+	 return FALSE;
+      }
+
+      for ( i = 0 ; i < numConfigs ; i++ ) {
+	 pSAVAGEConfigPtrs[i] = &pSAVAGEConfigs[i];
+      }
+
+      i = 0;
+      depth = 1;
+      for ( accum = 0 ; accum <= 1 ; accum++ ) {
+         for ( stencil = 0 ; stencil <= 1 ; stencil++ ) {
+            for ( db = 1 ; db >= 0 ; db-- ) {
+               pConfigs[i].vid			= -1;
+               pConfigs[i].class		= -1;
+               pConfigs[i].rgba			= TRUE;
+               pConfigs[i].redSize		= 5;
+               pConfigs[i].greenSize		= 6;
+               pConfigs[i].blueSize		= 5;
+               pConfigs[i].alphaSize		= 0;
+               pConfigs[i].redMask		= 0x0000F800;
+               pConfigs[i].greenMask		= 0x000007E0;
+               pConfigs[i].blueMask		= 0x0000001F;
+               pConfigs[i].alphaMask		= 0;
+               if ( accum ) {
+                  pConfigs[i].accumRedSize	= 16;
+                  pConfigs[i].accumGreenSize	= 16;
+                  pConfigs[i].accumBlueSize	= 16;
+                  pConfigs[i].accumAlphaSize	= 0;
+               } else {
+                  pConfigs[i].accumRedSize	= 0;
+                  pConfigs[i].accumGreenSize	= 0;
+                  pConfigs[i].accumBlueSize	= 0;
+                  pConfigs[i].accumAlphaSize	= 0;
+               }
+               if ( db ) {
+                  pConfigs[i].doubleBuffer	= TRUE;
+               } else {
+                  pConfigs[i].doubleBuffer	= FALSE;
+	       }
+               pConfigs[i].stereo		= FALSE;
+               pConfigs[i].bufferSize		= 16;
+               if ( depth ) {
+                  pConfigs[i].depthSize		= 16;
+               } else {
+                  pConfigs[i].depthSize		= 0;
+	       }
+               if ( stencil ) {
+                  pConfigs[i].stencilSize	= 8;
+               } else {
+                  pConfigs[i].stencilSize	= 0;
+	       }
+               pConfigs[i].auxBuffers		= 0;
+               pConfigs[i].level		= 0;
+               if ( accum || stencil ) {
+                  pConfigs[i].visualRating	= GLX_SLOW_VISUAL_EXT;
+               } else {
+                  pConfigs[i].visualRating	= GLX_NONE_EXT;
+	       }
+               pConfigs[i].transparentPixel	= 0;
+               pConfigs[i].transparentRed	= 0;
+               pConfigs[i].transparentGreen	= 0;
+               pConfigs[i].transparentBlue	= 0;
+               pConfigs[i].transparentAlpha	= 0;
+               pConfigs[i].transparentIndex	= 0;
+               i++;
+            }
+         }
+      }
+      if ( i != numConfigs ) {
+         xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		     "[drm] Incorrect initialization of visuals\n" );
+         return FALSE;
+      }
+      break;
+
+   case 32:
+      numConfigs = 8;
+
+      pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig),
+						numConfigs );
+      if ( !pConfigs ) {
+	 return FALSE;
+      }
+
+      pSAVAGEConfigs = (SAVAGEConfigPrivPtr)xcalloc( sizeof(SAVAGEConfigPrivRec),
+						 numConfigs );
+      if ( !pSAVAGEConfigs ) {
+	 xfree( pConfigs );
+	 return FALSE;
+      }
+
+      pSAVAGEConfigPtrs = (SAVAGEConfigPrivPtr*)xcalloc( sizeof(SAVAGEConfigPrivPtr),
+						     numConfigs );
+      if ( !pSAVAGEConfigPtrs ) {
+	 xfree( pConfigs );
+	 xfree( pSAVAGEConfigs );
+	 return FALSE;
+      }
+
+      for ( i = 0 ; i < numConfigs ; i++ ) {
+	 pSAVAGEConfigPtrs[i] = &pSAVAGEConfigs[i];
+      }
+
+      i = 0;
+      for ( accum = 0 ; accum <= 1 ; accum++ ) {
+         for ( depth = 0 ; depth <= 1 ; depth++ ) { /* and stencil */
+            for ( db = 1 ; db >= 0 ; db-- ) {
+               pConfigs[i].vid			= -1;
+               pConfigs[i].class		= -1;
+               pConfigs[i].rgba			= TRUE;
+               pConfigs[i].redSize		= 8;
+               pConfigs[i].greenSize		= 8;
+               pConfigs[i].blueSize		= 8;
+               pConfigs[i].alphaSize		= 8;
+               pConfigs[i].redMask		= 0x00FF0000;
+               pConfigs[i].greenMask		= 0x0000FF00;
+               pConfigs[i].blueMask		= 0x000000FF;
+               pConfigs[i].alphaMask		= 0;
+               if ( accum ) {
+                  pConfigs[i].accumRedSize	= 16;
+                  pConfigs[i].accumGreenSize	= 16;
+                  pConfigs[i].accumBlueSize	= 16;
+                  pConfigs[i].accumAlphaSize	= 0;
+               } else {
+                  pConfigs[i].accumRedSize	= 0;
+                  pConfigs[i].accumGreenSize	= 0;
+                  pConfigs[i].accumBlueSize	= 0;
+                  pConfigs[i].accumAlphaSize	= 0;
+               }
+               if ( db ) {
+                  pConfigs[i].doubleBuffer	= TRUE;
+               } else {
+                  pConfigs[i].doubleBuffer	= FALSE;
+	       }
+               pConfigs[i].stereo		= FALSE;
+               pConfigs[i].bufferSize		= 32;
+               if ( depth ) {
+		     pConfigs[i].depthSize	= 24;
+                     pConfigs[i].stencilSize	= 8;
+               }
+               else {
+                     pConfigs[i].depthSize	= 0;
+                     pConfigs[i].stencilSize	= 0;
+               }
+               pConfigs[i].auxBuffers		= 0;
+               pConfigs[i].level		= 0;
+               if ( accum ) {
+                  pConfigs[i].visualRating	= GLX_SLOW_VISUAL_EXT;
+               } else {
+                  pConfigs[i].visualRating	= GLX_NONE_EXT;
+	       }
+               pConfigs[i].transparentPixel	= 0;
+               pConfigs[i].transparentRed	= 0;
+               pConfigs[i].transparentGreen	= 0;
+               pConfigs[i].transparentBlue	= 0;
+               pConfigs[i].transparentAlpha	= 0;
+               pConfigs[i].transparentIndex	= 0;
+               i++;
+            }
+         }
+      }
+      if ( i != numConfigs ) {
+         xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		     "[drm] Incorrect initialization of visuals\n" );
+         return FALSE;
+      }
+      break;
+
+   default:
+      /* Unexpected bits/pixels */
+      break;
+   }
+
+   psav->numVisualConfigs = numConfigs;
+   psav->pVisualConfigs = pConfigs;
+   psav->pVisualConfigsPriv = pSAVAGEConfigs;
+
+   GlxSetVisualConfigs( numConfigs, pConfigs, (void **)pSAVAGEConfigPtrs );
+
+   return TRUE;
+}
+
+static Bool SAVAGECreateContext( ScreenPtr pScreen, VisualPtr visual,
+			      drm_context_t hwContext, void *pVisualConfigPriv,
+			      DRIContextType contextStore )
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SavagePtr psav = SAVPTR(pScrn);
+    SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+    savageAgpBufferPtr pAgp;
+    
+    int ret,size,i;
+    unsigned long  handle,map_handle;
+    drm_savage_sarea_t * pShare;
+    unsigned long offset;
+   
+    if(psav->xvmcContext)
+        return FALSE;
+    else
+    {
+        psav->DRIrunning++;
+    }
+    /* alloc agp memory to dma */
+    pShare = (drm_savage_sarea_ptr)DRIGetSAREAPrivate(pScreen);
+    pShare->agp_offset=0;
+    /* find the available buffer*/
+    for (i=0,pAgp = pSAVAGEDRIServer->agpBuffer;i<pSAVAGEDRIServer->numBuffer;i++,pAgp++)
+    {
+        if (pAgp->flags==0)
+            break;
+    }
+    if (i >= pSAVAGEDRIServer->numBuffer)
+    {
+        return TRUE;
+    }
+          
+    offset=pAgp->agp_offset;
+    size = DRM_SAVAGE_DMA_AGP_SIZE;
+    if (size <=0)
+        return TRUE;
+    ret=drmAgpAlloc( psav->drmFD,size,0,NULL,&handle);
+    if ( ret<0)
+    {
+        return TRUE;
+    }
+    ret=drmAgpBind( psav->drmFD,handle,offset);
+    if (ret<0)
+    {
+        return TRUE;
+    }
+    if (drmAddMap(psav->drmFD,
+                  offset,
+                  DRM_SAVAGE_DMA_AGP_SIZE,
+                  DRM_AGP,
+                  0,
+                  &map_handle)<0)
+    {
+        return TRUE;
+    }
+    pAgp->ctxOwner = hwContext;
+    pAgp->flags = 1;
+    pAgp->agp_handle = handle;
+    pAgp->map_handle = map_handle;
+    pShare->agp_offset=map_handle;
+    
+    return TRUE;
+    
+}
+
+static void SAVAGEDestroyContext( ScreenPtr pScreen, drm_context_t hwContext,
+			       DRIContextType contextStore )
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SavagePtr psav = SAVPTR(pScrn);
+
+    SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+    savageAgpBufferPtr pAgp;
+    drm_savage_sarea_t * pShare;
+    int i;
+    unsigned long handle,map_handle;
+    
+    psav->DRIrunning--;
+
+    pShare = (drm_savage_sarea_ptr)DRIGetSAREAPrivate(pScreen);
+    
+    for (i=0,pAgp = pSAVAGEDRIServer->agpBuffer;i<pSAVAGEDRIServer->numBuffer;i++,pAgp++)
+    {
+        if (pAgp->ctxOwner == hwContext)
+            break;
+    }
+    if (i >= pSAVAGEDRIServer->numBuffer || !pAgp->flags || !pAgp->agp_handle)
+    {
+        return;
+    }
+    handle = pAgp->agp_handle;
+    map_handle = pAgp->map_handle;
+    drmRmMap(psav->drmFD,map_handle);
+    drmAgpUnbind(psav->drmFD,handle);
+    drmAgpFree(psav->drmFD,handle);
+    pAgp->flags=0;
+    pAgp->ctxOwner=0;
+}
+
+#if 0
+/* Quiescence, locking
+ */
+#define SAVAGE_TIMEOUT		2048
+
+static void SAVAGEWaitForIdleDMA( ScrnInfoPtr pScrn )
+{
+   SavagePtr psav = SAVPTR(pScrn);
+   int ret;
+   int i = 0;
+
+   for (;;) {
+      do {
+	 ret = drmSAVAGEFlushDMA( psav->drmFD,
+			       DRM_LOCK_QUIESCENT | DRM_LOCK_FLUSH );
+      } while ( ( ret == -EBUSY ) && ( i++ < SAVAGE_TIMEOUT ) );
+
+      if ( ret == 0 )
+	 return;
+
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[dri] Idle timed out, resetting engine...\n" );
+
+      drmSAVAGEEngineReset( psav->drmFD );
+   }
+}
+
+
+void SAVAGEGetQuiescence( ScrnInfoPtr pScrn )
+{
+   SavagePtr psav = SAVPTR(pScrn);
+
+   DRILock( screenInfo.screens[pScrn->scrnIndex], 0 );
+   psav->haveQuiescense = 1;
+
+   if ( psav->directRenderingEnabled ) {
+      SAVAGEFBLayout *pLayout = &psav->CurrentLayout;
+
+      SAVAGEWaitForIdleDMA( pScrn );
+
+      WAITFIFO( 11 );
+      OUTREG( SAVAGEREG_MACCESS, psav->MAccess );
+      OUTREG( SAVAGEREG_PITCH, pLayout->displayWidth );
+
+      psav->PlaneMask = ~0;
+      OUTREG( SAVAGEREG_PLNWT, psav->PlaneMask );
+
+      psav->BgColor = 0;
+      psav->FgColor = 0;
+      OUTREG( SAVAGEREG_BCOL, psav->BgColor );
+      OUTREG( SAVAGEREG_FCOL, psav->FgColor );
+      OUTREG( SAVAGEREG_SRCORG, psav->realSrcOrg );
+
+      psav->SrcOrg = 0;
+      OUTREG( SAVAGEREG_DSTORG, psav->DstOrg );
+      OUTREG( SAVAGEREG_OPMODE, SAVAGEOPM_DMA_BLIT );
+      OUTREG( SAVAGEREG_CXBNDRY, 0xFFFF0000 ); /* (maxX << 16) | minX */
+      OUTREG( SAVAGEREG_YTOP, 0x00000000 );    /* minPixelPointer */
+      OUTREG( SAVAGEREG_YBOT, 0x007FFFFF );    /* maxPixelPointer */
+
+      psav->AccelFlags &= ~CLIPPER_ON;
+   }
+}
+
+void SAVAGEGetQuiescenceShared( ScrnInfoPtr pScrn )
+{
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEEntPtr pSAVAGEEnt = psav->entityPrivate;
+   SavagePtr pSAVAGE2 = SAVPTR(pSAVAGEEnt->pScrn_2);
+
+   DRILock( screenInfo.screens[pSAVAGEEnt->pScrn_1->scrnIndex], 0 );
+
+   psav = SAVPTR(pSAVAGEEnt->pScrn_1);
+   psav->haveQuiescense = 1;
+   pSAVAGE2->haveQuiescense = 1;
+
+   if ( pSAVAGEEnt->directRenderingEnabled ) {
+      SAVAGEWaitForIdleDMA( pSAVAGEEnt->pScrn_1 );
+      psav->RestoreAccelState( pScrn );
+      xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+   }
+}
+
+#endif 
+
+/* move in SAVAGEDRISwapContext() */
+#if 0
+static void SAVAGESwapContext( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+
+   /* Arrange for dma_quiescence and xaa sync to be called as
+    * appropriate.
+    */
+   psav->LockHeld = 1;   /* port as pMGA->haveQuiescense*/
+   psav->AccelInfoRec->NeedToSync = TRUE;
+}
+#endif
+
+/* no double-head */
+#if 0
+static void SAVAGESwapContextShared( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEEntPtr pSAVAGEEnt = psav->entityPrivate;
+   SavagePtr pSAVAGE2 = SAVPTR(pSAVAGEEnt->pScrn_2);
+
+   psav = SAVPTR(pSAVAGEEnt->pScrn_1);
+
+   psav->haveQuiescense = 0;
+   psav->AccelInfoRec->NeedToSync = TRUE;
+
+   pSAVAGE2->haveQuiescense = 0;
+   pSAVAGE2->AccelInfoRec->NeedToSync = TRUE;
+}
+#endif 
+
+/* This is really only called from validate/postvalidate as we
+ * override the dri lock/unlock.  Want to remove validate/postvalidate
+ * processing, but need to remove all client-side use of drawable lock
+ * first (otherwise there is noone recover when a client dies holding
+ * the drawable lock).
+ *
+ * What does this mean?
+ *
+ *   - The above code gets executed every time a
+ *     window changes shape or the focus changes, which isn't really
+ *     optimal.
+ *   - The X server therefore believes it needs to do an XAA sync
+ *     *and* a dma quiescense ioctl each time that happens.
+ *
+ * We don't wrap wakeuphandler any longer, so at least we can say that
+ * this doesn't happen *every time the mouse moves*...
+ */
+static void
+SAVAGEDRISwapContext( ScreenPtr pScreen, DRISyncType syncType,
+		   DRIContextType oldContextType, void *oldContext,
+		   DRIContextType newContextType, void *newContext )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+
+#if 1
+   /* this case call from DRIDoWakeupandler,  */
+   /* swap context in                         */
+   if ( syncType == DRI_3D_SYNC &&
+	oldContextType == DRI_2D_CONTEXT &&
+	newContextType == DRI_2D_CONTEXT )
+   {
+      psav->LockHeld = 1;   /* port as pMGA->haveQuiescense*/
+      psav->AccelInfoRec->NeedToSync = TRUE;
+   }
+   /* this case call from DRIDoBlockHandler,   */
+   /* swap context out                         */
+   else if (syncType == DRI_2D_SYNC &&
+	    oldContextType == DRI_NO_CONTEXT &&
+	    newContextType == DRI_2D_CONTEXT)
+   {
+      psav->LockHeld = 0;
+      psav->AccelInfoRec->NeedToSync = TRUE;
+   }
+#endif
+}
+
+/* no Double-Head */
+#if 0
+static void
+SAVAGEDRISwapContextShared( ScreenPtr pScreen, DRISyncType syncType,
+			  DRIContextType oldContextType, void *oldContext,
+			  DRIContextType newContextType, void *newContext )
+{
+#if 0
+   if ( syncType == DRI_3D_SYNC &&
+	oldContextType == DRI_2D_CONTEXT &&
+	newContextType == DRI_2D_CONTEXT )
+   {
+      SAVAGESwapContextShared( pScreen );
+   }
+#endif
+}
+#endif
+
+/* following I810 and R128 swaping  method      */
+/*       MGA swaping method is for their double head  */
+#if 0
+static void SAVAGEWakeupHandler( int screenNum, pointer wakeupData,
+			      unsigned long result, pointer pReadmask )
+{
+    ScreenPtr pScreen = screenInfo.screens[screenNum];
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+    if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+        SAVAGESwapContextShared( pScreen );
+    } else {
+        SAVAGESwapContext( pScreen );
+    }
+}
+
+static void SAVAGEBlockHandler( int screenNum, pointer blockData,
+			     pointer pTimeout, pointer pReadmask )
+
+{
+   ScreenPtr pScreen = screenInfo.screens[screenNum];
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEEntPtr pSAVAGEEnt;
+
+   if ( psav->haveQuiescense ) {
+      if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+	 /* Restore to first screen */
+	 psav->RestoreAccelState( pScrn );
+	 xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+	 pSAVAGEEnt = psav->entityPrivate;
+
+	 if ( pSAVAGEEnt->directRenderingEnabled ) {
+	    DRIUnlock( screenInfo.screens[pSAVAGEEnt->pScrn_1->scrnIndex] );
+	 }
+      } else {
+	 if ( psav->directRenderingEnabled ) {
+	    DRIUnlock( pScreen );
+	 }
+      }
+      psav->haveQuiescense = 0;
+   }
+}
+#endif
+
+void SAVAGESelectBuffer( ScrnInfoPtr pScrn, int which )
+{
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate;
+
+   psav->WaitIdleEmpty(psav);
+
+   OUTREG(0x48C18,INREG(0x48C18)&(~0x00000008));
+   
+   switch ( which ) {
+   case SAVAGE_BACK:
+      OUTREG( 0x8170, pSAVAGEDRI->backOffset );
+      OUTREG( 0x8174, pSAVAGEDRI->backBitmapDesc );
+      break;
+   case SAVAGE_DEPTH:
+      OUTREG( 0x8170, pSAVAGEDRI->depthOffset );
+      OUTREG( 0x8174, pSAVAGEDRI->depthBitmapDesc );
+      break;
+   default:
+   case SAVAGE_FRONT:
+      OUTREG( 0x8170, pSAVAGEDRI->frontOffset );
+      OUTREG( 0x8174, pSAVAGEDRI->frontBitmapDesc );
+      break;
+   }
+   OUTREG(0x48C18,INREG(0x48C18)|(0x00000008));
+   psav->WaitIdleEmpty(psav);
+
+}
+
+
+static unsigned int mylog2( unsigned int n )
+{
+   unsigned int log2 = 1;
+
+   n--;
+   while ( n > 1 ) n >>= 1, log2++;
+
+   return log2;
+}
+
+static Bool SAVAGEDRIAgpInit(ScreenPtr pScreen)
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+   unsigned long mode;
+   unsigned int vendor, device;
+   int ret;
+   int size,numbuffer,i;
+   savageAgpBufferPtr agpbuffer;
+   
+   /* FIXME: Make these configurable...
+    */
+   /*pSAVAGEDRIServer->agp.size = 16 * 1024 * 1024;*/
+   pSAVAGEDRIServer->agp.size = psav->agpSize * 1024 * 1024;
+   pSAVAGEDRIServer->agp.offset = pSAVAGEDRIServer->agp.size;
+   
+   pSAVAGEDRIServer->agpTextures.offset = 0;
+   /*pSAVAGEDRIServer->agpTextures.size  = 16*1024*1024;*/
+   pSAVAGEDRIServer->agpTextures.size  = psav->agpSize * 1024 * 1024;
+   pSAVAGEDRIServer->logAgpTextureGranularity = 10;
+
+   if ( drmAgpAcquire( psav->drmFD ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not available\n" );
+      return FALSE;
+   }
+
+   mode   = drmAgpGetMode( psav->drmFD );        /* Default mode */
+   vendor = drmAgpVendorId( psav->drmFD );
+   device = drmAgpDeviceId( psav->drmFD );
+
+   mode &= ~SAVAGE_AGP_MODE_MASK;
+
+   switch ( psav->agpMode ) {
+   case 4:
+      mode |= SAVAGE_AGP_4X_MODE;
+   case 2:
+      mode |= SAVAGE_AGP_2X_MODE;
+   case 1:
+   default:
+      mode |= SAVAGE_AGP_1X_MODE;
+   }
+
+   /*   mode |= SAVAGE_AGP_1X_MODE;*/
+
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[agp] Mode 0x%08lx [AGP 0x%04x/0x%04x; Card 0x%04x/0x%04x]\n",
+	       mode, vendor, device,
+	       psav->PciInfo->vendor,
+	       psav->PciInfo->chipType );
+
+   if ( drmAgpEnable( psav->drmFD, mode ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not enabled\n" );
+      drmAgpRelease( psav->drmFD );
+      return FALSE;
+   }
+
+   ret = drmAgpAlloc( psav->drmFD, pSAVAGEDRIServer->agp.size,
+		      0, NULL, &pSAVAGEDRIServer->agp.handle );
+   if ( ret < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Out of memory (%d)\n", ret );
+      drmAgpRelease( psav->drmFD );
+      return FALSE;
+   }
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[agp] %d kB allocated with handle 0x%08x\n",
+	       pSAVAGEDRIServer->agp.size/1024, pSAVAGEDRIServer->agp.handle );
+
+   if ( drmAgpBind( psav->drmFD, pSAVAGEDRIServer->agp.handle, 0 ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Could not bind memory\n" );
+      drmAgpFree( psav->drmFD, pSAVAGEDRIServer->agp.handle );
+      drmAgpRelease( psav->drmFD );
+      return FALSE;
+   }
+
+   if ( drmAddMap( psav->drmFD,
+		   pSAVAGEDRIServer->agpTextures.offset,
+		   pSAVAGEDRIServer->agpTextures.size,
+		   DRM_AGP, 0,
+		   &pSAVAGEDRIServer->agpTextures.handle ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[agp] Could not add agpTextures \n" );
+      return FALSE;
+   }
+   /*   pSAVAGEDRIServer->agp_offset=pSAVAGEDRIServer->agpTexture.size;*/
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[agp] agpTextures microcode handle = 0x%08lx\n",
+	       pSAVAGEDRIServer->agpTextures.handle );
+
+   /*if ( drmMap( psav->drmFD,
+		pSAVAGEDRIServer->agpTextures.handle,
+		pSAVAGEDRIServer->agpTextures.size,
+		&pSAVAGEDRIServer->agpTextures.map ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[agp] Could not map agpTextures \n" );
+      return FALSE;
+   }*/
+   
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[agp] agpTextures mapped at 0x%08lx\n",
+	       (unsigned long)pSAVAGEDRIServer->agpTextures.map );
+
+   /* for agp dma buffer*/
+   size = drmAgpSize(psav->drmFD);
+   size -=    pSAVAGEDRIServer->agpTextures.size;/*sub texture size*/
+   numbuffer = size /  DRM_SAVAGE_DMA_AGP_SIZE;
+   agpbuffer = (savageAgpBufferPtr)xcalloc(sizeof(savageAgpBuffer),numbuffer);
+   for (i=0;i<numbuffer;i++)
+   {
+       agpbuffer[i].ctxOwner = 0;
+       agpbuffer[i].agp_offset =
+           pSAVAGEDRIServer->agpTextures.size + i* DRM_SAVAGE_DMA_AGP_SIZE;
+       agpbuffer[i].flags = 0;
+       agpbuffer[i].agp_handle = 0;
+   }
+   pSAVAGEDRIServer->numBuffer = numbuffer;
+   pSAVAGEDRIServer->agpBuffer = agpbuffer;
+        
+   return TRUE;
+}
+
+static Bool SAVAGEDRIMapInit( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+
+   pSAVAGEDRIServer->registers.size = SAVAGEIOMAPSIZE;
+
+   if ( drmAddMap( psav->drmFD,
+		   (drm_handle_t)psav->MmioBase,
+		   pSAVAGEDRIServer->registers.size,
+		   DRM_REGISTERS,0,
+		   &pSAVAGEDRIServer->registers.handle ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[drm] Could not add MMIO registers mapping\n" );
+      return FALSE;
+   }
+   
+   pSAVAGEDRIServer->aperture.size = 5 * 0x01000000;
+   
+   if ( drmAddMap( psav->drmFD,
+		   (drm_handle_t)(psav->ApertureBase),
+		   pSAVAGEDRIServer->aperture.size,
+		   DRM_FRAME_BUFFER,0,
+		   &pSAVAGEDRIServer->aperture.handle ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[drm] Could not add aperture mapping\n" );
+      return FALSE;
+   }
+   
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[drm] aperture handle = 0x%08lx\n",
+	       pSAVAGEDRIServer->aperture.handle );
+
+   /*if(drmMap(psav->drmFD,
+          pSAVAGEDRIServer->registers.handle,
+          pSAVAGEDRIServer->registers.size,
+          &pSAVAGEDRIServer->registers.map)<0)
+   {
+         xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[drm] Could not map MMIO registers region to virtual\n" );
+      return FALSE;
+   
+   }*/
+
+   pSAVAGEDRIServer->status.size = SAREA_MAX;
+
+   if ( drmAddMap( psav->drmFD, 0, pSAVAGEDRIServer->status.size,
+		   DRM_SHM, DRM_READ_ONLY | DRM_LOCKED | DRM_KERNEL,
+		   &pSAVAGEDRIServer->status.handle ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[drm] Could not add status page mapping\n" );
+      return FALSE;
+   }
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[drm] Status handle = 0x%08lx\n",
+	       pSAVAGEDRIServer->status.handle );
+
+   if ( drmMap( psav->drmFD,
+		pSAVAGEDRIServer->status.handle,
+		pSAVAGEDRIServer->status.size,
+		&pSAVAGEDRIServer->status.map ) < 0 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[agp] Could not map status page\n" );
+      return FALSE;
+   }
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[agp] Status page mapped at 0x%08lx\n",
+	       (unsigned long)pSAVAGEDRIServer->status.map );
+
+   return TRUE;
+}
+
+/* no need DMA */
+#if 0 
+static Bool SAVAGEDRIKernelInit( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+   drmSAVAGEInit init;
+   int ret;
+
+   memset( &init, 0, sizeof(drmSAVAGEInit) );
+
+   init.sarea_priv_offset = sizeof(XF86DRISAREARec);
+
+   switch ( psav->Chipset ) {
+   case PCI_CHIP_SAVAGEG400:
+      init.chipset = SAVAGE_CARD_TYPE_G400;
+      break;
+   case PCI_CHIP_SAVAGEG200:
+   case PCI_CHIP_SAVAGEG200_PCI:
+      init.chipset = SAVAGE_CARD_TYPE_G200;
+      break;
+   default:
+      return FALSE;
+   }
+   init.sgram = !psav->HasSDRAM;
+
+   init.maccess = psav->MAccess;
+
+   init.fb_cpp		= pScrn->bitsPerPixel / 8;
+   init.front_offset	= pSAVAGEDRIServer->frontOffset;
+   init.front_pitch	= pSAVAGEDRIServer->frontPitch / init.fb_cpp;
+   init.back_offset	= pSAVAGEDRIServer->backOffset;
+   init.back_pitch	= pSAVAGEDRIServer->backPitch / init.fb_cpp;
+
+   init.depth_cpp	= pScrn->bitsPerPixel / 8;
+   init.depth_offset	= pSAVAGEDRIServer->depthOffset;
+   init.depth_pitch	= pSAVAGEDRIServer->depthPitch / init.depth_cpp;
+
+   init.texture_offset[0] = pSAVAGEDRIServer->textureOffset;
+   init.texture_size[0] = pSAVAGEDRIServer->textureSize;
+
+   init.fb_offset = psav->FbAddress;
+   init.mmio_offset = pSAVAGEDRIServer->registers.handle;
+   init.status_offset = pSAVAGEDRIServer->status.handle;
+
+   init.warp_offset = pSAVAGEDRIServer->warp.handle;
+   init.primary_offset = pSAVAGEDRIServer->primary.handle;
+   init.buffers_offset = pSAVAGEDRIServer->buffers.handle;
+
+   ret = drmSAVAGEInitDMA( psav->drmFD, &init );
+   if ( ret < 0 ) {
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[drm] Failed to initialize DMA! (%d)\n", ret );
+      return FALSE;
+   }
+
+#if 0
+   /* FIXME: This is just here to clean up after the engine reset test
+    * in the kernel module.  Please remove it later...
+    */
+   psav->GetQuiescence( pScrn );
+#endif
+
+   return TRUE;
+}
+
+static Bool SAVAGEDRIBuffersInit( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+
+
+   pSAVAGEDRIServer->drmBuffers = drmMapBufs( psav->drmFD );
+   if ( !pSAVAGEDRIServer->drmBuffers ) {
+	xf86DrvMsg( pScreen->myNum, X_ERROR,
+		    "[drm] Failed to map DMA buffers list\n" );
+	return FALSE;
+    }
+    xf86DrvMsg( pScreen->myNum, X_INFO,
+		"[drm] Mapped %d DMA buffers\n",
+		pSAVAGEDRIServer->drmBuffers->count );
+
+    return TRUE;
+}
+#endif
+
+Bool SAVAGEDRIScreenInit( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   DRIInfoPtr pDRIInfo;
+   SAVAGEDRIPtr pSAVAGEDRI;
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer;
+
+/*  disable first....*/
+#if 0
+   switch ( psav->Chipset ) {
+   case PCI_CHIP_SAVAGEG400:
+   case PCI_CHIP_SAVAGEG200:
+#if 0
+   case PCI_CHIP_SAVAGEG200_PCI:
+#endif
+      break;
+   default:
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[drm] Direct rendering only supported with AGP G200/G400 cards!\n" );
+      return FALSE;
+   }
+#endif
+
+   /* Check that the GLX, DRI, and DRM modules have been loaded by testing
+    * for canonical symbols in each module.
+    */
+   if ( !xf86LoaderCheckSymbol( "GlxSetVisualConfigs" ) )	return FALSE;
+   if ( !xf86LoaderCheckSymbol( "DRIScreenInit" ) )		return FALSE;
+   if ( !xf86LoaderCheckSymbol( "drmAvailable" ) )		return FALSE;
+   if ( !xf86LoaderCheckSymbol( "DRIQueryVersion" ) ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[dri] SAVAGEDRIScreenInit failed (libdri.a too old)\n" );
+      return FALSE;
+   }
+
+/* disable first */
+#if 1
+   /* Check the DRI version */
+   {
+      int major, minor, patch;
+      DRIQueryVersion( &major, &minor, &patch );
+      if ( major != 4 || minor < 0 ) {
+         xf86DrvMsg( pScreen->myNum, X_ERROR,
+		     "[dri] SAVAGEDRIScreenInit failed because of a version mismatch.\n"
+		     "[dri] libDRI version = %d.%d.%d but version 4.0.x is needed.\n"
+		     "[dri] Disabling the DRI.\n",
+		     major, minor, patch );
+         return FALSE;
+      }
+   }
+#endif
+
+   xf86DrvMsg( pScreen->myNum, X_INFO,
+	       "[drm] bpp: %d depth: %d\n",
+	       pScrn->bitsPerPixel, pScrn->depth );
+
+   if ( (pScrn->bitsPerPixel / 8) != 2 &&
+	(pScrn->bitsPerPixel / 8) != 4 ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[dri] Direct rendering only supported in 16 and 32 bpp modes\n" );
+      return FALSE;
+   }
+
+   pDRIInfo = DRICreateInfoRec();
+   if ( !pDRIInfo ) {
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[dri] DRICreateInfoRec() failed\n" );
+      return FALSE;
+   }
+   psav->pDRIInfo = pDRIInfo;
+
+   pDRIInfo->drmDriverName = SAVAGEKernelDriverName;
+   pDRIInfo->clientDriverName = SAVAGEClientDriverName;
+   if (xf86LoaderCheckSymbol("DRICreatePCIBusID")) {
+      pDRIInfo->busIdString = DRICreatePCIBusID(psav->PciInfo);
+   } else {
+      pDRIInfo->busIdString            = xalloc(64);
+      sprintf(pDRIInfo->busIdString,
+              "PCI:%d:%d:%d",
+              psav->PciInfo->bus,
+              psav->PciInfo->device,
+              psav->PciInfo->func);
+   }
+   pDRIInfo->ddxDriverMajorVersion = 1/*SAVAGE_MAJOR_VERSION*/;
+   pDRIInfo->ddxDriverMinorVersion = 1/*SAVAGE_MINOR_VERSION*/;
+   pDRIInfo->ddxDriverPatchVersion = 16/*SAVAGE_PATCHLEVEL*/;
+   pDRIInfo->frameBufferPhysicalAddress = psav->FrameBufferBase;
+   pDRIInfo->frameBufferSize = psav->videoRambytes;
+   pDRIInfo->frameBufferStride = pScrn->displayWidth*(pScrn->bitsPerPixel/8);
+   pDRIInfo->ddxDrawableTableEntry = SAVAGE_MAX_DRAWABLES;
+
+/* mark off these... we use default */
+#if 0
+   pDRIInfo->wrap.BlockHandler = SAVAGEBlockHandler;
+   pDRIInfo->wrap.WakeupHandler = SAVAGEWakeupHandler;
+#endif
+   
+   pDRIInfo->wrap.ValidateTree = NULL;
+   pDRIInfo->wrap.PostValidateTree = NULL;
+
+   pDRIInfo->createDummyCtx = TRUE;
+   pDRIInfo->createDummyCtxPriv = FALSE;
+
+   if ( SAREA_MAX_DRAWABLES < SAVAGE_MAX_DRAWABLES ) {
+      pDRIInfo->maxDrawableTableEntry = SAREA_MAX_DRAWABLES;
+   } else {
+      pDRIInfo->maxDrawableTableEntry = SAVAGE_MAX_DRAWABLES;
+   }
+
+   /* For now the mapping works by using a fixed size defined
+    * in the SAREA header.
+    */
+   if ( sizeof(XF86DRISAREARec) + sizeof(SAVAGESAREAPrivRec) > SAREA_MAX ) {
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[drm] Data does not fit in SAREA\n" );
+      return FALSE;
+   }
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+	       "[drm] Sarea %d+%d: %d\n",
+	       sizeof(XF86DRISAREARec), sizeof(SAVAGESAREAPrivRec),
+	       sizeof(XF86DRISAREARec) + sizeof(SAVAGESAREAPrivRec) );
+
+   pDRIInfo->SAREASize = SAREA_MAX;
+
+   pSAVAGEDRI = (SAVAGEDRIPtr)xcalloc( sizeof(SAVAGEDRIRec), 1 );
+   if ( !pSAVAGEDRI ) {
+      DRIDestroyInfoRec( psav->pDRIInfo );
+      psav->pDRIInfo = 0;
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[drm] Failed to allocate memory for private record\n" );
+      return FALSE;
+   }
+
+   pSAVAGEDRIServer = (SAVAGEDRIServerPrivatePtr)
+      xcalloc( sizeof(SAVAGEDRIServerPrivateRec), 1 );
+   if ( !pSAVAGEDRIServer ) {
+      xfree( pSAVAGEDRI );
+      DRIDestroyInfoRec( psav->pDRIInfo );
+      psav->pDRIInfo = 0;
+      xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+		  "[drm] Failed to allocate memory for private record\n" );
+      return FALSE;
+   }
+   psav->DRIServerInfo = pSAVAGEDRIServer;
+
+   pDRIInfo->devPrivate = pSAVAGEDRI;
+   pDRIInfo->devPrivateSize = sizeof(SAVAGEDRIRec);
+   pDRIInfo->contextSize = sizeof(SAVAGEDRIContextRec);
+
+   pDRIInfo->CreateContext = SAVAGECreateContext;
+   pDRIInfo->DestroyContext = SAVAGEDestroyContext;
+
+/* we don't have double head */
+#if 0   
+   if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+      pDRIInfo->SwapContext = SAVAGEDRISwapContextShared;
+   } else
+#endif
+ 
+   {
+      pDRIInfo->SwapContext = SAVAGEDRISwapContext;
+   }
+
+#if 0
+   switch( pScrn->bitsPerPixel ) {
+   case 8:
+       pDRIInfo->InitBuffers = Savage8DRIInitBuffers;
+       pDRIInfo->MoveBuffers = Savage8DRIMoveBuffers;
+   case 16:
+       pDRIInfo->InitBuffers = Savage16DRIInitBuffers;
+       pDRIInfo->MoveBuffers = Savage16DRIMoveBuffers;
+   case 24:
+       pDRIInfo->InitBuffers = Savage24DRIInitBuffers;
+       pDRIInfo->MoveBuffers = Savage24DRIMoveBuffers;
+   case 32:
+       pDRIInfo->InitBuffers = Savage32DRIInitBuffers;
+       pDRIInfo->MoveBuffers = Savage32DRIMoveBuffers;
+   }
+#endif
+   
+   pDRIInfo->InitBuffers = SAVAGEDRIInitBuffers;
+   pDRIInfo->MoveBuffers = SAVAGEDRIMoveBuffers;
+   pDRIInfo->OpenFullScreen = SAVAGEDRIOpenFullScreen;
+   pDRIInfo->CloseFullScreen = SAVAGEDRICloseFullScreen;
+   pDRIInfo->bufferRequests = DRI_ALL_WINDOWS;
+
+   if ( !DRIScreenInit( pScreen, pDRIInfo, &psav->drmFD ) ) {
+      xfree( pSAVAGEDRIServer );
+      psav->DRIServerInfo = 0;
+      xfree( pDRIInfo->devPrivate );
+      pDRIInfo->devPrivate = 0;
+      DRIDestroyInfoRec( psav->pDRIInfo );
+      psav->pDRIInfo = 0;
+      xf86DrvMsg( pScreen->myNum, X_ERROR,
+		  "[drm] DRIScreenInit failed.  Disabling DRI.\n" );
+      return FALSE;
+   }
+
+/* Disable these */
+#if 1
+   /* Check the SAVAGE DRM version */
+   {
+      drmVersionPtr version = drmGetVersion(psav->drmFD);
+      if ( version ) {
+         if ( version->version_major != 1 ||
+	      version->version_minor < 0 ) {
+            /* incompatible drm version */
+            xf86DrvMsg( pScreen->myNum, X_ERROR,
+			"[dri] SAVAGEDRIScreenInit failed because of a version mismatch.\n"
+			"[dri] savage.o kernel module version is %d.%d.%d but version 3.0.x is needed.\n"
+			"[dri] Disabling DRI.\n",
+			version->version_major,
+			version->version_minor,
+			version->version_patchlevel );
+            drmFreeVersion( version );
+	    SAVAGEDRICloseScreen( pScreen );		/* FIXME: ??? */
+            return FALSE;
+         }
+         drmFreeVersion( version );
+      }
+   }
+#endif
+
+#if 0
+   /* Calculate texture constants for AGP texture space.
+    * FIXME: move!
+    */
+   {
+      CARD32 agpTextureOffset = SAVAGE_DMA_BUF_SZ * SAVAGE_DMA_BUF_NR;
+      CARD32 agpTextureSize = pSAVAGEDRI->agp.size - agpTextureOffset;
+
+      i = mylog2(agpTextureSize / SAVAGE_NR_TEX_REGIONS);
+      if (i < SAVAGE_LOG_MIN_TEX_REGION_SIZE)
+         i = SAVAGE_LOG_MIN_TEX_REGION_SIZE;
+
+      pSAVAGEDRI->logAgpTextureGranularity = i;
+      pSAVAGEDRI->agpTextureSize = (agpTextureSize >> i) << i;
+      pSAVAGEDRI->agpTextureOffset = agpTextureOffset;
+   }
+#endif
+
+   if ( !SAVAGEDRIAgpInit( pScreen ) ) {
+      DRICloseScreen( pScreen );
+      return FALSE;
+   }
+
+   if ( !SAVAGEDRIMapInit( pScreen ) ) {
+      DRICloseScreen( pScreen );
+      return FALSE;
+   }
+
+   if ( !SAVAGEInitVisualConfigs( pScreen ) ) {
+      DRICloseScreen( pScreen );
+      return FALSE;
+   }
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[dri] visual configs initialized\n" );
+
+   return TRUE;
+}
+
+
+Bool SAVAGEDRIFinishScreenInit( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+   SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate;
+   int i;
+   unsigned int TileStride;
+   
+   
+   if ( !psav->pDRIInfo )
+      return FALSE;
+
+   psav->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT;
+
+   /* NOTE: DRIFinishScreenInit must be called before *DRIKernelInit
+    * because *DRIKernelInit requires that the hardware lock is held by
+    * the X server, and the first time the hardware lock is grabbed is
+    * in DRIFinishScreenInit.
+    */
+   if ( !DRIFinishScreenInit( pScreen ) ) {
+      SAVAGEDRICloseScreen( pScreen );
+      return FALSE;
+   }
+
+/* no dma...... */
+#if 0
+   if ( !SAVAGEDRIKernelInit( pScreen ) ) {
+      SAVAGEDRICloseScreen( pScreen );
+      return FALSE;
+   }
+
+   if ( !SAVAGEDRIBuffersInit( pScreen ) ) {
+      SAVAGEDRICloseScreen( pScreen );
+      return FALSE;
+   }
+
+   switch ( psav->Chipset ) {
+   case PCI_CHIP_SAVAGEG400:
+      pSAVAGEDRI->chipset = SAVAGE_CARD_TYPE_G400;
+      break;
+   case PCI_CHIP_SAVAGEG200:
+   case PCI_CHIP_SAVAGEG200_PCI:
+      pSAVAGEDRI->chipset = SAVAGE_CARD_TYPE_G200;
+      break;
+   default:
+      return FALSE;
+   }
+#endif
+
+   pSAVAGEDRI->chipset          = psav->Chipset;
+   pSAVAGEDRI->width		= pScrn->virtualX;
+   pSAVAGEDRI->height		= pScrn->virtualY;
+   pSAVAGEDRI->mem			= pScrn->videoRam * 1024;
+   pSAVAGEDRI->cpp			= pScrn->bitsPerPixel / 8;
+   pSAVAGEDRI->zpp			=pSAVAGEDRI->cpp;  
+   pSAVAGEDRI->agpMode		= psav->agpMode;
+
+   pSAVAGEDRI->frontOffset		= pSAVAGEDRIServer->frontOffset;
+   pSAVAGEDRI->frontbufferSize		= pSAVAGEDRIServer->frontbufferSize;
+   pSAVAGEDRI->frontbuffer		= psav->FrameBufferBase + 
+                                          pSAVAGEDRI->frontOffset;
+   pSAVAGEDRI->frontPitch		= pSAVAGEDRIServer->frontPitch;
+   pSAVAGEDRI->IsfrontTiled             = psav->bTiled; /* AGD: was 0 */
+   
+   if(pSAVAGEDRI->IsfrontTiled)
+   {
+      if(pSAVAGEDRI->cpp==2)
+        TileStride = (pSAVAGEDRI->width+63)&(~63);
+      else
+        TileStride = (pSAVAGEDRI->width+31)&(~31);
+
+      if ((psav->Chipset == S3_TWISTER)
+         || (psav->Chipset == S3_PROSAVAGE)
+         || (psav->Chipset == S3_PROSAVAGEDDR)
+         || (psav->Chipset == S3_SUPERSAVAGE))
+      { 
+      		pSAVAGEDRI->frontBitmapDesc   	= 0x10000000 | /* block write disabled */
+                	                          (1<<24) | /* destination tile format */
+                        	                  (pScrn->bitsPerPixel<<16) | /* bpp */
+                        	                  TileStride; /* stride */
+      } else {        
+      		pSAVAGEDRI->frontBitmapDesc   	= 0x10000000 | /* block write disabled */
+                	                          ((pSAVAGEDRI->cpp==2)?
+                        	                     BCI_BD_TILE_16:BCI_BD_TILE_32) | /*16/32 bpp tile format */
+                        	                  (pScrn->bitsPerPixel<<16) | /* bpp */
+                        	                  TileStride; /* stride */
+      		pSAVAGEDRI->frontPitch 		= TileStride;
+      }
+   }
+   else
+   {
+      pSAVAGEDRI->frontBitmapDesc	= 0x10000000 | /* AGD: block write should be disabled:  was 0x00000000 */
+      					  pScrn->bitsPerPixel<<16 |
+      					  pSAVAGEDRI->width;
+   }
+   
+   pSAVAGEDRI->backOffset		= pSAVAGEDRIServer->backOffset;
+   pSAVAGEDRI->backbufferSize		= pSAVAGEDRIServer->backbufferSize;
+   pSAVAGEDRI->backbuffer		= psav->FrameBufferBase +
+   					  pSAVAGEDRI->backOffset;
+   pSAVAGEDRI->backPitch		= pSAVAGEDRIServer->backPitch;
+
+   {
+      if(pSAVAGEDRI->cpp==2)
+        TileStride = (pSAVAGEDRI->width+63)&(~63);
+      else
+        TileStride = (pSAVAGEDRI->width+31)&(~31);
+
+      if ((psav->Chipset == S3_TWISTER)
+         || (psav->Chipset == S3_PROSAVAGE)
+         || (psav->Chipset == S3_PROSAVAGEDDR)
+         || (psav->Chipset == S3_SUPERSAVAGE)) /* AGD: supersavage may work like savage4/MX/IX, I just don't know. */
+      {        				       /* It's here since the 2D driver sets it up like prosavage */
+      		pSAVAGEDRI->backBitmapDesc   	= 0x10000000 |
+                	                          (1<<24) |
+                	                          (pScrn->bitsPerPixel<<16) |
+                	                          TileStride;
+      } else {
+      		pSAVAGEDRI->backBitmapDesc   	= 0x10000000 |
+                	                          ((pSAVAGEDRI->cpp==2)?
+                	                             BCI_BD_TILE_16:BCI_BD_TILE_32) |
+                	                          (pScrn->bitsPerPixel<<16) |
+                	                          TileStride;
+      }
+   }
+
+   pSAVAGEDRI->depthOffset		= pSAVAGEDRIServer->depthOffset;
+   pSAVAGEDRI->depthbufferSize		= pSAVAGEDRIServer->depthbufferSize;
+   pSAVAGEDRI->depthbuffer		= psav->FrameBufferBase +
+   					  pSAVAGEDRI->depthOffset;
+   pSAVAGEDRI->depthPitch		= pSAVAGEDRIServer->depthPitch;
+
+   {
+      if(pSAVAGEDRI->zpp==2)
+        TileStride = (pSAVAGEDRI->width+63)&(~63);
+      else
+        TileStride = (pSAVAGEDRI->width+31)&(~31);
+
+      if ((psav->Chipset == S3_TWISTER)
+         || (psav->Chipset == S3_PROSAVAGE)
+         || (psav->Chipset == S3_PROSAVAGEDDR)
+         || (psav->Chipset == S3_SUPERSAVAGE))
+      {  
+      		pSAVAGEDRI->depthBitmapDesc   	= 0x10000000 |
+ 	     					  (1<<24) |
+	                                          (pScrn->bitsPerPixel<<16) |
+	                                          TileStride;
+      } else {
+	        pSAVAGEDRI->depthBitmapDesc   	= 0x10000000 |
+                	                          ((pSAVAGEDRI->zpp==2)?
+                	                             BCI_BD_TILE_16:BCI_BD_TILE_32) |
+                	                          (pScrn->bitsPerPixel<<16) |
+                	                          TileStride;
+      }
+   }
+
+   pSAVAGEDRI->textureOffset	= pSAVAGEDRIServer->textureOffset;
+   pSAVAGEDRI->textures 		= psav->FrameBufferBase +
+   					  pSAVAGEDRI->textureOffset;
+   pSAVAGEDRI->textureSize		= pSAVAGEDRIServer->textureSize;
+
+   i = mylog2( pSAVAGEDRI->textureSize / SAVAGE_NR_TEX_REGIONS );
+   if ( i < SAVAGE_LOG_MIN_TEX_REGION_SIZE )
+      i = SAVAGE_LOG_MIN_TEX_REGION_SIZE;
+
+   pSAVAGEDRI->logTextureGranularity = i;
+   pSAVAGEDRI->textureSize = (pSAVAGEDRI->textureSize >> i) << i; /* truncate */
+
+   pSAVAGEDRI->agpTextures.handle = pSAVAGEDRIServer->agpTextures.handle;
+   pSAVAGEDRI->agpTextures.offset = pSAVAGEDRIServer->agpTextures.offset;   
+   pSAVAGEDRI->agpTextures.size = pSAVAGEDRIServer->agpTextures.size;
+   pSAVAGEDRI->agpTextures.map = pSAVAGEDRIServer->agpTextures.map;
+
+   i = mylog2( pSAVAGEDRI->agpTextures.size / SAVAGE_NR_TEX_REGIONS );
+   if ( i < SAVAGE_LOG_MIN_TEX_REGION_SIZE )
+      i = SAVAGE_LOG_MIN_TEX_REGION_SIZE;
+
+   pSAVAGEDRI->logAgpTextureGranularity = i;
+   pSAVAGEDRI->agpTextures.size = (pSAVAGEDRI->agpTextures.size >> i) << i; /* truncate */
+
+   pSAVAGEDRI->aperture.handle	= pSAVAGEDRIServer->aperture.handle;
+   pSAVAGEDRI->aperture.size	= pSAVAGEDRIServer->aperture.size;
+   pSAVAGEDRI->aperture.map    = pSAVAGEDRIServer->aperture.map;
+   {
+      unsigned int shift = 0;
+      
+      if(pSAVAGEDRI->width > 1024)
+        shift = 1; 
+
+      /* pSAVAGEDRI->aperturePitch = psav->ulAperturePitch; */
+      pSAVAGEDRI->aperturePitch = psav->ul3DAperturePitch;
+   }
+
+   {
+      unsigned int value = 0;
+      
+      OUTREG(0x850C,(INREG(0x850C) | 0x00008000)); /* AGD: I don't think this does anything on 3D/MX/IX */
+						   /* maybe savage4 too... */
+      /* we don't use Y range flag,so comment it */
+      /*
+        if(pSAVAGEDRI->width <= 1024)
+            value |= (1<<29);
+      */
+      if ((psav->Chipset == S3_SAVAGE_MX) /* 3D/MX/IX seem to set up the tile stride differently */
+	|| (psav->Chipset == S3_SAVAGE3D)) {
+      	    if(pSAVAGEDRI->cpp == 2)
+      	    {
+         	value |=  ((psav->l3DDelta / 4) >> 5) << 24; /* I assume psav->l3DDelta for 3D */
+         	value |= 2<<30;
+      	    } else {
+         	value |=  ((psav->l3DDelta / 4) >> 5) << 24; /* I assume psav->l3DDelta for 3D */
+         	value |= 3<<30;
+      	    }
+
+	    OUTREG(0x48C40, value|(pSAVAGEDRI->frontOffset) ); /* front */ 
+	    OUTREG(0x48C44, value|(pSAVAGEDRI->backOffset) ); /* back  */
+	    OUTREG(0x48C48, value|(pSAVAGEDRI->depthOffset) ); /* depth */
+      } else {
+      	    if(pSAVAGEDRI->cpp == 2)
+      	    {
+         	value |=  (((pSAVAGEDRI->width + 0x3F) & 0xFFC0) >> 6) << 20;
+         	value |= 2<<30;
+      	    } else {
+         	value |=  (((pSAVAGEDRI->width + 0x1F) & 0xFFE0) >> 5) << 20;
+         	value |= 3<<30;
+      	    }
+
+	    OUTREG(0x48C40, value|(pSAVAGEDRI->frontOffset >> 5) ); /* front */
+	    OUTREG(0x48C44, value|(pSAVAGEDRI->backOffset >> 5) ); /* back  */
+	    OUTREG(0x48C48, value|(pSAVAGEDRI->depthOffset >> 5) ); /* depth */
+      }
+   }
+   
+   pSAVAGEDRI->registers.handle	= pSAVAGEDRIServer->registers.handle;
+   pSAVAGEDRI->registers.size	= pSAVAGEDRIServer->registers.size;
+   pSAVAGEDRI->registers.map    = pSAVAGEDRIServer->registers.map;
+   
+   pSAVAGEDRI->BCIcmdBuf.handle	= pSAVAGEDRIServer->registers.handle+0x00010000;
+   pSAVAGEDRI->BCIcmdBuf.size	= 0x00020000;
+   pSAVAGEDRI->BCIcmdBuf.map    = (drmAddress)( (unsigned int)
+                                     pSAVAGEDRIServer->registers.map +
+                                     0x00010000);
+   
+   pSAVAGEDRI->status.handle	= pSAVAGEDRIServer->status.handle;
+   pSAVAGEDRI->status.size		= pSAVAGEDRIServer->status.size;
+   pSAVAGEDRI->shadowStatus = psav->ShadowStatus;
+
+/* no DMA now ....*/
+#if 0
+   pSAVAGEDRI->primary.handle	= pSAVAGEDRIServer->primary.handle;
+   pSAVAGEDRI->primary.size	= pSAVAGEDRIServer->primary.size;
+   pSAVAGEDRI->buffers.handle	= pSAVAGEDRIServer->buffers.handle;
+   pSAVAGEDRI->buffers.size	= pSAVAGEDRIServer->buffers.size;
+#endif
+   
+   pSAVAGEDRI->sarea_priv_offset = sizeof(XF86DRISAREARec);
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]pSAVAGEDRIServer:\n" );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	reserved_map_agpstart:0x%08x\n",pSAVAGEDRIServer->reserved_map_agpstart); 
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	reserved_map_idx:0x%08x\n",pSAVAGEDRIServer->reserved_map_idx);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	sarea_priv_offset:0x%08lx\n",pSAVAGEDRIServer->sarea_priv_offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	chipset:0x%08x\n",pSAVAGEDRIServer->chipset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	sgram:0x%08x\n",pSAVAGEDRIServer->sgram);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontbufferSize:0x%08x\n",pSAVAGEDRIServer->frontbufferSize);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontOffset:0x%08x\n",pSAVAGEDRIServer->frontOffset);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontPitch:0x%08x\n",pSAVAGEDRIServer->frontPitch);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backbufferSize:0x%08x\n",pSAVAGEDRIServer->backbufferSize);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backOffset:0x%08x\n",pSAVAGEDRIServer->backOffset);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backPitch:0x%08x\n",pSAVAGEDRIServer->backPitch);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthbufferSize:0x%08x\n",pSAVAGEDRIServer->depthbufferSize);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthOffset:0x%08x\n",pSAVAGEDRIServer->depthOffset);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthPitch:0x%08x\n",pSAVAGEDRIServer->depthPitch);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textureOffset:0x%08x\n",pSAVAGEDRIServer->textureOffset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textureSize:0x%08x\n",pSAVAGEDRIServer->textureSize);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textureSize:0x%08x\n",pSAVAGEDRIServer->textureSize);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	logTextureGranularity:0x%08x\n",pSAVAGEDRIServer->logTextureGranularity);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agp:handle:0x%08lx\n",pSAVAGEDRIServer->agp.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agp:offset:0x%08lx\n",pSAVAGEDRIServer->agp.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agp:size:0x%08lx\n",pSAVAGEDRIServer->agp.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agp:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->agp.map);
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:handle:0x%08lx\n",pSAVAGEDRIServer->registers.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:offset:0x%08lx\n",pSAVAGEDRIServer->registers.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:size:0x%08lx\n",pSAVAGEDRIServer->registers.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->registers.map);
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:handle:0x%08lx\n",pSAVAGEDRIServer->status.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:offset:0x%08lx\n",pSAVAGEDRIServer->status.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:size:0x%08lx\n",pSAVAGEDRIServer->status.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->status.map);
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:handle:0x%08lx\n",pSAVAGEDRIServer->agpTextures.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:offset:0x%08lx\n",pSAVAGEDRIServer->agpTextures.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:size:0x%08lx\n",pSAVAGEDRIServer->agpTextures.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	apgTextures:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->agpTextures.map);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	logAgpTextureGranularity:0x%08x\n",pSAVAGEDRIServer->logAgpTextureGranularity); 
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]pSAVAGEDRI:\n" );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	chipset:0x%08x\n",pSAVAGEDRI->chipset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	width:0x%08x\n",pSAVAGEDRI->width );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	height:0x%08x\n",pSAVAGEDRI->height );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	mem:0x%08lx\n",pSAVAGEDRI->mem );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	cpp:%d\n",pSAVAGEDRI->cpp );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	zpp:%d\n",pSAVAGEDRI->zpp );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpMode:%d\n",pSAVAGEDRI->agpMode );
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontbuffer:0x%08lx\n",pSAVAGEDRI->frontbuffer);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontbufferSize:0x%08x\n",pSAVAGEDRI->frontbufferSize);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontOffset:0x%08x\n",pSAVAGEDRI->frontOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontPitch:0x%08x\n",pSAVAGEDRI->frontPitch );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	frontBitmapDesc:0x%08lx\n",pSAVAGEDRI->frontBitmapDesc );
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backbuffer:0x%08lx\n",pSAVAGEDRI->backbuffer);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backbufferSize:0x%08x\n",pSAVAGEDRI->backbufferSize);     
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backOffset:0x%08x\n",pSAVAGEDRI->backOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backPitch:0x%08x\n",pSAVAGEDRI->backPitch );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	backBitmapDesc:0x%08lx\n",pSAVAGEDRI->backBitmapDesc );
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthbuffer:0x%08lx\n",pSAVAGEDRI->depthbuffer);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthbufferSize:0x%08x\n",pSAVAGEDRI->depthbufferSize);  
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthOffset:0x%08x\n",pSAVAGEDRI->depthOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthPitch:0x%08x\n",pSAVAGEDRI->depthPitch );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	depthBitmapDesc:0x%08lx\n",pSAVAGEDRI->depthBitmapDesc );
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textures:0x%08lx\n",pSAVAGEDRI->textures );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textureOffset:0x%08x\n",pSAVAGEDRI->textureOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	textureSize:0x%08x\n",pSAVAGEDRI->textureSize );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	logTextureGranularity:0x%08x\n",pSAVAGEDRI->logTextureGranularity );
+   
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpBufferOffset:0x%08x\n",pSAVAGEDRI->agpBufferOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextureOffset:0x%08x\n",pSAVAGEDRI->agpTextureOffset );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextureSize:0x%08x\n",pSAVAGEDRI->agpTextureSize );
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	logAgpTextureGranularity:0x%08x\n",pSAVAGEDRI->logAgpTextureGranularity );
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:handle:0x%08lx\n",pSAVAGEDRI->agpTextures.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:offset:0x%08lx\n",pSAVAGEDRI->agpTextures.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	agpTextures:size:0x%08lx\n",pSAVAGEDRI->agpTextures.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	apgTextures:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->agpTextures.map);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:handle:0x%08lx\n",pSAVAGEDRI->registers.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:offset:0x%08lx\n",pSAVAGEDRI->registers.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:size:0x%08lx\n",pSAVAGEDRI->registers.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	registers:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->registers.map);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	aperture:handle:0x%08lx\n",pSAVAGEDRI->aperture.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	aperture:offset:0x%08lx\n",pSAVAGEDRI->aperture.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	aperture:size:0x%08lx\n",pSAVAGEDRI->aperture.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	aperture:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->aperture.map);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	aperturePitch:0x%08x\n",pSAVAGEDRI->aperturePitch);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	BCIcmdBuf:handle:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	BCIcmdBuf:offset:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	BCIcmdBuf:size:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	BCIcmdBuf:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->BCIcmdBuf.map);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:handle:0x%08lx\n",pSAVAGEDRI->status.handle);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:offset:0x%08lx\n",pSAVAGEDRI->status.offset);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:size:0x%08lx\n",pSAVAGEDRI->status.size);
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	status:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->status.map);
+
+   xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]	sarea_priv_offset:0x%08lx\n",pSAVAGEDRI->sarea_priv_offset);
+    
+   return TRUE;
+}
+
+
+void SAVAGEDRICloseScreen( ScreenPtr pScreen )
+{
+   ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+   SavagePtr psav = SAVPTR(pScrn);
+   SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo;
+
+/* no DMA now..... */
+#if 0
+   if ( pSAVAGEDRIServer->drmBuffers ) {
+      drmUnmapBufs( pSAVAGEDRIServer->drmBuffers );
+      pSAVAGEDRIServer->drmBuffers = NULL;
+   }
+
+   drmSAVAGECleanupDMA( psav->drmFD );
+#endif
+
+   if ( pSAVAGEDRIServer->status.map ) {
+      drmUnmap( pSAVAGEDRIServer->status.map, pSAVAGEDRIServer->status.size );
+      pSAVAGEDRIServer->status.map = NULL;
+   }
+
+   if ( pSAVAGEDRIServer->registers.map ) {
+      drmUnmap( pSAVAGEDRIServer->registers.map, pSAVAGEDRIServer->registers.size );
+      pSAVAGEDRIServer->registers.map = NULL;
+   }
+   
+
+   if ( pSAVAGEDRIServer->agpTextures.map ) {
+      drmUnmap( pSAVAGEDRIServer->agpTextures.map, 
+                pSAVAGEDRIServer->agpTextures.size );
+      pSAVAGEDRIServer->agpTextures.map = NULL;
+   }
+
+   if (pSAVAGEDRIServer->status.handle)
+       drmRmMap(psav->drmFD,pSAVAGEDRIServer->status.handle);
+
+   if (pSAVAGEDRIServer->registers.handle)
+       drmRmMap(psav->drmFD,pSAVAGEDRIServer->registers.handle);
+
+   if (pSAVAGEDRIServer->agpTextures.handle)
+       drmRmMap(psav->drmFD,pSAVAGEDRIServer->agpTextures.handle);
+
+/* no DMA now.... */
+#if 0
+   if ( pSAVAGEDRIServer->buffers.map ) {
+      drmUnmap( pSAVAGEDRIServer->buffers.map, pSAVAGEDRIServer->buffers.size );
+      pSAVAGEDRIServer->buffers.map = NULL;
+   }
+   if ( pSAVAGEDRIServer->primary.map ) {
+      drmUnmap( pSAVAGEDRIServer->primary.map, pSAVAGEDRIServer->primary.size );
+      pSAVAGEDRIServer->primary.map = NULL;
+   }
+   if ( pSAVAGEDRIServer->warp.map ) {
+      drmUnmap( pSAVAGEDRIServer->warp.map, pSAVAGEDRIServer->warp.size );
+      pSAVAGEDRIServer->warp.map = NULL;
+   }
+#endif
+
+   if ( pSAVAGEDRIServer->agp.handle ) {
+      drmAgpUnbind( psav->drmFD, pSAVAGEDRIServer->agp.handle );
+      drmAgpFree( psav->drmFD, pSAVAGEDRIServer->agp.handle );
+      pSAVAGEDRIServer->agp.handle = 0;
+      drmAgpRelease( psav->drmFD );
+   }
+
+   DRICloseScreen( pScreen );
+   
+   /*Don't use shadow status any more*/
+   psav->ShadowVirtual = NULL;
+   psav->ShadowPhysical = 0;
+
+   if(psav->reserved)
+      xf86FreeOffscreenLinear(psav->reserved);
+
+   if ( psav->pDRIInfo ) {
+      if ( psav->pDRIInfo->devPrivate ) {
+	 xfree( psav->pDRIInfo->devPrivate );
+	 psav->pDRIInfo->devPrivate = 0;
+      }
+      DRIDestroyInfoRec( psav->pDRIInfo );
+      psav->pDRIInfo = 0;
+   }
+   if ( psav->DRIServerInfo ) {
+      xfree( psav->DRIServerInfo );
+      psav->DRIServerInfo = 0;
+   }
+   if ( psav->pVisualConfigs ) {
+      xfree( psav->pVisualConfigs );
+   }
+   if ( psav->pVisualConfigsPriv ) {
+      xfree( psav->pVisualConfigsPriv );
+   }
+}
+
+void
+SAVAGEDRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SavagePtr psav = SAVPTR(pScrn);
+    BoxPtr pbox = REGION_RECTS(prgn);
+    int nbox  = REGION_NUM_RECTS(prgn);
+
+
+#if 0
+    CHECK_DMA_QUIESCENT(SAVPTR(pScrn), pScrn);
+#endif
+#if 0
+    if(!psav->LockHeld)
+       psav->LockHeld = 1;
+    SAVAGEDRISetupForSolidFill(pScrn, 0, GXcopy, -1);
+    while (nbox--) {
+        SAVAGESelectBuffer(pScrn, SAVAGE_BACK);
+        SAVAGEDRISubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1,
+					 pbox->x2-pbox->x1, pbox->y2-pbox->y1);
+        SAVAGESelectBuffer(pScrn, SAVAGE_DEPTH);
+        SAVAGEDRISubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1,
+					 pbox->x2-pbox->x1, pbox->y2-pbox->y1);
+        pbox++;
+    }
+#endif
+#if 0
+    {
+       SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate;
+       unsigned int *bcicmd;
+       BCI_GET_PTR;
+       /*bcicmd = (unsigned int *) psav->BciMem;
+       *(bcicmd) = 0x4BCC8000;
+       *(bcicmd) = 0x00F80000;
+       *(bcicmd) = 0x02000200;
+       *(bcicmd) = 0x01000100;*/
+       BCI_SEND(0x4BCC8000);
+       BCI_SEND(0x00F80000);
+       BCI_SEND(0x02000200);
+       BCI_SEND(0x01000100);
+       sleep(5);
+    }
+#endif
+#if 0
+    SAVAGESelectBuffer(pScrn, SAVAGE_FRONT);
+    psav->AccelInfoRec->NeedToSync = TRUE;
+#endif
+}
+
+/*
+  This routine is a modified form of XAADoBitBlt with the calls to
+  ScreenToScreenBitBlt built in. My routine has the prgnSrc as source
+  instead of destination. My origin is upside down so the ydir cases
+  are reversed.
+*/
+
+void
+SAVAGEDRIMoveBuffers(WindowPtr pParent, DDXPointRec ptOldOrg,
+		   RegionPtr prgnSrc, CARD32 index)
+{
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    SavagePtr psav = SAVPTR(pScrn);
+    int nbox;
+    BoxPtr pbox, pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
+    DDXPointPtr pptTmp, pptNew1, pptNew2;
+    int xdir, ydir;
+    int dx, dy;
+    DDXPointPtr pptSrc;
+    int screenwidth = pScrn->virtualX;
+    int screenheight = pScrn->virtualY;
+
+#if 1
+#if 0
+    CHECK_DMA_QUIESCENT(SAVPTR(pScrn), pScrn);
+#endif
+    if(!psav->LockHeld)
+       psav->LockHeld = 1;
+
+    pbox = REGION_RECTS(prgnSrc);
+    nbox = REGION_NUM_RECTS(prgnSrc);
+    pboxNew1 = 0;
+    pptNew1 = 0;
+    pboxNew2 = 0;
+    pboxNew2 = 0;
+    pptSrc = &ptOldOrg;
+
+    dx = pParent->drawable.x - ptOldOrg.x;
+    dy = pParent->drawable.y - ptOldOrg.y;
+
+    /* If the copy will overlap in Y, reverse the order */
+    if (dy>0) {
+        ydir = -1;
+
+        if (nbox>1) {
+	    /* Keep ordering in each band, reverse order of bands */
+	    pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
+	    if (!pboxNew1) return;
+	    pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
+	    if (!pptNew1) {
+	        DEALLOCATE_LOCAL(pboxNew1);
+	        return;
+	    }
+	    pboxBase = pboxNext = pbox+nbox-1;
+	    while (pboxBase >= pbox) {
+	        while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1))
+		  pboxNext--;
+	        pboxTmp = pboxNext+1;
+	        pptTmp = pptSrc + (pboxTmp - pbox);
+	        while (pboxTmp <= pboxBase) {
+		    *pboxNew1++ = *pboxTmp++;
+		    *pptNew1++ = *pptTmp++;
+		}
+	        pboxBase = pboxNext;
+	    }
+	    pboxNew1 -= nbox;
+	    pbox = pboxNew1;
+	    pptNew1 -= nbox;
+	    pptSrc = pptNew1;
+	}
+    } else {
+        /* No changes required */
+        ydir = 1;
+    }
+
+    /* If the regions will overlap in X, reverse the order */
+    if (dx>0) {
+        xdir = -1;
+
+        if (nbox > 1) {
+	    /*reverse orderof rects in each band */
+	    pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
+	    pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
+	    if (!pboxNew2 || !pptNew2) {
+	        if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
+	        if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
+	        if (pboxNew1) {
+		    DEALLOCATE_LOCAL(pptNew1);
+		    DEALLOCATE_LOCAL(pboxNew1);
+		}
+	       return;
+	    }
+	    pboxBase = pboxNext = pbox;
+	    while (pboxBase < pbox+nbox) {
+	        while ((pboxNext < pbox+nbox) &&
+		       (pboxNext->y1 == pboxBase->y1))
+		  pboxNext++;
+	        pboxTmp = pboxNext;
+	        pptTmp = pptSrc + (pboxTmp - pbox);
+	        while (pboxTmp != pboxBase) {
+		    *pboxNew2++ = *--pboxTmp;
+		    *pptNew2++ = *--pptTmp;
+		}
+	        pboxBase = pboxNext;
+	    }
+	    pboxNew2 -= nbox;
+	    pbox = pboxNew2;
+	    pptNew2 -= nbox;
+	    pptSrc = pptNew2;
+	}
+    } else {
+        /* No changes are needed */
+        xdir = 1;
+    }
+#if 0
+    SAVAGEDRISetupForScreenToScreenCopy(pScrn, xdir, ydir, GXcopy, -1, -1);
+    for ( ; nbox-- ; pbox++)
+     {
+	 int x1 = pbox->x1;
+	 int y1 = pbox->y1;
+	 int destx = x1 + dx;
+	 int desty = y1 + dy;
+	 int w = pbox->x2 - x1 + 1;
+	 int h = pbox->y2 - y1 + 1;
+
+	 if ( destx < 0 ) x1 -= destx, w += destx, destx = 0;
+	 if ( desty < 0 ) y1 -= desty, h += desty, desty = 0;
+	 if ( destx + w > screenwidth ) w = screenwidth - destx;
+	 if ( desty + h > screenheight ) h = screenheight - desty;
+	 if ( w <= 0 ) continue;
+	 if ( h <= 0 ) continue;
+
+	 SAVAGESelectBuffer(pScrn, SAVAGE_BACK);
+	 SAVAGEDRISubsequentScreenToScreenCopy(pScrn, x1, y1,
+					       destx,desty, w, h);
+	 SAVAGESelectBuffer(pScrn, SAVAGE_DEPTH);
+	 SAVAGEDRISubsequentScreenToScreenCopy(pScrn, x1,y1,
+					       destx,desty, w, h);
+     }
+    SAVAGESelectBuffer(pScrn, SAVAGE_FRONT);
+
+    if (pboxNew2) {
+        DEALLOCATE_LOCAL(pptNew2);
+        DEALLOCATE_LOCAL(pboxNew2);
+    }
+    if (pboxNew1) {
+        DEALLOCATE_LOCAL(pptNew1);
+        DEALLOCATE_LOCAL(pboxNew1);
+    }
+
+    psav->AccelInfoRec->NeedToSync = TRUE;
+#endif
+#endif
+}
+
+static void 
+SAVAGEDRISetupForScreenToScreenCopy(
+    ScrnInfoPtr pScrn,
+    int xdir, 
+    int ydir,
+    int rop,
+    unsigned planemask,
+    int transparency_color)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    int cmd =0;
+
+    cmd = BCI_CMD_RECT | BCI_CMD_DEST_PBD | BCI_CMD_SRC_PBD_COLOR;
+    BCI_CMD_SET_ROP( cmd, XAAGetCopyROP(rop) );
+    if (transparency_color != -1)
+        cmd |= BCI_CMD_SEND_COLOR | BCI_CMD_SRC_TRANSPARENT;
+
+    if (xdir == 1 ) cmd |= BCI_CMD_RECT_XP;
+    if (ydir == 1 ) cmd |= BCI_CMD_RECT_YP;
+
+    psav->SavedBciCmd = cmd;
+    psav->SavedBgColor = transparency_color;
+
+}
+
+static void 
+SAVAGEDRISubsequentScreenToScreenCopy(
+    ScrnInfoPtr pScrn,
+    int x1,
+    int y1,
+    int x2,
+    int y2,
+    int w,
+    int h)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    BCI_GET_PTR;
+
+    if (!w || !h) return;
+    if (!(psav->SavedBciCmd & BCI_CMD_RECT_XP)) {
+        w --;
+        x1 += w;
+        x2 += w;
+        w ++;
+    }
+    if (!(psav->SavedBciCmd & BCI_CMD_RECT_YP)) {
+        h --;
+        y1 += h;
+        y2 += h;
+        h ++;
+    }
+
+    psav->WaitQueue(psav,6);
+    BCI_SEND(psav->SavedBciCmd);
+    if (psav->SavedBgColor != -1) 
+	BCI_SEND(psav->SavedBgColor);
+    BCI_SEND(BCI_X_Y(x1, y1));
+    BCI_SEND(BCI_X_Y(x2, y2));
+    BCI_SEND(BCI_W_H(w, h));
+
+}
+
+
+/*
+ * SetupForSolidFill is also called to set up for lines.
+ */ 
+#if 0
+static void 
+SAVAGEDRISetupForSolidFill(
+    ScrnInfoPtr pScrn,
+    int color, 
+    int rop,
+    unsigned planemask)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    XAAInfoRecPtr xaaptr = GET_XAAINFORECPTR_FROM_SCRNINFOPTR( pScrn );
+    int cmd;
+    int mix;
+
+    cmd = BCI_CMD_RECT
+        | BCI_CMD_RECT_XP | BCI_CMD_RECT_YP
+        | BCI_CMD_DEST_PBD | BCI_CMD_SRC_SOLID;
+
+    /* Don't send a color if we don't have to. */
+
+    if( rop == GXcopy )
+    {
+	if( color == 0 )
+	    rop = GXclear;
+	else if( color == xaaptr->FullPlanemask )
+	    rop = GXset;
+    }
+
+#if 1
+    mix = SavageHelpSolidROP( pScrn, &color, planemask, &rop );
+#endif
+    if( mix & ROP_PAT )
+	cmd |= BCI_CMD_SEND_COLOR;
+
+    BCI_CMD_SET_ROP( cmd, rop );
+
+    psav->SavedBciCmd = cmd;
+    psav->SavedFgColor = color;
+}
+#endif    
+    
+static void 
+SAVAGEDRISubsequentSolidFillRect(
+    ScrnInfoPtr pScrn,
+    int x,
+    int y,
+    int w,
+    int h)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    BCI_GET_PTR;
+    
+    if( !w || !h )
+	return;
+
+    psav->WaitQueue(psav,5);
+
+    BCI_SEND(psav->SavedBciCmd);
+    if( psav->SavedBciCmd & BCI_CMD_SEND_COLOR )
+	BCI_SEND(psav->SavedFgColor);
+    BCI_SEND(BCI_X_Y(x, y));
+    BCI_SEND(BCI_W_H(w, h));
+}
+
+
+static Bool
+SAVAGEDRIOpenFullScreen(ScreenPtr pScreen)
+{
+  ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+  vgaHWPtr hwp = VGAHWPTR(pScrn);
+  SavagePtr psav = SAVPTR(pScrn);
+  unsigned int vgaCRIndex = hwp->IOBase + 4;
+  unsigned int vgaCRReg = hwp->IOBase + 5;
+  SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate;
+  unsigned int TileStride;
+  unsigned int WidthinTiles;
+  unsigned int depth;
+  
+  OUTREG(0x48C18, INREG(0x48C18) & 0xFFFFFFF7);
+  /*VGAOUT8(vgaCRIndex,0x66);
+  VGAOUT8(vgaCRReg, VGAIN8(vgaCRReg)|0x10);*/
+  VGAOUT8(vgaCRIndex,0x69);
+  VGAOUT8(vgaCRReg, 0x80);
+  
+  depth = pScrn->bitsPerPixel;
+  
+  if(depth == 16)
+  {
+      WidthinTiles = (pSAVAGEDRI->width+63)>>6;
+      TileStride = (pSAVAGEDRI->width+63)&(~63);
+  
+  }
+  else
+  {
+      WidthinTiles = (pSAVAGEDRI->width+31)>>5;
+      TileStride = (pSAVAGEDRI->width+31)&(~31);
+  
+  }  
+
+
+  /* set primary stream stride */
+  {
+      unsigned int value;
+      
+      /*value = 0x80000000|(WidthinTiles<<24)|(TileStride*depth/8);*/
+      value = 0x80000000|(WidthinTiles<<24);
+      if(depth == 32)
+          value |= 0x40000000;
+      
+      OUTREG(PRI_STREAM_STRIDE, value);
+  
+  }
+  
+  /* set global bitmap descriptor */
+  {
+      unsigned int value;
+      value = 0x10000000|
+              0x00000009|
+              0x01000000|
+              (depth<<16)  | TileStride;
+  
+      OUTREG(0x816C,value);
+  
+  }
+ 
+   OUTREG(0x48C18, INREG(0x48C18) | 0x8);
+   
+  return TRUE;
+}
+
+static Bool
+SAVAGEDRICloseFullScreen(ScreenPtr pScreen)
+{
+  ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+  SavagePtr psav = SAVPTR(pScrn);
+  SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate;
+  unsigned int depth = pScrn->bitsPerPixel;
+  BCI_GET_PTR;
+
+  BCI_SEND(0xC0FF0000);
+  psav->WaitIdleEmpty(psav);
+  OUTREG(0x48C18, INREG(0x48C18) & 0xFFFFFFF7);
+  /* set primary stream stride */
+  {
+      /* MM81C0 and 81C4 are used to control primary stream. */
+      OUTREG32(PRI_STREAM_FBUF_ADDR0,0x00000000);
+      OUTREG32(PRI_STREAM_FBUF_ADDR1,0x00000000);
+      
+      /* FIFO control */
+      OUTREG32(0X81EC,0Xffffffff);
+      
+      if (!psav->bTiled) {
+          OUTREG32(PRI_STREAM_STRIDE,
+                   (((psav->lDelta * 2) << 16) & 0x3FFFE000) |
+                   (psav->lDelta & 0x00001fff));
+      }
+      else if (pScrn->bitsPerPixel == 16) {
+          /* Scanline-length-in-bytes/128-bytes-per-tile * 256 Qwords/tile */
+          OUTREG32(PRI_STREAM_STRIDE,
+                   (((psav->lDelta * 2) << 16) & 0x3FFFE000)
+                   | 0x80000000 | (psav->lDelta & 0x00001fff));
+      }
+      else if (pScrn->bitsPerPixel == 32) {
+          OUTREG32(PRI_STREAM_STRIDE,
+                   (((psav->lDelta * 2) << 16) & 0x3FFFE000)
+                   | 0xC0000000 | (psav->lDelta & 0x00001fff));
+      }
+      
+      
+  }
+  
+  /* set global bitmap descriptor */
+      {
+          OUTREG32(S3_GLB_BD_LOW,psav->GlobalBD.bd2.LoPart );
+          OUTREG32(S3_GLB_BD_HIGH,psav->GlobalBD.bd2.HiPart | BCI_ENABLE | S3_LITTLE_ENDIAN | S3_BD64);
+          
+      }
+  
+  OUTREG(0x48C18, INREG(0x48C18) | 0x8);
+  return TRUE;
+}
+/* get the physics address (for shadow status)*/
+unsigned long SAVAGEDRIGetPhyAddress(ScrnInfoPtr pScrn,void * pointer)
+{
+
+  SavagePtr psav = SAVPTR(pScrn);
+
+  drm_savage_get_physcis_address_t req;
+  int ret;
+
+  req.v_address = (unsigned long )pointer;
+  ret = ioctl(psav->drmFD, DRM_IOCTL_SAVAGE_GET_PHYSICS_ADDRESS,&req);
+  if (ret != 1)
+    fprintf(stderr,"[GetPhyAddress],Wrong virtual address.\n");
+  return req.p_address;
+}
+
+#endif
diff --git a/src/savage_dri.h b/src/savage_dri.h
new file mode 100644
index 0000000..af62e76
--- /dev/null
+++ b/src/savage_dri.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+
+#ifndef __SAVAGE_DRI_H__
+#define __SAVAGE_DRI_H__
+
+#include "xf86drm.h"
+#include "drm.h"
+
+#define SAVAGE_DEFAULT_AGP_MODE     1
+#define SAVAGE_MAX_AGP_MODE         4
+
+/* Buffer are aligned on 4096 byte boundaries.
+ */
+/*  this is used for backbuffer, depthbuffer, etc..*/
+/*          alignment                                      */
+
+#define SAVAGE_BUFFER_ALIGN	0x00000fff
+
+typedef struct{
+    drm_context_t ctxOwner;
+    unsigned long agp_offset;
+    unsigned long agp_handle;
+    unsigned long map_handle;
+    int flags;
+} savageAgpBuffer , *savageAgpBufferPtr;
+
+typedef struct _server{
+   int reserved_map_agpstart;
+   int reserved_map_idx;
+   
+#if 0
+   int buffer_map_idx;
+#endif 
+
+   int sarea_priv_offset;
+
+#if 0
+   int primary_size;
+   int warp_ucode_size;
+#endif 
+
+   int chipset;
+   int sgram;     /* seems no use */
+
+   unsigned int frontOffset;
+   unsigned int frontPitch;
+   unsigned int frontbufferSize;
+   
+   unsigned int backOffset;
+   unsigned int backPitch;
+   unsigned int backbufferSize;
+
+   unsigned int depthOffset;
+   unsigned int depthPitch;
+   unsigned int depthbufferSize;
+
+   unsigned int textureOffset;
+   int textureSize;
+   int logTextureGranularity;
+
+   drmRegion agp;
+
+   /* PCI mappings */
+   drmRegion aperture;
+   drmRegion registers;
+   drmRegion status;
+
+   /* AGP mappings */
+#if 0
+   drmRegion warp;
+   drmRegion primary;
+   drmRegion buffers;
+#endif
+
+   drmRegion agpTextures;
+   int logAgpTextureGranularity;
+
+#if 0
+   drmBufMapPtr drmBuffers;
+#endif
+    /*for agp*/
+    int numBuffer;
+    savageAgpBufferPtr agpBuffer;
+} SAVAGEDRIServerPrivateRec, *SAVAGEDRIServerPrivatePtr;
+
+typedef struct {
+   int chipset;
+   int width;
+   int height;
+   int mem;
+   int cpp;
+   int zpp;
+
+   int agpMode;
+   
+   drm_handle_t frontbuffer;
+   unsigned int frontbufferSize;
+   unsigned int frontOffset;
+   unsigned int frontPitch;
+   unsigned int frontBitmapDesc;   /*Bitmap Descriptior*/ 
+   unsigned int IsfrontTiled;
+
+   drm_handle_t backbuffer;
+   unsigned int backbufferSize;
+   unsigned int backOffset;
+   unsigned int backPitch;
+   unsigned int backBitmapDesc;   /*Bitmap Descriptior*/
+
+   drm_handle_t depthbuffer;
+   unsigned int depthbufferSize;
+   unsigned int depthOffset;
+   unsigned int depthPitch;
+   unsigned int depthBitmapDesc;   /*Bitmap Descriptior*/
+
+
+
+   drm_handle_t textures;
+   drm_handle_t xvmcSurfHandle;
+   unsigned int textureOffset;
+   unsigned int textureSize;
+   int logTextureGranularity;
+
+   /* Allow calculation of setup dma addresses.
+    */
+   unsigned int agpBufferOffset;
+
+   unsigned int agpTextureOffset;
+   unsigned int agpTextureSize;
+   drmRegion agpTextures;
+   int logAgpTextureGranularity;
+
+/*   unsigned int mAccess;*/
+
+   drmRegion aperture;
+   unsigned int aperturePitch;    /* in byte */
+
+
+   drmRegion registers;
+   drmRegion BCIcmdBuf;
+   drmRegion status;
+
+#if 0
+   drmRegion primary;
+   drmRegion buffers;
+#endif
+  /*For shadow status*/
+  unsigned long sareaPhysAddr;
+
+   unsigned int sarea_priv_offset;
+  int shadowStatus;
+} SAVAGEDRIRec, *SAVAGEDRIPtr;
+
+#endif
+
+
+
+
+
+
+
+
diff --git a/src/savage_dripriv.h b/src/savage_dripriv.h
new file mode 100644
index 0000000..19e4487
--- /dev/null
+++ b/src/savage_dripriv.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+#ifndef __SAVAGE_DRIPRIV_H__
+#define __SAVAGE_DRIPRIV_H__
+
+#include "GL/glxint.h"
+
+#define SAVAGE_MAX_DRAWABLES 256
+
+extern void GlxSetVisualConfigs( int nconfigs,
+				 __GLXvisualConfig *configs,
+				 void **configprivs );
+
+typedef struct {
+  /* Nothing here yet */
+  int dummy;
+} SAVAGEConfigPrivRec, *SAVAGEConfigPrivPtr;
+
+typedef struct {
+  /* Nothing here yet */
+  int dummy;
+} SAVAGEDRIContextRec, *SAVAGEDRIContextPtr;
+
+#endif
diff --git a/src/savage_driver.c b/src/savage_driver.c
index 8415d10..c2e63b8 100644
--- a/src/savage_driver.c
+++ b/src/savage_driver.c
@@ -24,6 +24,7 @@
 #include "savage_driver.h"
 #include "savage_bci.h"
 
+#define TRANSPARENCY_KEY 0xff;
 
 /*
  * prototypes
@@ -60,6 +61,7 @@ static void SavageLoadPalette(ScrnInfoPtr pScrn, int numColors,
 static void SavageLoadPaletteSavage4(ScrnInfoPtr pScrn, int numColors,
 			      int *indicies, LOCO *colors,
 			      VisualPtr pVisual);
+static void SavageUpdateKey(ScrnInfoPtr pScrn, int r, int g, int b);
 static void SavageCalcClock(long freq, int min_m, int min_n1, int max_n1,
 			   int min_n2, int max_n2, long freq_min,
 			   long freq_max, unsigned int *mdiv,
@@ -175,24 +177,26 @@ static PciChipsets SavagePciChipsets[] = {
 };
 
 typedef enum {
-     OPTION_PCI_BURST
-    ,OPTION_PCI_RETRY
-    ,OPTION_NOACCEL
-    ,OPTION_LCD_CENTER
-    ,OPTION_LCDCLOCK
-    ,OPTION_MCLK
-    ,OPTION_REFCLK
-    ,OPTION_SHOWCACHE
-    ,OPTION_SWCURSOR
-    ,OPTION_HWCURSOR
-    ,OPTION_SHADOW_FB
-    ,OPTION_ROTATE
-    ,OPTION_USEBIOS
-    ,OPTION_SHADOW_STATUS
-    ,OPTION_CRT_ONLY
-    ,OPTION_TV_ON
-    ,OPTION_TV_PAL
-    ,OPTION_FORCE_INIT
+    OPTION_PCI_BURST,
+    OPTION_PCI_RETRY,
+    OPTION_NOACCEL,
+    OPTION_LCD_CENTER,
+    OPTION_LCDCLOCK,
+    OPTION_MCLK,
+    OPTION_REFCLK,
+    OPTION_SHOWCACHE,
+    OPTION_SWCURSOR,
+    OPTION_HWCURSOR,
+    OPTION_SHADOW_FB,
+    OPTION_ROTATE,
+    OPTION_USEBIOS,
+    OPTION_SHADOW_STATUS,
+    OPTION_CRT_ONLY,
+    OPTION_TV_ON,
+    OPTION_TV_PAL,
+    OPTION_FORCE_INIT,
+    OPTION_OVERLAY,
+    OPTION_T_KEY
 } SavageOpts;
 
 
@@ -210,6 +214,8 @@ static const OptionInfoRec SavageOptions[] =
     { OPTION_TV_ON,     "TvOn",         OPTV_BOOLEAN, {0}, FALSE },
     { OPTION_TV_PAL,    "PAL",          OPTV_BOOLEAN, {0}, FALSE },
     { OPTION_FORCE_INIT,"ForceInit",    OPTV_BOOLEAN, {0}, FALSE },
+    { OPTION_OVERLAY,	"Overlay",	OPTV_ANYSTR, {0}, FALSE },
+    { OPTION_T_KEY,	"TransparencyKey",	OPTV_ANYSTR, {0}, FALSE },
     { -1,		NULL,		OPTV_NONE,    {0}, FALSE }
 };
 
@@ -229,7 +235,7 @@ static const char *vgaHWSymbols[] = {
     "vgaHWSetMmioFuncs",
     "vgaHWSetStdFuncs",
     "vgaHWUnmapMem",
-    "vgaHWddc1SetSpeed",
+    "vgaHWddc1SetSpeedWeak",
 #if 0
     "vgaHWFreeHWRec",
     "vgaHWMapMem",
@@ -247,6 +253,13 @@ static const char *ramdacSymbols[] = {
     NULL
 };
 
+static const char *int10Symbols[] = {
+    "xf86ExecX86int10",
+    "xf86Int10AllocPages",
+    "xf86int10Addr",
+    "xf86Int10FreePages"
+};
+
 static const char *vbeSymbols[] = {
     "VBEInit",
     "vbeDoEDID",
@@ -281,13 +294,14 @@ static const char *i2cSymbols[] = {
 };
 
 static const char *xaaSymbols[] = {
-    "XAACopyROP",
-    "XAACopyROP_PM",
+    "XAAGetCopyROP",
+    "XAAGetCopyROP_PM",
     "XAACreateInfoRec",
     "XAADestroyInfoRec",
     "XAAHelpPatternROP",
     "XAAHelpSolidROP",
     "XAAInit",
+    "XAAScreenIndex",
     NULL
 };
 
@@ -296,18 +310,6 @@ static const char *shadowSymbols[] = {
     NULL
 };
 
-static const char *int10Symbols[] = {
-    "xf86ExecX86int10",
-#if 0
-    "xf86FreeInt10",
-#endif
-    "xf86InitInt10",
-    "xf86Int10AllocPages",
-    "xf86Int10FreePages",
-    "xf86int10Addr",
-    NULL
-};
-
 static const char *fbSymbols[] = {
     "fbPictureInit",
     "fbScreenInit",
@@ -323,7 +325,7 @@ static XF86ModuleVersionInfo SavageVersRec = {
     MODULEVENDORSTRING,
     MODINFOSTRING1,
     MODINFOSTRING2,
-    XF86_VERSION_CURRENT,
+    XORG_VERSION_CURRENT,
     VERSION_MAJOR, VERSION_MINOR, PATCHLEVEL,
     ABI_CLASS_VIDEODRV,
     ABI_VIDEODRV_VERSION,
@@ -398,7 +400,7 @@ ShadowWait( SavagePtr psav )
     BCI_SEND( 0x98000000 + psav->ShadowCounter );
 
     while(
-	(psav->ShadowVirtual[1] & 0x7fff) != psav->ShadowCounter  &&
+	(int)(psav->ShadowVirtual[1] & 0x7fff) != psav->ShadowCounter  &&
 	(loop++ < MAXLOOP)
     )
 	;
@@ -419,7 +421,7 @@ static int
 WaitQueue3D( SavagePtr psav, int v )
 {
     int loop = 0;
-    int slots = MAXFIFO - v;
+    CARD32 slots = MAXFIFO - v;
 
     mem_barrier();
     if( psav->ShadowVirtual )
@@ -440,7 +442,7 @@ static int
 WaitQueue4( SavagePtr psav, int v )
 {
     int loop = 0;
-    int slots = MAXFIFO - v;
+    CARD32 slots = MAXFIFO - v;
 
     if( !psav->NoPCIRetry )
 	return 0;
@@ -460,7 +462,7 @@ static int
 WaitQueue2K( SavagePtr psav, int v )
 {
     int loop = 0;
-    int slots = MAXFIFO - v;
+    CARD32 slots = MAXFIFO - v;
 
     if( !psav->NoPCIRetry )
 	return 0;
@@ -828,6 +830,8 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Option: shadow FB enabled\n");
     }
 
+    psav->primStreamBpp = pScrn->bitsPerPixel;
+
     if ((s = xf86GetOptValString(psav->Options, OPTION_ROTATE))) {
 	if(!xf86NameCmp(s, "CW")) {
 	    /* accel is disabled below for shadowFB */
@@ -858,6 +862,48 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	psav->NoAccel = TRUE;
     }
 
+    if ((s = xf86GetOptValString(psav->Options, OPTION_OVERLAY))) {
+	
+	if (psav->shadowFB) {
+	    xf86DrvMsg(pScrn->scrnIndex,X_INFO,
+		       "Option \"Overlay\" not supported with shadowFB\n");
+	} else {
+	    if (pScrn->depth == 8) {
+		if (!*s || !xf86NameCmp(s, "24")) {
+		    psav->overlayDepth = 24;
+		    psav->NoAccel = TRUE; /* Preliminary */
+		    pScrn->colorKey = TRANSPARENCY_KEY;
+		    pScrn->overlayFlags = OVERLAY_8_32_DUALFB;
+		} else if (!xf86NameCmp(s, "16")) {
+		    psav->overlayDepth = 16;
+		    psav->NoAccel = TRUE; /* Preliminary */
+		    pScrn->colorKey = TRANSPARENCY_KEY;
+		    pScrn->overlayFlags = OVERLAY_8_32_DUALFB;
+		} else {
+		    xf86DrvMsg(pScrn->scrnIndex,X_WARNING,"Wrong argument: "
+			       "\"%s\" Ingnoring\n",s);
+		}
+	    } else if (pScrn->depth != 15) {
+		psav->overlayDepth = 8;
+		psav->NoAccel = TRUE; /* Preliminary */
+		pScrn->colorKey = TRANSPARENCY_KEY;
+		pScrn->overlayFlags = OVERLAY_8_32_DUALFB;
+		if (*s && (xf86NameCmp(s, "8")))
+		    xf86DrvMsg(pScrn->scrnIndex,X_WARNING,"Wrong argument: "
+			       "\"%s\" for depth %i overlay depth must be 8\n",
+			       s,pScrn->depth);
+	    } else {
+		 xf86DrvMsg(pScrn->scrnIndex,X_WARNING,"Overlay not "
+			       "supported for depth 15\n");
+	    }
+	    if (psav->overlayDepth) {
+		xf86DrvMsg(pScrn->scrnIndex,X_INFO,"%i/%i Overlay enabled\n",
+			   pScrn->depth,psav->overlayDepth);
+		psav->primStreamBpp = 8;
+	    } 
+	}
+    }
+
     if (pScrn->bitsPerPixel == 24 && !psav->NoAccel) {
 	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 		   "HW acceleration not possible with depth 32 and bpp 24.\n");
@@ -937,15 +983,10 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	return FALSE;
     }
     psav->EntityIndex = pEnt->index;
-
-    if (xf86LoadSubModule(pScrn, "int10")) {
- 	xf86LoaderReqSymLists(int10Symbols, NULL);
-	psav->pInt10 = xf86InitInt10(pEnt->index);
-    }
-
+    
     if (xf86LoadSubModule(pScrn, "vbe")) {
 	xf86LoaderReqSymLists(vbeSymbols, NULL);
-	psav->pVbe = VBEInit(psav->pInt10, pEnt->index);
+	psav->pVbe = VBEInit(NULL, pEnt->index);
     }
 
 
@@ -1002,6 +1043,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
     if (!SavageMapMMIO(pScrn)) {
 	SavageFreeRec(pScrn);
         vbeFree(psav->pVbe);
+	psav->pVbe = NULL;
 	return FALSE;
     }
 
@@ -1032,6 +1074,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 
 	if (!xf86SetGamma(pScrn, zeros)) {
 	    vbeFree(psav->pVbe);
+	    psav->pVbe = NULL;
 	    SavageFreeRec(pScrn);
 	    return FALSE;
 	}
@@ -1103,6 +1146,41 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 		pScrn->videoRam);
     }
 
+    /* Do the DDC dance. */
+
+    {
+	ddc = xf86LoadSubModule(pScrn, "ddc");
+	if (ddc) {
+	    xf86MonPtr pMon = NULL;
+	   
+	    xf86LoaderReqSymLists(ddcSymbols, NULL);
+/*
+ * On many machines, the attempt to read DDC information via VBE puts the
+ * BIOS access into a state which prevents me from reading mode information.
+ * This is a complete mystery to me.
+ */
+	    if ((psav->pVbe) 
+	       && ((pMon = xf86PrintEDID(vbeDoEDID(psav->pVbe, ddc))) != NULL))
+	       xf86SetDDCproperties(pScrn,pMon);
+	    else if (( psav->Chipset != S3_PROSAVAGE )  
+		&& !SavageDDC1(pScrn->scrnIndex)) {
+		if ( xf86LoadSubModule(pScrn, "i2c") ) {
+		    xf86LoaderReqSymLists(i2cSymbols,NULL);
+		    if (SavageI2CInit(pScrn)) {
+			unsigned char tmp;
+
+			InI2CREG(psav,tmp);
+			OutI2CREG(psav,tmp | 0x13);
+			xf86SetDDCproperties(pScrn,xf86PrintEDID(
+			    xf86DoEDID_DDC2(pScrn->scrnIndex,psav->I2C)));
+			OutI2CREG(psav,tmp);
+		    }
+		}
+	    }
+	}
+    } 
+
+    /* Get video RAM */
     if( !pScrn->videoRam && psav->pVbe )
     {
         /* If VBE is available, ask it about onboard memory. */
@@ -1202,44 +1280,6 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	    break;
     }
 
-    /* Do the DDC dance. */
-
-    if( psav->Chipset != S3_PROSAVAGE ) {
-	ddc = xf86LoadSubModule(pScrn, "ddc");
-	if (ddc) {
-#if 0
-	    xf86MonPtr pMon = NULL;
-#endif
-	   
-	    xf86LoaderReqSymLists(ddcSymbols, NULL);
-#if 0
-/*
- * On many machines, the attempt to read DDC information via VBE puts the
- * BIOS access into a state which prevents me from reading mode information.
- * This is a complete mystery to me.
- */
-	    if ((psav->pVbe) 
-	       && ((pMon = xf86PrintEDID(vbeDoEDID(psav->pVbe, ddc))) != NULL))
-	       xf86SetDDCproperties(pScrn,pMon);
-	    else 
-#endif
-	    if (!SavageDDC1(pScrn->scrnIndex)) {
-		if ( xf86LoadSubModule(pScrn, "i2c") ) {
-		    xf86LoaderReqSymLists(i2cSymbols,NULL);
-		    if (SavageI2CInit(pScrn)) {
-			unsigned char tmp;
-
-			InI2CREG(psav,tmp);
-			OutI2CREG(psav,tmp | 0x13);
-			xf86SetDDCproperties(pScrn,xf86PrintEDID(
-			    xf86DoEDID_DDC2(pScrn->scrnIndex,psav->I2C)));
-			OutI2CREG(psav,tmp);
-		    }
-		}
-	    }
-	}
-    }
-
     /* Savage ramdac speeds */
     pScrn->numClocks = 4;
     pScrn->clock[0] = 250000;
@@ -1374,6 +1414,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "xf86ValidateModes failure\n");
 	SavageFreeRec(pScrn);
 	vbeFree(psav->pVbe);
+	psav->pVbe = NULL;
 	return FALSE;
     }
 
@@ -1383,6 +1424,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
 	SavageFreeRec(pScrn);
 	vbeFree(psav->pVbe);
+	psav->pVbe = NULL;
 	return FALSE;
     }
 
@@ -1395,7 +1437,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	    SavageFreeBIOSModeTable( psav, &psav->ModeTable );
 	}
 
-	psav->ModeTable = SavageGetBIOSModeTable( psav, pScrn->bitsPerPixel );
+	psav->ModeTable = SavageGetBIOSModeTable( psav, psav->primStreamBpp );
 
 	if( !psav->ModeTable || !psav->ModeTable->NumModes ) {
 	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 
@@ -1436,6 +1478,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
     if (xf86LoadSubModule(pScrn, "fb") == NULL) {
 	SavageFreeRec(pScrn);
 	vbeFree(psav->pVbe);
+	psav->pVbe = NULL;
 	return FALSE;
     }
 
@@ -1445,6 +1488,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	if( !xf86LoadSubModule(pScrn, "xaa") ) {
 	    SavageFreeRec(pScrn);
 	    vbeFree(psav->pVbe);
+	    psav->pVbe = NULL;
 	    return FALSE;
 	}
 	xf86LoaderReqSymLists(xaaSymbols, NULL );
@@ -1454,6 +1498,7 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	if (!xf86LoadSubModule(pScrn, "ramdac")) {
 	    SavageFreeRec(pScrn);
 	    vbeFree(psav->pVbe);
+	    psav->pVbe = NULL;
 	    return FALSE;
 	}
 	xf86LoaderReqSymLists(ramdacSymbols, NULL);
@@ -1463,12 +1508,15 @@ static Bool SavagePreInit(ScrnInfoPtr pScrn, int flags)
 	if (!xf86LoadSubModule(pScrn, "shadowfb")) {
 	    SavageFreeRec(pScrn);
 	    vbeFree(psav->pVbe);
+	    psav->pVbe = NULL;
 	    return FALSE;
 	}
 	xf86LoaderReqSymLists(shadowSymbols, NULL);
     }
     vbeFree(psav->pVbe);
 
+    psav->pVbe = NULL;
+
     return TRUE;
 }
 
@@ -1481,7 +1529,13 @@ static Bool SavageEnterVT(int scrnIndex, int flags)
     gpScrn = pScrn;
     SavageEnableMMIO(pScrn);
     SavageSave(pScrn);
-    return SavageModeInit(pScrn, pScrn->currentMode);
+    if(SavageModeInit(pScrn, pScrn->currentMode)) {
+	/* some BIOSes seem to enable HW cursor on PM resume */
+	if (!SAVPTR(pScrn)->hwc_on)
+	    SavageHideCursor( pScrn ); 
+	return TRUE;
+    }
+    return FALSE;
 }
 
 
@@ -1495,6 +1549,7 @@ static void SavageLeaveVT(int scrnIndex, int flags)
 
     TRACE(("SavageLeaveVT(%d)\n", flags));
     gpScrn = pScrn;
+    SavageStreamsOff(pScrn);
     SavageWriteMode(pScrn, vgaSavePtr, SavageSavePtr, FALSE);
     SavageDisableMMIO(pScrn);
 }
@@ -1740,6 +1795,10 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
 	VGAOUT8(vgaCRIndex, 0x53);
 	VGAOUT8(vgaCRReg, VGAIN8(vgaCRReg) & ~0x10);
 
+	/* Disable HW cursor */
+
+	VGAOUT16(vgaCRIndex, 0x0045);
+
 	/* Set the color mode. */
 
 	VGAOUT8(vgaCRIndex, 0x67);
@@ -1748,7 +1807,8 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
 	/* Enable gamma correction. */
 
 	VGAOUT8(0x3c4, 0x1b);
-	if( (pScrn->bitsPerPixel == 32) && !psav->DGAactive )
+	if( (pScrn->bitsPerPixel == 32) && !psav->DGAactive 
+	    && ! psav->FBStart2nd )
 		VGAOUT8(0x3c5, 0x28 );
 	else
 		VGAOUT8(0x3c5, 0x00 );
@@ -1770,7 +1830,7 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
 
 	    if( pScrn->displayWidth >= 1024 )
 	    {
-		if(pScrn->bitsPerPixel == 32 )
+		if(psav->primStreamBpp == 32 )
 		{
 		    if( restore->refresh >= 130 )
 			cr79 = 0x03;
@@ -1787,7 +1847,7 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
 			    cr79 = 0x08;
 		    }
 		}
-		else if( pScrn->bitsPerPixel == 16)
+		else if( psav->primStreamBpp == 16)
 		{
 
 /* The windows driver uses 0x13 for 16-bit 130Hz, but I see terrible
@@ -1824,7 +1884,7 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
         VGAOUT8(vgaCRIndex, 0x50);
         VGAOUT8(vgaCRReg, VGAIN8(vgaCRReg) | 0xC1);
 
-	width = (pScrn->displayWidth * (pScrn->bitsPerPixel / 8)) >> 3;
+	width = (pScrn->displayWidth * (psav->primStreamBpp / 8)) >> 3;
 	VGAOUT16(vgaCRIndex, ((width & 0xff) << 8) | 0x13 );
 	VGAOUT16(vgaCRIndex, ((width & 0x300) << 4) | 0x51 );
 
@@ -1895,7 +1955,7 @@ static void SavageWriteMode(ScrnInfoPtr pScrn, vgaRegPtr vgaSavePtr,
      * switch to mode 3 here seems to eliminate the issue.
      */
 
-    if( ((restore->CR31 & 0x0a) == 0) && psav->pInt10 ) {
+    if( ((restore->CR31 & 0x0a) == 0) && psav->pVbe ) {
 	SavageSetTextMode( psav );
     }
 
@@ -2167,7 +2227,7 @@ static Bool SavageMapMMIO(ScrnInfoPtr pScrn)
     return TRUE;
 }
 
-
+#define TRANSPARENCY_KEY 0xff;
 
 static Bool SavageMapFB(ScrnInfoPtr pScrn)
 {
@@ -2240,6 +2300,7 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
     SavagePtr psav;
     EntityInfoPtr pEnt;
     int ret;
+    int colormapFlags;
 
     TRACE(("SavageScreenInit()\n"));
 
@@ -2247,13 +2308,27 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
     psav = SAVPTR(pScrn);
 
     pEnt = xf86GetEntityInfo(pScrn->entityList[0]); 
-    psav->pVbe = VBEInit(NULL, pEnt->index);
+    if (!psav->pVbe)
+	psav->pVbe = VBEInit(NULL, pEnt->index);
  
     SavageEnableMMIO(pScrn);
 
     if (!SavageMapFB(pScrn))
 	return FALSE;
  
+    psav->FBStart2nd = 0;
+
+    if (psav->overlayDepth) {
+	if ((pScrn->virtualX * pScrn->virtualY *
+	     (DEPTH_BPP(DEPTH_2ND(pScrn))) >> 3)
+	     > (psav->CursorKByte * 1024))
+	    xf86DrvMsg(pScrn->scrnIndex,X_WARNING,
+		       "Not enough memory for overlay mode: disabling\n");
+	else psav->FBStart2nd  = psav->FBStart
+		 + ((pScrn->virtualX * pScrn->virtualY + 0xff) & ~0xff);
+
+    }
+
     if( psav->ShadowStatus ) {
 	psav->ShadowPhysical = 
 	    psav->FrameBufferBase + psav->CursorKByte*1024 + 4096 - 32;
@@ -2285,19 +2360,27 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
 
     miClearVisualTypes();
 
-    if (pScrn->bitsPerPixel == 16) {
-	if (!miSetVisualTypes(pScrn->depth, TrueColorMask,
-			      pScrn->rgbBits, pScrn->defaultVisual))
-	    return FALSE;
-	if (!miSetPixmapDepths ())
-	    return FALSE;
-    } else {
-	if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth),
-			      pScrn->rgbBits, pScrn->defaultVisual))
-	    return FALSE;
-	if (!miSetPixmapDepths ())
-	    return FALSE;
-    }
+    {
+ 	int visual;
+
+ 	visual = ((psav->FBStart2nd && pScrn->bitsPerPixel > 8)
+		   || pScrn->bitsPerPixel == 16) ? TrueColorMask
+	    : miGetDefaultVisualMask(DEPTH_BPP(pScrn->depth));
+ 	if (!miSetVisualTypes(pScrn->depth, visual,
+  			      pScrn->rgbBits, pScrn->defaultVisual))
+  	    return FALSE;
+ 	
+ 	if (psav->FBStart2nd) {/* we have overlay */	
+ 	    visual = psav->overlayDepth > 8 ? TrueColorMask :
+ 		miGetDefaultVisualMask(DEPTH_BPP(psav->overlayDepth));
+ 	    if (!miSetVisualTypes(psav->overlayDepth, visual,
+ 				  psav->overlayDepth > 8 ? 8 : 6, 
+ 				  pScrn->defaultVisual))
+ 		return FALSE;
+ 	}
+     }
+     if (!miSetPixmapDepths ())
+	 return FALSE;
 
     ret = SavageInternalScreenInit(scrnIndex, pScreen);
     if (!ret)
@@ -2305,18 +2388,61 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
 
     xf86SetBlackWhitePixels(pScreen);
 
-    if (pScrn->bitsPerPixel > 8) {
+    {
 	VisualPtr visual;
-
 	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;
+	    if ((visual->class | DynamicClass) == DirectColor
+		&& visual->nplanes > MAX_PSEUDO_DEPTH) {
+		if (visual->nplanes == pScrn->depth) {
+		    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;
+		} else if (visual->offsetRed > 8 
+			   || visual->offsetGreen > 8
+			   || visual->offsetBlue > 8) {
+	/*
+	 * mi has set these wrong. fix it here -- we cannot use pScrn
+	 * as this is set up for the default depth 8.
+	 */
+		    int tmp;
+		    int c_s = 0;
+		    
+		    tmp = visual->offsetBlue;
+		    visual->offsetBlue = visual->offsetRed;
+		    visual->offsetRed = tmp;
+		    tmp = visual->blueMask;
+		    visual->blueMask = visual->redMask;
+		    visual->redMask = tmp;
+		    switch (DEPTH_2ND(pScrn)) {
+			case 16:
+			    visual->offsetRed = 11;
+			    visual->offsetGreen = 5;
+			    visual->offsetBlue = 0;
+			    visual->redMask = 0xF800;
+			    visual->greenMask = 0x7E0;
+			    visual->blueMask = 0x1F;
+			    break;
+			case 24:
+			    visual->offsetRed = 16;
+			    visual->offsetGreen = 8;
+			    visual->offsetBlue = 0;
+			    visual->redMask = 0xFF0000;
+			    visual->greenMask = 0xFF00;
+			    visual->blueMask = 0xFF;
+			    c_s = 2;
+			    break;
+		    }
+		    psav->overlay.redMask = visual->redMask;
+		    psav->overlay.greenMask = visual->greenMask;
+		    psav->overlay.blueMask = visual->blueMask;
+		    psav->overlay.redShift = visual->offsetRed + c_s;
+		    psav->overlay.greenShift = visual->offsetGreen + c_s;
+		    psav->overlay.blueShift = visual->offsetBlue + c_s;
+		}
 	    }
 	}
     }
@@ -2364,19 +2490,17 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
     if (!miCreateDefColormap(pScreen))
 	    return FALSE;
 
+    colormapFlags =  CMAP_RELOAD_ON_MODE_SWITCH
+	| ((psav->FBStart2nd) ? 0 : CMAP_PALETTED_TRUECOLOR);
+    
     if (psav->Chipset == S3_SAVAGE4) {
         if (!xf86HandleColormaps(pScreen, 256, 6, SavageLoadPaletteSavage4,
-				 NULL, 
-				 CMAP_RELOAD_ON_MODE_SWITCH
-				 | CMAP_PALETTED_TRUECOLOR
-				 ))
+				 NULL, colormapFlags ))
 	    return FALSE;
     } else {
         if (!xf86HandleColormaps(pScreen, 256, 6, SavageLoadPalette, NULL,
-				 CMAP_RELOAD_ON_MODE_SWITCH
-				 | CMAP_PALETTED_TRUECOLOR
-				 ))
-	    return FALSE;
+				 colormapFlags ))
+ 	    return FALSE;
     }
 
     vgaHWBlankScreen(pScrn, FALSE);
@@ -2388,7 +2512,7 @@ static Bool SavageScreenInit(int scrnIndex, ScreenPtr pScreen,
     if (xf86DPMSInit(pScreen, SavageDPMS, 0) == FALSE)
 	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "DPMS initialization failed\n");
 
-    if( !psav->NoAccel && !SavagePanningCheck(pScrn) )
+    if( !psav->FBStart2nd && !SavagePanningCheck(pScrn) )
 	SavageInitVideo( pScreen );
 
     if (serverGeneration == 1)
@@ -2432,10 +2556,38 @@ static int SavageInternalScreenInit(int scrnIndex, ScreenPtr pScreen)
 	FBStart = psav->FBStart;
     }
 
-    ret = fbScreenInit(pScreen, FBStart, width, height,
-		       pScrn->xDpi, pScrn->yDpi,
-		       displayWidth,
-		       pScrn->bitsPerPixel);
+    if (!psav->FBStart2nd) {
+	ret = fbScreenInit(pScreen, FBStart, width, height,
+			   pScrn->xDpi, pScrn->yDpi,
+			   displayWidth,
+			   pScrn->bitsPerPixel);
+    } else { 
+	FbOverlayScrPrivPtr pScrPriv;
+	int Depth2nd = DEPTH_2ND(pScrn);
+	if (!fbSetupScreen (pScreen, FBStart, width, height, 
+			    pScrn->xDpi, pScrn->yDpi, displayWidth, 8))
+	    return FALSE;
+	if (pScrn->depth == 8) {
+	    ret = fbOverlayFinishScreenInit (pScreen, FBStart, 
+					     psav->FBStart2nd, width, 
+					     height,pScrn->xDpi, pScrn->yDpi,
+					     displayWidth,displayWidth,
+					     8, DEPTH_BPP(Depth2nd),
+					     8, Depth2nd);
+	    pScrPriv = fbOverlayGetScrPriv(pScreen);
+	    pScrPriv->layer[0].key = pScrn->colorKey;
+	} else {
+	    ret = fbOverlayFinishScreenInit (pScreen, psav->FBStart2nd,
+					     FBStart, 
+					     width, height,pScrn->xDpi, 
+					     pScrn->yDpi,
+					     displayWidth,displayWidth,
+					     DEPTH_BPP(Depth2nd), 8,
+					     Depth2nd, 8);
+	    pScrPriv = fbOverlayGetScrPriv(pScreen);
+	    pScrPriv->layer[1].key = pScrn->colorKey;
+	}
+    }
     return ret;
 }
 
@@ -2550,7 +2702,7 @@ static Bool SavageModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 	    new->CR67 = 0x40;	/* 16bpp, 1 pixels/clock */
 	break;
     case 24:
-	if (pScrn->bitsPerPixel == 24 )
+	if (psav->primStreamBpp == 24 )
 	    new->CR67 = 0x70;
 	else
 	    new->CR67 = 0xd0;
@@ -2691,12 +2843,12 @@ static Bool SavageModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 	new->SR29 = (r & 4) | (m & 0x100) >> 5 | (n & 0x40) >> 2;
 
 	if (psav->fifo_moderate) {
-	    if (pScrn->bitsPerPixel < 24)
+	    if (psav->primStreamBpp < 24)
 		new->MMPR0 -= 0x8000;
 	    else
 		new->MMPR0 -= 0x4000;
 	} else if (psav->fifo_aggressive) {
-	    if (pScrn->bitsPerPixel < 24)
+	    if (psav->primStreamBpp < 24)
 		new->MMPR0 -= 0xc000;
 	    else
 		new->MMPR0 -= 0x6000;
@@ -2736,7 +2888,7 @@ static Bool SavageModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 		    (((mode->CrtcVDisplay - 1) & 0x400) >> 9) |
 		    (((mode->CrtcVSyncStart) & 0x400) >> 8) |
 		    (((mode->CrtcVSyncStart) & 0x400) >> 6) | 0x40;
-	width = (pScrn->displayWidth * (pScrn->bitsPerPixel / 8)) >> 3;
+	width = (pScrn->displayWidth * (psav->primStreamBpp / 8)) >> 3;
 	new->CR91 = vganew->CRTC[19] = 0xff & width;
 	new->CR51 = (0x300 & width) >> 4;
 	new->CR90 = 0x80 | (width >> 8);
@@ -2744,9 +2896,9 @@ static Bool SavageModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 
 	/* Set frame buffer description. */
 
-	if (pScrn->bitsPerPixel <= 8)
+	if (psav->primStreamBpp <= 8)
 	    new->CR50 = 0;
-	else if (pScrn->bitsPerPixel <= 16)
+	else if (psav->primStreamBpp <= 16)
 	    new->CR50 = 0x10;
 	else
 	    new->CR50 = 0x30;
@@ -2792,6 +2944,11 @@ static Bool SavageModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode)
 
     /* do it! */
     SavageWriteMode(pScrn, vganew, new, TRUE);
+    SavageStreamsOn(pScrn);
+
+    if (psav->FBStart2nd)
+	SavageInitSecondaryStream(pScrn);
+
     SavageAdjustFrame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 
     return TRUE;
@@ -2824,6 +2981,7 @@ static Bool SavageCloseScreen(int scrnIndex, ScreenPtr pScreen)
     }
 
     if (pScrn->vtSema) {
+	SavageStreamsOff(pScrn);
 	SavageWriteMode(pScrn, vgaSavePtr, SavageSavePtr, FALSE);
 	vgaHWLock(hwp);
 	SavageUnmapMem(pScrn, 0);
@@ -2847,7 +3005,7 @@ static Bool SavageSaveScreen(ScreenPtr pScreen, int mode)
 	    SavageShowCursor( pScrn );
 	else
 	    SavageHideCursor( pScrn );
-	SAVPTR(pScrn)->hwc_on = TRUE;
+	SAVPTR(pScrn)->hwc_on = TRUE; /*restore */
     }
 
 	return vgaHWSaveScreen(pScreen, mode);
@@ -2871,7 +3029,7 @@ void SavageAdjustFrame(int scrnIndex, int x, int y, int flags)
 	y += pScrn->virtualY - 1;
 
     Base = ((y * pScrn->displayWidth + (x&~1)) *
-	    (pScrn->bitsPerPixel / 8)) >> 2;
+	    (psav->primStreamBpp / 8)) >> 2;
     /* now program the start address registers */
     VGAOUT16(vgaCRIndex, (Base & 0x00ff00) | 0x0c);
     VGAOUT16(vgaCRIndex, ((Base & 0x00ff) << 8) | 0x0d);
@@ -2885,6 +3043,7 @@ void SavageAdjustFrame(int scrnIndex, int x, int y, int flags)
 Bool SavageSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
 {
     TRACE(("SavageSwitchMode\n"));
+    SavageStreamsOff(xf86Screens[scrnIndex]);
     return SavageModeInit(xf86Screens[scrnIndex], mode);
 }
 
@@ -2947,14 +3106,48 @@ void SavageLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indicies,
 {
     SavagePtr psav = SAVPTR(pScrn);
     int i, index;
-
+    int updateKey = -1;
+    
     for (i=0; i<numColors; i++) {
 	index = indicies[i];
+	if (index == pScrn->colorKey) updateKey = index;
 	VGAOUT8(0x3c8, index);
 	VGAOUT8(0x3c9, colors[index].red);
 	VGAOUT8(0x3c9, colors[index].green);
 	VGAOUT8(0x3c9, colors[index].blue);
     }
+    if (updateKey != -1)
+	SavageUpdateKey(pScrn, colors[updateKey].red, colors[updateKey].green,
+			colors[updateKey].blue);
+}
+
+#define Shift(v,d)  ((d) < 0 ? ((v) >> (-d)) : ((v) << (d)))
+
+static void
+SavageUpdateKey(ScrnInfoPtr pScrn, int r, int g, int b)
+{
+    ScreenPtr pScreen;
+    SavagePtr psav = SAVPTR(pScrn);
+    FbOverlayScrPrivPtr pScrOvlPriv;
+    CARD32 key;
+    int ul = 0, ol = 1;
+
+    if (pScrn->depth != 8) {
+	ul = 1;
+	ol = 0;
+    }
+    if (!(pScreen = pScrn->pScreen) 
+	|| !(pScrOvlPriv = fbOverlayGetScrPriv(pScreen))) 
+	return;
+    key = ((Shift(r,psav->overlay.redShift) & psav->overlay.redMask)
+	   | (Shift(g,psav->overlay.greenShift) & psav->overlay.greenMask)
+	   | (Shift(b,psav->overlay.blueShift) & psav->overlay.blueMask));
+    if (pScrOvlPriv->layer[ol].key != key) {
+	pScrOvlPriv->layer[ol].key = key;
+	(*pScrOvlPriv->PaintKey) (&pScrOvlPriv->layer[ol].u.run.pixmap->drawable,
+				  &pScrOvlPriv->layer[ul].u.run.region,
+				  pScrOvlPriv->layer[ol].key, ol);
+    }
 }
 
 #define inStatus1() (hwp->readST01( hwp ))
@@ -2964,7 +3157,8 @@ void SavageLoadPaletteSavage4(ScrnInfoPtr pScrn, int numColors, int *indicies,
 {
     SavagePtr psav = SAVPTR(pScrn);
     int i, index;
-
+    int updateKey = -1;
+    
     vgaHWPtr hwp = VGAHWPTR(pScrn);
     VerticalRetraceWait(psav);
 
@@ -2976,11 +3170,13 @@ void SavageLoadPaletteSavage4(ScrnInfoPtr pScrn, int numColors, int *indicies,
 	VGAOUT8(0x3c9, colors[index].red);
 	VGAOUT8(0x3c9, colors[index].green);
 	VGAOUT8(0x3c9, colors[index].blue);
+	if (index == pScrn->colorKey) updateKey = index;
     }
+    if (updateKey != -1)
+	SavageUpdateKey(pScrn, colors[updateKey].red, colors[updateKey].green,
+			colors[updateKey].blue);
 }
 
-
-
 static void SavageCalcClock(long freq, int min_m, int min_n1, int max_n1,
 
 	/* Make sure linear addressing is enabled after the BIOS call. */
@@ -3232,7 +3428,8 @@ SavageDDC1(int scrnIndex)
     OutI2CREG(psav,tmp | 0x12);
     
     if ((pMon = xf86PrintEDID(
-	xf86DoEDID_DDC1(scrnIndex,vgaHWddc1SetSpeed,SavageDDC1Read))) != NULL)
+	xf86DoEDID_DDC1(scrnIndex,vgaHWddc1SetSpeedWeak(),
+	                SavageDDC1Read))) != NULL)
 	success = TRUE;
     xf86SetDDCproperties(pScrn,pMon);
 
diff --git a/src/savage_driver.h b/src/savage_driver.h
index 4375302..ccf3972 100644
--- a/src/savage_driver.h
+++ b/src/savage_driver.h
@@ -3,6 +3,8 @@
 #ifndef SAVAGE_VGAHWMMIO_H
 #define SAVAGE_VGAHWMMIO_H
 
+#define MODE_24 24
+
 #include "xf86_ansic.h"
 #include "compiler.h"
 #include "vgaHW.h"
@@ -15,6 +17,7 @@
 #include "mipointer.h"
 #include "micmap.h"
 #include "fb.h"
+#include "fboverlay.h"
 #include "xf86cmap.h"
 #include "vbe.h"
 #include "xaa.h"
@@ -70,6 +73,10 @@ typedef struct {
     unsigned int  MMPR0, MMPR1, MMPR2, MMPR3;
 } SavageRegRec, *SavageRegPtr;
 
+typedef  struct {
+    CARD32 redMask, greenMask, blueMask;
+    int redShift, greenShift, blueShift;
+} savageOverlayRec;
 
 typedef struct _Savage {
     SavageRegRec	SavedReg;
@@ -85,7 +92,7 @@ typedef struct _Savage {
     int			videoRambytes;
     int			videoRamKbytes;
     int			MemOffScreen;
-    CARD32		CursorKByte;
+    int			CursorKByte;
 
     /* These are physical addresses. */
     unsigned long	FrameBufferBase;
@@ -178,8 +185,6 @@ typedef struct _Savage {
     unsigned int	SavedSbdOffset;
     unsigned int	SavedSbd;
 
-    /* Support for Int10 processing */
-    xf86Int10InfoPtr	pInt10;
     SavageModeTablePtr	ModeTable;
 
     /* Support for the Savage command overflow buffer. */
@@ -203,6 +208,11 @@ typedef struct _Savage {
     int			dwBCIWait2DIdle;
     XF86OffscreenImagePtr offscreenImages;
 
+    /* Support for Overlays */
+     unsigned char *	FBStart2nd;
+     savageOverlayRec	overlay;
+     int                 overlayDepth;
+     int			primStreamBpp;
 } SavageRec, *SavagePtr;
 
 /* Video flags. */
@@ -213,7 +223,6 @@ typedef struct _Savage {
 
 /* Make the names of these externals driver-unique */
 #define gpScrn savagegpScrn
-#define myOUTREG savageOUTREG
 #define readdw savagereaddw
 #define readfb savagereadfb
 #define writedw savagewritedw
@@ -272,5 +281,22 @@ unsigned short SavageGetBIOSModes(
 
 void SavageInitVideo( ScreenPtr pScreen );
 
+/* In savage_streams.c */
+
+void SavageStreamsOn(ScrnInfoPtr pScrn);
+void SavageStreamsOff(ScrnInfoPtr pScrn);
+void SavageInitSecondaryStream(ScrnInfoPtr pScrn);
+
+#if (MODE_24 == 32)
+# define  BYTES_PP24 4
+#else
+# define BYTES_PP24 3
+#endif
+
+
+#define DEPTH_BPP(depth) (depth == 24 ? (BYTES_PP24 << 3) : (depth + 7) & ~0x7)
+#define DEPTH_2ND(pScrn) (pScrn->depth > 8 ? pScrn->depth\
+                              : SAVPTR(pScrn)->overlayDepth)
+
 #endif /* SAVAGE_VGAHWMMIO_H */
 
diff --git a/src/savage_drm.h b/src/savage_drm.h
new file mode 100644
index 0000000..62bd49b
--- /dev/null
+++ b/src/savage_drm.h
@@ -0,0 +1,248 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+#ifndef __SAVAGE_DRM_H__
+#define __SAVAGE_DRM_H__
+
+#ifndef __SAVAGE_SAREA_DEFINES__
+#define __SAVAGE_SAREA_DEFINES__
+
+#define DRM_SAVAGE_MEM_PAGE (1UL<<12)
+#define DRM_SAVAGE_MEM_WORK 32
+#define DRM_SAVAGE_MEM_LOCATION_PCI 1
+#define DRM_SAVAGE_MEM_LOCATION_AGP 2
+#define DRM_SAVAGE_DMA_AGP_SIZE (16*1024*1024)
+
+typedef struct drm_savage_alloc_cont_mem
+{
+   size_t size; /*size of buffer*/
+   unsigned long type; /*4k page or word*/
+   unsigned long alignment;
+   unsigned long location; /*agp or pci*/
+
+   unsigned long phyaddress;
+   unsigned long linear;
+} drm_savage_alloc_cont_mem_t;
+
+typedef struct drm_savage_get_physcis_address
+{
+   unsigned long v_address;
+   unsigned long p_address;
+}drm_savage_get_physcis_address_t;
+
+/*ioctl number*/
+#define DRM_IOCTL_SAVAGE_ALLOC_CONTINUOUS_MEM \
+	DRM_IOWR(0x40,drm_savage_alloc_cont_mem_t)
+#define DRM_IOCTL_SAVAGE_GET_PHYSICS_ADDRESS \
+	DRM_IOWR(0x41, drm_savage_get_physcis_address_t)
+#define DRM_IOCTL_SAVAGE_FREE_CONTINUOUS_MEM \
+	DRM_IOWR(0x42, drm_savage_alloc_cont_mem_t)
+
+#define SAVAGE_FRONT		0x1
+#define SAVAGE_BACK		0x2
+#define SAVAGE_DEPTH		0x4
+#define SAVAGE_STENCIL		0x8
+
+/* What needs to be changed for the current vertex dma buffer?
+ */
+#define SAVAGE_UPLOAD_CTX	0x1
+#define SAVAGE_UPLOAD_TEX0	0x2
+#define SAVAGE_UPLOAD_TEX1	0x4
+#define SAVAGE_UPLOAD_PIPE	0x8  /* <- seems should be removed, Jiayo Hsu */
+#define SAVAGE_UPLOAD_TEX0IMAGE	0x10 /* handled client-side */
+#define SAVAGE_UPLOAD_TEX1IMAGE	0x20 /* handled client-side */
+#define SAVAGE_UPLOAD_2D	0x40
+#define SAVAGE_WAIT_AGE		0x80 /* handled client-side */
+#define SAVAGE_UPLOAD_CLIPRECTS	0x100 /* handled client-side */
+/*frank:add Buffer state 2001/11/15*/
+#define SAVAGE_UPLOAD_BUFFERS 0x200
+/* original marked off in MGA drivers , Jiayo Hsu Oct.23,2001 */
+
+/* Keep these small for testing.
+ */
+#define SAVAGE_NR_SAREA_CLIPRECTS	8
+
+/* 2 heaps (1 for card, 1 for agp), each divided into upto 128
+ * regions, subject to a minimum region size of (1<<16) == 64k.
+ *
+ * Clients may subdivide regions internally, but when sharing between
+ * clients, the region size is the minimum granularity.
+ */
+
+#define SAVAGE_CARD_HEAP		0
+#define SAVAGE_AGP_HEAP			1
+#define SAVAGE_NR_TEX_HEAPS		2
+#define SAVAGE_NR_TEX_REGIONS		16   /* num. of global texture manage list element*/
+#define SAVAGE_LOG_MIN_TEX_REGION_SIZE	16   /* each region 64K, Jiayo Hsu */
+
+#endif /* __SAVAGE_SAREA_DEFINES__ */
+
+/* drm_tex_region_t define in drm.h */
+
+typedef drm_tex_region_t drm_savage_tex_region_t;
+
+/* Setup registers for 2D, X server
+ */
+typedef struct {
+	unsigned int pitch;
+} drm_savage_server_regs_t;
+
+
+typedef struct _drm_savage_sarea {
+	/* The channel for communication of state information to the kernel
+	 * on firing a vertex dma buffer.
+	 */
+	unsigned int setup[28];    /* 3D context registers */
+   	drm_savage_server_regs_t server_state;
+ 
+   	unsigned int dirty;
+   	
+   	unsigned int vertsize;   /* vertext  size */
+
+	/* The current cliprects, or a subset thereof.
+	 */
+   	drm_clip_rect_t boxes[SAVAGE_NR_SAREA_CLIPRECTS];
+   	unsigned int nbox;
+
+	/* Information about the most recently used 3d drawable.  The
+	 * client fills in the req_* fields, the server fills in the
+	 * exported_ fields and puts the cliprects into boxes, above.
+	 *
+	 * The client clears the exported_drawable field before
+	 * clobbering the boxes data.
+	 */
+        unsigned int req_drawable;	 /* the X drawable id */
+	unsigned int req_draw_buffer;	 /* SAVAGE_FRONT or SAVAGE_BACK */
+
+        unsigned int exported_drawable;
+	unsigned int exported_index;
+        unsigned int exported_stamp;
+        unsigned int exported_buffers;
+        unsigned int exported_nfront;
+        unsigned int exported_nback;
+	int exported_back_x, exported_front_x, exported_w;
+	int exported_back_y, exported_front_y, exported_h;
+   	drm_clip_rect_t exported_boxes[SAVAGE_NR_SAREA_CLIPRECTS];
+
+	/* Counters for aging textures and for client-side throttling.
+	 */
+	unsigned int status[4];
+
+
+	/* LRU lists for texture memory in agp space and on the card.
+	 */
+	drm_tex_region_t texList[SAVAGE_NR_TEX_HEAPS][SAVAGE_NR_TEX_REGIONS+1];
+	unsigned int texAge[SAVAGE_NR_TEX_HEAPS];
+
+	/* Mechanism to validate card state.
+	 */
+   	int ctxOwner;
+	unsigned long shadow_status[64];/*too big?*/
+
+	/*agp offset*/
+	unsigned long agp_offset;
+} drm_savage_sarea_t,*drm_savage_sarea_ptr;
+
+
+/* WARNING: If you change any of these defines, make sure to change the
+ * defines in the Xserver file (xf86drmMga.h)
+ */
+
+typedef struct drm_savage_init {
+
+   	unsigned long sarea_priv_offset;
+
+	int chipset;
+   	int sgram;
+
+	unsigned int maccess;
+
+   	unsigned int fb_cpp;
+	unsigned int front_offset, front_pitch;
+   	unsigned int back_offset, back_pitch;
+
+   	unsigned int depth_cpp;
+   	unsigned int depth_offset, depth_pitch;
+
+   	unsigned int texture_offset[SAVAGE_NR_TEX_HEAPS];
+   	unsigned int texture_size[SAVAGE_NR_TEX_HEAPS];
+
+	unsigned long fb_offset;
+	unsigned long mmio_offset;
+	unsigned long status_offset;
+#if 0
+/*============================================================*/
+	unsigned long warp_offset;
+	unsigned long primary_offset;
+	unsigned long buffers_offset;
+/*============================================================*/
+#endif /*end #if 0 */
+} drm_savage_init_t;
+
+typedef struct drm_savage_fullscreen {
+	enum {
+		SAVAGE_INIT_FULLSCREEN    = 0x01,
+		SAVAGE_CLEANUP_FULLSCREEN = 0x02
+	} func;
+} drm_savage_fullscreen_t;
+
+typedef struct drm_savage_clear {
+	unsigned int flags;
+	unsigned int clear_color;
+	unsigned int clear_depth;
+	unsigned int color_mask;
+	unsigned int depth_mask;
+} drm_savage_clear_t;
+
+typedef struct drm_savage_vertex {
+   	int idx;			/* buffer to queue */
+	int used;			/* bytes in use */
+	int discard;			/* client finished with buffer?  */
+} drm_savage_vertex_t;
+
+typedef struct drm_savage_indices {
+   	int idx;			/* buffer to queue */
+	unsigned int start;
+	unsigned int end;
+	int discard;			/* client finished with buffer?  */
+} drm_savage_indices_t;
+
+typedef struct drm_savage_iload {
+	int idx;
+	unsigned int dstorg;
+	unsigned int length;
+} drm_savage_iload_t;
+
+typedef struct _drm_savage_blit {
+	unsigned int planemask;
+	unsigned int srcorg;
+	unsigned int dstorg;
+	int src_pitch, dst_pitch;
+	int delta_sx, delta_sy;
+	int delta_dx, delta_dy;
+	int height, ydir;		/* flip image vertically */
+	int source_pitch, dest_pitch;
+} drm_savage_blit_t;
+
+#endif
diff --git a/src/savage_hwmc.c b/src/savage_hwmc.c
new file mode 100644
index 0000000..37d314d
--- /dev/null
+++ b/src/savage_hwmc.c
@@ -0,0 +1,403 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86Resources.h"
+#include "xf86_ansic.h"
+#include "compiler.h"
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#include "xf86fbman.h"
+#include "regionstr.h"
+
+#include "savage_driver.h"
+#include "savage_dri.h"
+
+#include "xf86xv.h"
+#include "xf86xvmc.h"
+#include "Xv.h"
+#include "XvMC.h"
+#include "xaa.h"
+#include "xaalocal.h"
+#include "dixstruct.h"
+#include "fourcc.h"
+
+#define SAVAGE_MAX_SURFACES    5 
+#define SAVAGE_MAX_SUBPICTURES 1
+
+#define XVMC_IDCT_8BIT         0x80000000
+
+
+int SAVAGEXvMCCreateContext (ScrnInfoPtr pScrn, XvMCContextPtr pContext,
+                           int *num_priv, long **priv );
+void SAVAGEXvMCDestroyContext (ScrnInfoPtr pScrn, XvMCContextPtr pContext);
+
+int SAVAGEXvMCCreateSurface (ScrnInfoPtr pScrn, XvMCSurfacePtr pSurf,
+                           int *num_priv, long **priv );
+void SAVAGEXvMCDestroySurface (ScrnInfoPtr pScrn, XvMCSurfacePtr pSurf);
+
+int SAVAGEXvMCCreateSubpicture (ScrnInfoPtr pScrn, XvMCSubpicturePtr pSurf,
+                               int *num_priv, long **priv );
+void SAVAGEXvMCDestroySubpicture (ScrnInfoPtr pScrn, XvMCSubpicturePtr pSurf);
+
+
+typedef struct {
+  drm_context_t drmcontext;
+  unsigned int fbBase;
+  unsigned int MMIOHandle;
+  unsigned int MMIOSize;
+  unsigned int SurfaceHandle;
+  unsigned int SurfaceOffset;
+  unsigned int SurfaceSize;
+  unsigned int DCTBlockHandle;
+  unsigned int DCTBlockOffset;
+  unsigned int DCTBlockSize;
+  unsigned int ApertureHandle;
+  unsigned int ApertureSize;
+  unsigned int bitsPerPixel;
+  unsigned int frameX0;
+  unsigned int frameY0;
+  unsigned int IOBase;
+  unsigned int displayWidth;
+  char busIdString[10];
+  char pad[2];
+} SAVAGEXvMCCreateContextRec;
+
+
+static int yv12_subpicture_index_list[1] = 
+{
+  FOURCC_IA44
+};
+
+static XF86MCImageIDList yv12_subpicture_list =
+{
+  1,
+  yv12_subpicture_index_list
+};
+ 
+static XF86MCSurfaceInfoRec savage_YV12_mpg2_surface =
+{
+    FOURCC_YV12,  
+    XVMC_CHROMA_FORMAT_420,
+    0,
+    720,
+    576,
+    720,
+    576,
+    XVMC_MPEG_2,
+    XVMC_OVERLAID_SURFACE | XVMC_INTRA_UNSIGNED | XVMC_BACKEND_SUBPICTURE | XVMC_IDCT_8BIT,
+    &yv12_subpicture_list
+};
+
+static XF86MCSurfaceInfoPtr ppSI[1] = 
+{
+    (XF86MCSurfaceInfoPtr)&savage_YV12_mpg2_surface,
+};
+
+/* List of subpicture types that we support */
+static XF86ImageRec ia44_subpicture = XVIMAGE_IA44;
+
+static XF86ImagePtr savage_subpicture_list[1] =
+{
+  (XF86ImagePtr)&ia44_subpicture,
+};
+
+/* Fill in the device dependent adaptor record. 
+ * This is named "SAVAGE Video Overlay" because this code falls under the
+ * XV extenstion, the name must match or it won't be used.
+ *
+ * Surface and Subpicture - see above
+ * Function pointers to functions below
+ */
+static XF86MCAdaptorRec pAdapt = 
+{
+  "Savage Streams Engine",	/* name */
+  1,				/* num_surfaces */
+  ppSI,				/* surfaces */
+  1,				/* num_subpictures */
+  savage_subpicture_list,		/* subpictures */
+  (xf86XvMCCreateContextProcPtr)SAVAGEXvMCCreateContext,
+  (xf86XvMCDestroyContextProcPtr)SAVAGEXvMCDestroyContext,
+  (xf86XvMCCreateSurfaceProcPtr)SAVAGEXvMCCreateSurface,
+  (xf86XvMCDestroySurfaceProcPtr)SAVAGEXvMCDestroySurface,
+  (xf86XvMCCreateSubpictureProcPtr)SAVAGEXvMCCreateSubpicture,
+  (xf86XvMCDestroySubpictureProcPtr)SAVAGEXvMCDestroySubpicture
+};
+
+static XF86MCAdaptorPtr ppAdapt[1] = 
+{
+	(XF86MCAdaptorPtr)&pAdapt
+};
+
+/**************************************************************************
+ *
+ *  SAVAGEInitMC
+ *
+ *  Initialize the hardware motion compenstation extention for this 
+ *  hardware. The initialization routines want the address of the pointers
+ *  to the structures, not the address of the structures. This means we
+ *  allocate (or create static?) the pointer memory and pass that 
+ *  address. This seems a little convoluted.
+ *
+ *  We need to allocate memory for the device depended adaptor record. 
+ *  This is what holds the pointers to all our device functions.
+ *
+ *  We need to map the overlay registers into the drm.
+ *
+ *  We need to map the surfaces into the drm.
+ *
+ *  Inputs:
+ *    Screen pointer
+ *
+ *  Outputs:
+ *    None, this calls the device independent screen initialization 
+ *    function.
+ *
+ *  Revisions:
+ *  
+ **************************************************************************/
+Bool SAVAGEInitMC(ScreenPtr pScreen)
+{
+  ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  DRIInfoPtr pDRIInfo = pSAVAGE->pDRIInfo;
+  SAVAGEDRIPtr pSAVAGEDriPriv = (SAVAGEDRIPtr)pDRIInfo->devPrivate;
+  int i;
+  unsigned int offset;
+
+  /* Clear the Surface Allocation */
+  for(i=0; i<SAVAGE_MAX_SURFACES; i++) {
+	pSAVAGE->surfaceAllocation[i] = 0;
+  } 
+
+  if(pSAVAGE->hwmcSize == 0)
+  {
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEInitMC: There is not enough memory!\n");
+    return FALSE;
+  }
+
+  offset = pSAVAGE->hwmcOffset + pSAVAGE->FrameBufferBase;
+
+  if(drmAddMap(pSAVAGE->drmFD, offset, pSAVAGE->hwmcSize,
+               DRM_FRAME_BUFFER, 0, &pSAVAGEDriPriv->xvmcSurfHandle) < 0)
+  {
+      
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEInitMC: Cannot add map to drm!\n");
+    return FALSE;
+  } 
+
+  return xf86XvMCScreenInit(pScreen, 1, ppAdapt);
+}
+
+/**************************************************************************
+ *
+ *  SAVAGEXvMCCreateContext
+ *
+ *  Some info about the private data:
+ *
+ *  Set *num_priv to the number of 32bit words that make up the size of
+ *  of the data that priv will point to.
+ *
+ *  *priv = (long *) xcalloc (elements, sizeof(element))
+ *  *num_priv = (elements * sizeof(element)) >> 2;
+ *
+ **************************************************************************/
+
+int SAVAGEXvMCCreateContext (ScrnInfoPtr pScrn, XvMCContextPtr pContext,
+                            int *num_priv, long **priv )
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  DRIInfoPtr pDRIInfo = pSAVAGE->pDRIInfo;
+  SAVAGEDRIPtr pSAVAGEDriPriv = (SAVAGEDRIPtr)pDRIInfo->devPrivate;
+  SAVAGEXvMCCreateContextRec *contextRec;
+  vgaHWPtr hwp = VGAHWPTR(pScrn);
+
+
+  if(!pSAVAGE->directRenderingEnabled) {
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEXvMCCreateContext: Cannot use XvMC without DRI!\n");
+    return BadAlloc;
+  }
+
+  /* Context Already in use! */
+  if(pSAVAGE->xvmcContext) {
+    xf86DrvMsg(X_WARNING, pScrn->scrnIndex,
+        "SAVAGEXvMCCreateContext: 2 XvMC Contexts Attempted, not supported.\n");
+    return BadAlloc;
+  }
+
+  *priv = xcalloc(1,sizeof(SAVAGEXvMCCreateContextRec));
+  contextRec = (SAVAGEXvMCCreateContextRec *)*priv;
+
+  if(!*priv) {
+    *num_priv = 0;
+    return(BadAlloc);
+  }
+
+  *num_priv = sizeof(SAVAGEXvMCCreateContextRec) >> 2;
+
+  if(drmCreateContext(pSAVAGE->drmFD, &(contextRec->drmcontext) ) < 0) {
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEXvMCCreateContext: Unable to create DRMContext!\n");
+    xfree(*priv);
+    return(BadAlloc);
+  }
+
+  drmAuthMagic(pSAVAGE->drmFD, pContext->flags);
+
+  pSAVAGE->xvmcContext = contextRec->drmcontext;
+  contextRec->fbBase = pScrn->memPhysBase;
+
+  contextRec->MMIOHandle = pSAVAGEDriPriv->registers.handle;
+  contextRec->MMIOSize = pSAVAGEDriPriv->registers.size;
+
+  contextRec->DCTBlockHandle = pSAVAGEDriPriv->agpTextures.handle;
+  contextRec->DCTBlockOffset = pSAVAGEDriPriv->agpTextures.offset;
+  contextRec->DCTBlockSize = pSAVAGEDriPriv->agpTextures.size;
+
+  contextRec->SurfaceHandle = pSAVAGEDriPriv->xvmcSurfHandle;
+  contextRec->SurfaceOffset = pSAVAGE->hwmcOffset;
+  contextRec->SurfaceSize = pSAVAGE->hwmcSize;
+
+  contextRec->ApertureHandle = pSAVAGEDriPriv->aperture.handle;
+  contextRec->ApertureSize = pSAVAGEDriPriv->aperture.size;
+
+  contextRec->bitsPerPixel = pScrn->bitsPerPixel;
+  contextRec->frameX0 = pScrn->frameX0;
+  contextRec->frameY0 = pScrn->frameY0;
+  contextRec->IOBase = hwp->IOBase;
+  contextRec->displayWidth = pScrn->displayWidth;
+
+
+  strncpy (contextRec->busIdString, pDRIInfo->busIdString, 9);
+
+  return Success;
+}
+
+
+int SAVAGEXvMCCreateSurface (ScrnInfoPtr pScrn, XvMCSurfacePtr pSurf,
+                           int *num_priv, long **priv )
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  int i;
+  /* This size is used for flip, mixer, subpicture and palette buffers*/
+  unsigned int offset = ((786*576*2 + 2048)*5 + 2048) & 0xfffff800; 
+
+  *priv = (long *)xcalloc(2,sizeof(long));
+
+  if(!*priv) {
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEXvMCCreateSurface: Unable to allocate memory!\n");
+    *num_priv = 0;
+    return (BadAlloc);
+  }
+  *num_priv = 1;
+
+  /* Surface Arrangement is different based on 6 or 7 Surfaces */
+  for(i = 0; i < SAVAGE_MAX_SURFACES; i++) {
+      if(!pSAVAGE->surfaceAllocation[i]) {
+         pSAVAGE->surfaceAllocation[i] = pSurf->surface_id;
+         (*priv)[0] =  offset + (576 * 786 * 2 + 2048) * i;
+         /* UV data starts at 0 offset, each set is 288k * */
+         return Success;
+      }
+  }
+
+  (*priv)[0] = 0;
+  return BadAlloc;
+}
+
+int SAVAGEXvMCCreateSubpicture (ScrnInfoPtr pScrn, XvMCSubpicturePtr pSubp,
+                              int *num_priv, long **priv )
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  int i;
+
+  *priv = (long *)xcalloc(1,sizeof(long));
+
+  if(!*priv) {
+    xf86DrvMsg(X_ERROR, pScrn->scrnIndex,
+        "SAVAGEXvMCCreateSubpicture: Unable to allocate memory!\n");
+    *num_priv = 0;
+    return (BadAlloc);
+  }
+
+  *num_priv = 1;
+
+  for(i = SAVAGE_MAX_SURFACES; i < SAVAGE_MAX_SURFACES + SAVAGE_MAX_SUBPICTURES; i++) {  
+      if(!pSAVAGE->surfaceAllocation[i]) {
+          pSAVAGE->surfaceAllocation[i] = pSubp->subpicture_id;
+          (*priv)[0] = ( 576*1024 * i);
+          return Success;
+     }
+  }
+
+  (*priv)[0] = 0;
+  return BadAlloc;
+}
+
+void SAVAGEXvMCDestroyContext (ScrnInfoPtr pScrn, XvMCContextPtr pContext)
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+
+  drmDestroyContext(pSAVAGE->drmFD,pSAVAGE->xvmcContext);
+  pSAVAGE->xvmcContext = 0;
+}
+
+void SAVAGEXvMCDestroySurface (ScrnInfoPtr pScrn, XvMCSurfacePtr pSurf)
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  int i;
+
+  for(i=0; i<SAVAGE_MAX_SURFACES; i++) {
+    if(pSAVAGE->surfaceAllocation[i] == pSurf->surface_id) {
+      pSAVAGE->surfaceAllocation[i] = 0;
+      return;
+    }
+  }
+  return;
+}
+
+void SAVAGEXvMCDestroySubpicture (ScrnInfoPtr pScrn, XvMCSubpicturePtr pSubp)
+{
+  SavagePtr pSAVAGE = SAVPTR(pScrn);
+  int i;
+
+  for(i = SAVAGE_MAX_SURFACES; i < SAVAGE_MAX_SURFACES + SAVAGE_MAX_SUBPICTURES; i++) {
+    if(pSAVAGE->surfaceAllocation[i] == pSubp->subpicture_id) {
+      pSAVAGE->surfaceAllocation[i] = 0;
+      return;
+    }
+  }
+  return;
+}
+
+
+
+
+
+
diff --git a/src/savage_image.c b/src/savage_image.c
index 8b9605b..9530bff 100644
--- a/src/savage_image.c
+++ b/src/savage_image.c
@@ -102,7 +102,7 @@ SavageWriteBitmapCPUToScreenColorExpand (
     cmd = BCI_CMD_RECT | BCI_CMD_RECT_XP | BCI_CMD_RECT_YP
         | BCI_CMD_SEND_COLOR | BCI_CMD_CLIP_LR
         | BCI_CMD_DEST_GBD | BCI_CMD_SRC_MONO;
-    cmd |= XAACopyROP[rop] << 16;
+    cmd |= XAAGetCopyROP(rop) << 16;
 
     if( bg == -1 )
         cmd |= BCI_CMD_SRC_TRANSPARENT;
@@ -160,7 +160,7 @@ SavageSetupForImageWrite(
         | BCI_CMD_CLIP_LR
         | BCI_CMD_DEST_GBD | BCI_CMD_SRC_COLOR;
 
-    cmd |= XAACopyROP[rop] << 16;
+    cmd |= XAAGetCopyROP(rop) << 16;
 
     if( transparency_color != -1 )
         cmd |= BCI_CMD_SRC_TRANSPARENT;
@@ -181,13 +181,11 @@ void SavageSubsequentImageWriteRect
 {
     SavagePtr psav = SAVPTR(pScrn);
     BCI_GET_PTR;
-    int count;
 
-    count = ((w * pScrn->bitsPerPixel + 31) / 32) * h;
-    psav->WaitQueue( psav, count );
+    psav->WaitQueue( psav, 6 );
     BCI_SEND(psav->SavedBciCmd);
     BCI_SEND(BCI_CLIP_LR(x+skipleft, x+w-1));
-    if( psav->SavedBgColor != -1 )
+    if( psav->SavedBgColor != 0xffffffff )
         BCI_SEND(psav->SavedBgColor);
     BCI_SEND(BCI_X_Y(x, y));
     BCI_SEND(BCI_W_H(w, h));
diff --git a/src/savage_regs.h b/src/savage_regs.h
index 0f807a1..92f0584 100644
--- a/src/savage_regs.h
+++ b/src/savage_regs.h
@@ -66,97 +66,6 @@ enum S3CHIPTAGS {
 #define STREAMS_TIMEOUT_REG		0x8208
 #define MISC_TIMEOUT_REG		0x820c
 
-/* Stream Processor 1 */
-
-/* Primary Stream 1 Frame Buffer Address 0 */
-#define PRI_STREAM_FBUF_ADDR0           0x81c0
-/* Primary Stream 1 Frame Buffer Address 0 */
-#define PRI_STREAM_FBUF_ADDR1           0x81c4
-/* Primary Stream 1 Stride */
-#define PRI_STREAM_STRIDE               0x81c8
-/* Primary Stream 1 Frame Buffer Size */
-#define PRI_STREAM_BUFFERSIZE           0x8214
-
-/* Secondary stream 1 Color/Chroma Key Control */
-#define SEC_STREAM_CKEY_LOW             0x8184
-/* Secondary stream 1 Chroma Key Upper Bound */
-#define SEC_STREAM_CKEY_UPPER           0x8194
-/* Blend Control of Secondary Stream 1 & 2 */
-#define BLEND_CONTROL                   0x8190
-/* Secondary Stream 1 Color conversion/Adjustment 1 */
-#define SEC_STREAM_COLOR_CONVERT1       0x8198
-/* Secondary Stream 1 Color conversion/Adjustment 2 */
-#define SEC_STREAM_COLOR_CONVERT2       0x819c
-/* Secondary Stream 1 Color conversion/Adjustment 3 */
-#define SEC_STREAM_COLOR_CONVERT3       0x81e4
-/* Secondary Stream 1 Horizontal Scaling */
-#define SEC_STREAM_HSCALING             0x81a0
-/* Secondary Stream 1 Frame Buffer Size */
-#define SEC_STREAM_BUFFERSIZE           0x81a8
-/* Secondary Stream 1 Horizontal Scaling Normalization (2K only) */
-#define SEC_STREAM_HSCALE_NORMALIZE	0x81ac
-/* Secondary Stream 1 Horizontal Scaling */
-#define SEC_STREAM_VSCALING             0x81e8
-/* Secondary Stream 1 Frame Buffer Address 0 */
-#define SEC_STREAM_FBUF_ADDR0           0x81d0
-/* Secondary Stream 1 Frame Buffer Address 1 */
-#define SEC_STREAM_FBUF_ADDR1           0x81d4
-/* Secondary Stream 1 Frame Buffer Address 2 */
-#define SEC_STREAM_FBUF_ADDR2           0x81ec
-/* Secondary Stream 1 Stride */
-#define SEC_STREAM_STRIDE               0x81d8
-/* Secondary Stream 1 Window Start Coordinates */
-#define SEC_STREAM_WINDOW_START         0x81f8
-/* Secondary Stream 1 Window Size */
-#define SEC_STREAM_WINDOW_SZ            0x81fc
-/* Secondary Streams Tile Offset */
-#define SEC_STREAM_TILE_OFF             0x821c
-/* Secondary Stream 1 Opaque Overlay Control */
-#define SEC_STREAM_OPAQUE_OVERLAY       0x81dc
-
-
-/* Stream Processor 2 */
-
-/* Primary Stream 2 Frame Buffer Address 0 */
-#define PRI_STREAM2_FBUF_ADDR0          0x81b0
-/* Primary Stream 2 Frame Buffer Address 1 */
-#define PRI_STREAM2_FBUF_ADDR1          0x81b4
-/* Primary Stream 2 Stride */
-#define PRI_STREAM2_STRIDE              0x81b8
-/* Primary Stream 2 Frame Buffer Size */
-#define PRI_STREAM2_BUFFERSIZE          0x8218
-
-/* Secondary Stream 2 Color/Chroma Key Control */
-#define SEC_STREAM2_CKEY_LOW            0x8188
-/* Secondary Stream 2 Chroma Key Upper Bound */
-#define SEC_STREAM2_CKEY_UPPER          0x818c
-/* Secondary Stream 2 Horizontal Scaling */
-#define SEC_STREAM2_HSCALING            0x81a4
-/* Secondary Stream 2 Horizontal Scaling */
-#define SEC_STREAM2_VSCALING            0x8204
-/* Secondary Stream 2 Frame Buffer Size */
-#define SEC_STREAM2_BUFFERSIZE          0x81ac
-/* Secondary Stream 2 Frame Buffer Address 0 */
-#define SEC_STREAM2_FBUF_ADDR0          0x81bc
-/* Secondary Stream 2 Frame Buffer Address 1 */
-#define SEC_STREAM2_FBUF_ADDR1          0x81e0
-/* Secondary Stream 2 Frame Buffer Address 2 */
-#define SEC_STREAM2_FBUF_ADDR2          0x8208
-/* Multiple Buffer/LPB and Secondary Stream 2 Stride */
-#define SEC_STREAM2_STRIDE_LPB          0x81cc
-/* Secondary Stream 2 Color conversion/Adjustment 1 */
-#define SEC_STREAM2_COLOR_CONVERT1      0x81f0
-/* Secondary Stream 2 Color conversion/Adjustment 2 */
-#define SEC_STREAM2_COLOR_CONVERT2      0x81f4
-/* Secondary Stream 2 Color conversion/Adjustment 3 */
-#define SEC_STREAM2_COLOR_CONVERT3      0x8200
-/* Secondary Stream 2 Window Start Coordinates */
-#define SEC_STREAM2_WINDOW_START        0x820c
-/* Secondary Stream 2 Window Size */
-#define SEC_STREAM2_WINDOW_SZ           0x8210
-/* Secondary Stream 2 Opaque Overlay Control */
-#define SEC_STREAM2_OPAQUE_OVERLAY      0x8180
-
 
 #define SUBSYS_STAT_REG			0x8504
 
@@ -198,8 +107,8 @@ enum S3CHIPTAGS {
         VGAIN8(psav->vgaIOBase+4); \
 	VGAOUT8(psav->vgaIOBase+4, 0x17); \
 	if (VGAIN8(psav->vgaIOBase+5) & 0x80) { \
-		while ((VGAIN8(psav->vgaIOBase + 0x0a) & 0x08) == 0x08) ; \
-		while ((VGAIN8(psav->vgaIOBase + 0x0a) & 0x08) == 0x00) ; \
+		while ((VGAIN8(psav->vgaIOBase + 0x0a) & 0x08) == 0x08) {}; \
+		while ((VGAIN8(psav->vgaIOBase + 0x0a) & 0x08) == 0x00) {}; \
 	} \
 }
 
diff --git a/src/savage_sarea.h b/src/savage_sarea.h
new file mode 100644
index 0000000..d4287cf
--- /dev/null
+++ b/src/savage_sarea.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2001-2003 S3 Graphics, Inc. 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
+ * VIA, S3 GRAPHICS, AND/OR ITS 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.
+ */
+
+
+#ifndef __SAVAGE_SAREA_H__
+#define __SAVAGE_SAREA_H__
+
+#include "drm.h"
+
+/* WARNING: If you change any of these defines, make sure to change
+ * the kernel include file as well (savage_drm.h)
+ */
+#ifndef __SAVAGE_SAREA_DEFINES__
+#define __SAVAGE_SAREA_DEFINES__
+#endif
+typedef drm_savage_sarea_t SAVAGESAREAPrivRec;
+typedef drm_savage_sarea_t *SAVAGESAREAPrivPtr;
+
+
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/savage_streams.c b/src/savage_streams.c
new file mode 100644
index 0000000..88936e3
--- /dev/null
+++ b/src/savage_streams.c
@@ -0,0 +1,461 @@
+#include "Xv.h"
+#include "dix.h"
+#include "dixstruct.h"
+
+#include "savage_driver.h"
+#include "savage_streams.h"
+
+#define STREAMS_TRACE	4
+
+static void SavageInitStreamsOld(ScrnInfoPtr pScrn);
+static void SavageInitStreamsNew(ScrnInfoPtr pScrn);
+
+static void OverlayParamInit(ScrnInfoPtr pScrn);
+static void InitStreamsForExpansion(ScrnInfoPtr pScrn);
+
+static void
+SavageInitSecondaryStreamOld(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    vgaHWPtr hwp;
+    unsigned short vgaIOBase, vgaCRIndex, vgaCRReg;
+    int offset = (psav->FBStart2nd - psav->FBStart);
+    int colorkey = pScrn->colorKey;
+    int pitch = pScrn->displayWidth * DEPTH_BPP(DEPTH_2ND(pScrn))/8;
+    CARD8 cr92;
+
+    hwp = VGAHWPTR(pScrn);
+    vgaHWGetIOBase(hwp);
+    vgaIOBase = hwp->IOBase;
+    vgaCRIndex = vgaIOBase + 4;
+    vgaCRReg = vgaIOBase + 5;
+
+    OUTREG(COL_CHROMA_KEY_CONTROL_REG, 0x37000000 | (colorkey & 0xFF));
+    OUTREG(CHROMA_KEY_UPPER_BOUND_REG, 0x00000000 | (colorkey & 0xFF));
+    OUTREG(BLEND_CONTROL_REG, 0x05000000 );
+    OUTREG(SSTREAM_CONTROL_REG, SSTREAMS_MODE(DEPTH_BPP(DEPTH_2ND(pScrn)))
+	   << 24  | pScrn->displayWidth );
+    OUTREG(SSTREAM_STRETCH_REG, 1 << 15);
+    OUTREG(SSTREAM_VSCALE_REG, 1 << 15);
+    OUTREG(SSTREAM_LINES_REG, pScrn->virtualY );
+    OUTREG(SSTREAM_VINITIAL_REG, 0 );
+    OUTREG(SSTREAM_FBADDR0_REG, offset & 0x1ffffff & ~BASE_PAD);
+    OUTREG(SSTREAM_FBADDR1_REG, 0 );
+    
+    OUTREG(SSTREAM_STRIDE_REG, pitch);
+    OUTREG(SSTREAM_WINDOW_START_REG, OS_XY(0,0));
+    OUTREG(SSTREAM_WINDOW_SIZE_REG, 
+	   OS_WH(pScrn->displayWidth, pScrn->virtualY));
+
+    pitch = (pitch + 7) / 8;
+    VGAOUT8(vgaCRIndex, 0x92);
+    cr92 = VGAIN8(vgaCRReg);
+    VGAOUT8(vgaCRReg, (cr92 & 0x40) | (pitch >> 8) | 0x80);
+    VGAOUT8(vgaCRIndex, 0x93);
+    VGAOUT8(vgaCRReg, pitch);
+    OUTREG(STREAMS_FIFO_REG, 2 | 25 << 5 | 32 << 11);
+}
+
+static void
+SavageInitSecondaryStreamNew(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    vgaHWPtr hwp;
+    unsigned short vgaIOBase, vgaCRIndex, vgaCRReg;
+    int offset = (psav->FBStart2nd - psav->FBStart);
+    int colorkey = pScrn->colorKey;
+    int pitch = pScrn->displayWidth * DEPTH_BPP(DEPTH_2ND(pScrn))/8;
+    CARD8 cr92;
+
+    hwp = VGAHWPTR(pScrn);
+
+    vgaHWGetIOBase(hwp);
+    vgaIOBase = hwp->IOBase;
+    vgaCRIndex = vgaIOBase + 4;
+    vgaCRReg = vgaIOBase + 5;
+
+    OUTREG( SEC_STREAM_CKEY_LOW, 0x47000000 | (colorkey & 0xFF));
+    OUTREG( SEC_STREAM_CKEY_UPPER, 0x47000000 | (colorkey & 0xFF));
+    OUTREG( BLEND_CONTROL, SSTREAMS_MODE(DEPTH_BPP(DEPTH_2ND(pScrn))) << 9
+	    | 0x08 );
+    if( psav->Chipset == S3_SAVAGE2000 )  {
+	OUTREG(SEC_STREAM_HSCALING,  1 << 15);
+	OUTREG(SEC_STREAM_HSCALE_NORMALIZE, 2048 << 16 );
+	OUTREG(SEC_STREAM_VSCALING, 1 << 15);
+    }  else  {
+	OUTREG(SEC_STREAM_HSCALING,((pScrn->displayWidth &0xfff)<<20) | 1<<15);
+	/* BUGBUG need to add 00040000 if src stride > 2048 */
+	OUTREG(SEC_STREAM_VSCALING,((pScrn->virtualY &0xfff)<<20) | 1<<15);
+    }
+
+    OUTREG(SEC_STREAM_FBUF_ADDR0, offset & (0x7ffffff & ~BASE_PAD));
+    OUTREG(SEC_STREAM_STRIDE, pitch);
+    OUTREG(SEC_STREAM_WINDOW_START, OS_XY(0,0));
+    /* ? width may need to be increased by 1 */
+    OUTREG(SEC_STREAM_WINDOW_SZ, OS_WH(pScrn->displayWidth, pScrn->virtualY));
+    
+    pitch = (pitch + 7) / 8;
+    VGAOUT8(vgaCRIndex, 0x92);
+    cr92 = VGAIN8(vgaCRReg);
+    VGAOUT8(vgaCRReg, (cr92 & 0x40) | (pitch >> 8) | 0x80);
+    VGAOUT8(vgaCRIndex, 0x93);
+    VGAOUT8(vgaCRReg, pitch);
+}
+
+void
+SavageInitSecondaryStream(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+
+    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
+	(psav->Chipset == S3_SUPERSAVAGE) ||
+	(psav->Chipset == S3_SAVAGE2000) )
+	SavageInitSecondaryStreamNew(pScrn);
+    else 
+	SavageInitSecondaryStreamOld(pScrn);
+}
+
+void SavageInitStreamsOld(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    unsigned long jDelta;
+    unsigned long format = 0;
+
+    /*
+     * For the OLD streams engine, several of these registers
+     * cannot be touched unless streams are on.  Seems backwards to me;
+     * I'd want to set 'em up, then cut 'em loose.
+     */
+
+    xf86ErrorFVerb(STREAMS_TRACE, "SavageInitStreams\n" );
+
+    /* Primary stream reflects the frame buffer. */
+
+    if (psav->FBStart2nd) {
+	jDelta = pScrn->displayWidth;
+	format = 0 << 24;
+    } else {
+	jDelta = pScrn->displayWidth * (pScrn->bitsPerPixel + 7) / 8;
+	switch( pScrn->depth ) {
+	    case  8: format = 0 << 24; break;
+	    case 15: format = 3 << 24; break;
+	    case 16: format = 5 << 24; break;
+	    case 24: format = 7 << 24; break;
+	}
+    }
+    
+    OUTREG( PSTREAM_WINDOW_START_REG, OS_XY(0,0) );
+    OUTREG( PSTREAM_WINDOW_SIZE_REG, OS_WH(pScrn->displayWidth, pScrn->virtualY) );
+    OUTREG( PSTREAM_FBADDR0_REG, pScrn->fbOffset );
+    OUTREG( PSTREAM_FBADDR1_REG, 0 );
+    OUTREG( PSTREAM_STRIDE_REG, jDelta );
+    OUTREG( PSTREAM_CONTROL_REG, format );
+    OUTREG( PSTREAM_FBSIZE_REG, jDelta * pScrn->virtualY >> 3 );
+
+    OUTREG( COL_CHROMA_KEY_CONTROL_REG, 0 );
+    OUTREG( SSTREAM_CONTROL_REG, 0 );
+    OUTREG( CHROMA_KEY_UPPER_BOUND_REG, 0 );
+    OUTREG( SSTREAM_STRETCH_REG, 0 );
+    OUTREG( COLOR_ADJUSTMENT_REG, 0 );
+    OUTREG( BLEND_CONTROL_REG, 1 << 24 );
+    OUTREG( DOUBLE_BUFFER_REG, 0 );
+    OUTREG( SSTREAM_FBADDR0_REG, 0 );
+    OUTREG( SSTREAM_FBADDR1_REG, 0 );
+    OUTREG( SSTREAM_FBADDR2_REG, 0 );
+/*    OUTREG( SSTREAM_FBSIZE_REG, 0 ); */
+    OUTREG( SSTREAM_STRIDE_REG, 0 );
+    OUTREG( SSTREAM_VSCALE_REG, 0 );
+    OUTREG( SSTREAM_LINES_REG, 0 );
+    OUTREG( SSTREAM_VINITIAL_REG, 0 );
+    OUTREG( SSTREAM_WINDOW_START_REG, OS_XY(0xfffe, 0xfffe) );
+    OUTREG( SSTREAM_WINDOW_SIZE_REG, OS_WH(10,2) );
+    OUTREG(STREAMS_FIFO_REG, 2 | 25 << 5 | 32 << 11);
+
+    {
+	vgaHWPtr hwp;
+	unsigned short vgaIOBase, vgaCRIndex, vgaCRReg;
+	unsigned char cr90;
+
+	hwp = VGAHWPTR(pScrn);
+	
+	vgaHWGetIOBase(hwp);
+	vgaIOBase = hwp->IOBase;
+	vgaCRIndex = vgaIOBase + 4;
+	vgaCRReg = vgaIOBase + 5;
+
+	VGAOUT8(vgaCRIndex, 0x90);
+	cr90 = VGAIN8(vgaCRReg);
+	VGAOUT8(vgaCRReg, (cr90 & 0x7F));
+    }
+}
+
+static void
+SavageInitStreamsNew(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    unsigned long jDelta;
+
+    xf86ErrorFVerb(STREAMS_TRACE, "SavageInitStreams\n" );
+
+    if( 
+	S3_SAVAGE_MOBILE_SERIES(psav->Chipset) && 
+	!psav->CrtOnly && 
+	!psav->TvOn 
+    ) {
+	OverlayParamInit( pScrn );
+    }
+
+    /* Primary stream reflects the frame buffer. */
+
+    if (psav->FBStart2nd)
+	jDelta = pScrn->displayWidth;
+    else
+	jDelta = pScrn->displayWidth * (pScrn->bitsPerPixel + 7) / 8;
+    
+    OUTREG( PRI_STREAM_BUFFERSIZE, jDelta * pScrn->virtualY >> 3 );
+    OUTREG( PRI_STREAM_FBUF_ADDR0, pScrn->fbOffset );
+    OUTREG( PRI_STREAM_STRIDE, jDelta );
+
+    OUTREG( SEC_STREAM_CKEY_LOW, 0 );
+    OUTREG( SEC_STREAM_CKEY_UPPER, 0 );
+    OUTREG( SEC_STREAM_HSCALING, 0 );
+    OUTREG( SEC_STREAM_VSCALING, 0 );
+    OUTREG( BLEND_CONTROL, 0 );
+    OUTREG( SEC_STREAM_FBUF_ADDR0, 0 );
+    OUTREG( SEC_STREAM_FBUF_ADDR1, 0 );
+    OUTREG( SEC_STREAM_FBUF_ADDR2, 0 );
+    OUTREG( SEC_STREAM_WINDOW_START, 0 );
+    OUTREG( SEC_STREAM_WINDOW_SZ, 0 );
+/*    OUTREG( SEC_STREAM_BUFFERSIZE, 0 ); */
+    OUTREG( SEC_STREAM_TILE_OFF, 0 );
+    OUTREG( SEC_STREAM_OPAQUE_OVERLAY, 0 );
+    OUTREG( SEC_STREAM_STRIDE, 0 );
+
+    /* These values specify brightness, contrast, saturation and hue. */
+    OUTREG( SEC_STREAM_COLOR_CONVERT1, 0x0000C892 );
+    OUTREG( SEC_STREAM_COLOR_CONVERT2, 0x00039F9A );
+    OUTREG( SEC_STREAM_COLOR_CONVERT3, 0x01F1547E );
+#if 0
+    {
+	vgaHWPtr hwp;
+	unsigned short vgaIOBase, vgaCRIndex, vgaCRReg;
+	hwp = VGAHWPTR(pScrn);
+	unsigned char cr90;
+
+	vgaHWGetIOBase(hwp);
+	vgaIOBase = hwp->IOBase;
+	vgaCRIndex = vgaIOBase + 4;
+	vgaCRReg = vgaIOBase + 5;
+
+	VGAOUT8(vgaCRIndex, 0x90);
+	cr90 = VGAIN8(vgaCRReg);
+	VGAOUT8(vgaCRReg, (cr90 & 0x7F));
+    }
+#endif
+}
+
+
+/* Function to get lcd factor, display offset for overlay use
+ * Input: pScrn; Output: x,yfactor, displayoffset in pScrn
+ */
+static void OverlayParamInit(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+
+    psav = SAVPTR(pScrn);
+    psav->cxScreen = pScrn->currentMode->HDisplay;
+    InitStreamsForExpansion(pScrn);
+}
+
+/* Function to calculate lcd expansion x,y factor and offset for overlay
+ */
+static void InitStreamsForExpansion(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    int		PanelSizeX,PanelSizeY;
+    int		ViewPortWidth,ViewPortHeight;
+    int		XExpansion, YExpansion;
+    int		XFactor, YFactor;
+    int		Hstate, Vstate;
+
+    static CARD32 Xfactors[] = {
+	0x00010001,
+	0x00010001, /* 1 */
+	0,
+	0x00090008, /* 3 */
+	0x00050004, /* 4 */
+	0,
+	0x00030002, /* 6 */
+	0x00020001  /* 7 */
+    };
+
+    static CARD32 Yfactors[] = {
+	0x00010001,	0x00010001,
+	0,		0x00060005,
+	0x00050004,	0x00040003,
+	0,		0x00030002,
+	0x00020001,	0x00050002,
+	0x000C0005,	0x00080003,
+	0x00090004,	0,
+	0x00030001,	0x00040001,
+    };
+
+
+
+    PanelSizeX = psav->PanelX;
+    PanelSizeY = psav->PanelY;
+    ViewPortWidth = pScrn->currentMode->HDisplay;
+    ViewPortHeight = pScrn->currentMode->VDisplay;
+
+    if( PanelSizeX == 1408 )
+	PanelSizeX = 1400;
+
+    XExpansion = 0x00010001;
+    YExpansion = 0x00010001;
+
+    psav->displayXoffset = 0;
+    psav->displayYoffset = 0;
+
+    VGAOUT8(0x3C4, HZEXP_COMP_1);
+    Hstate = VGAIN8(0x3C5);
+    VGAOUT8(0x3C4, VTEXP_COMP_1);
+    Vstate = VGAIN8(0x3C5);
+    VGAOUT8(0x3C4, HZEXP_FACTOR_IGA1);
+    XFactor = VGAIN8(0x3C5);
+    VGAOUT8(0x3C4, VTEXP_FACTOR_IGA1);
+    YFactor = VGAIN8(0x3C5);
+
+    if( Hstate & EC1_EXPAND_ON )
+    {
+	XExpansion = Xfactors[XFactor>>4];
+    }
+
+    if( Vstate & EC1_EXPAND_ON )
+    {
+	YExpansion = Yfactors[YFactor>>4];
+    }
+
+    psav->XExp1 = XExpansion >> 16;
+    psav->XExp2 = XExpansion & 0xFFFF;
+
+    psav->YExp1 = YExpansion >> 16;
+    psav->YExp2 = YExpansion & 0xFFFF;
+
+    psav->displayXoffset = 
+       ((PanelSizeX - (psav->XExp1 * ViewPortWidth) / psav->XExp2) / 2 + 7) & 0xfff8;
+    psav->displayYoffset = 
+       ((PanelSizeY - (psav->YExp1 * ViewPortHeight) / psav->YExp2) / 2);
+
+}  /* InitStreamsForExpansionPM */
+
+void 
+SavageStreamsOn(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+     unsigned char jStreamsControl;
+     unsigned short vgaCRIndex = psav->vgaIOBase + 4;
+     unsigned short vgaCRReg = psav->vgaIOBase + 5;
+
+    xf86ErrorFVerb(STREAMS_TRACE, "SavageStreamsOn\n" );
+
+    /* Sequence stolen from streams.c in M7 NT driver */
+
+
+    xf86EnableIO();
+
+    /* Unlock extended registers. */
+
+    VGAOUT16(vgaCRIndex, 0x4838);
+    VGAOUT16(vgaCRIndex, 0xa039);
+    VGAOUT16(0x3c4, 0x0608);
+
+    VGAOUT8( vgaCRIndex, EXT_MISC_CTRL2 );
+
+    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
+#if 0 /* I don't think commenting this out is correct (EE) */
+	(psav->Chipset == S3_SUPERSAVAGE) ||
+#endif
+	(psav->Chipset == S3_SAVAGE2000) )
+    {
+	SavageInitStreamsNew( pScrn );
+
+	jStreamsControl = VGAIN8( vgaCRReg ) | ENABLE_STREAM1;
+
+	/* Wait for VBLANK. */
+	
+	VerticalRetraceWait(psav);
+
+	/* Fire up streams! */
+
+	VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
+
+	/* These values specify brightness, contrast, saturation and hue. */
+	OUTREG( SEC_STREAM_COLOR_CONVERT1, 0x0000C892 );
+	OUTREG( SEC_STREAM_COLOR_CONVERT2, 0x00039F9A );
+	OUTREG( SEC_STREAM_COLOR_CONVERT3, 0x01F1547E );
+    }
+    else
+    {
+	jStreamsControl = VGAIN8( vgaCRReg ) | ENABLE_STREAMS_OLD;
+
+	/* Wait for VBLANK. */
+	
+	VerticalRetraceWait(psav);
+
+	/* Fire up streams! */
+
+	VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
+
+	SavageInitStreamsOld( pScrn );
+    }
+
+    /* Wait for VBLANK. */
+    
+    VerticalRetraceWait(psav);
+
+    /* Turn on secondary stream TV flicker filter, once we support TV. */
+
+    /* SR70 |= 0x10 */
+
+}
+
+void
+SavageStreamsOff(ScrnInfoPtr pScrn)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+    unsigned char jStreamsControl;
+    unsigned short vgaCRIndex = psav->vgaIOBase + 4;
+    unsigned short vgaCRReg = psav->vgaIOBase + 5;
+
+    xf86ErrorFVerb(STREAMS_TRACE, "SavageStreamsOff\n" );
+    
+    xf86EnableIO();
+
+    /* Unlock extended registers. */
+
+    VGAOUT16(vgaCRIndex, 0x4838);
+    VGAOUT16(vgaCRIndex, 0xa039);
+    VGAOUT16(0x3c4, 0x0608);
+
+    VGAOUT8( vgaCRIndex, EXT_MISC_CTRL2 );
+    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
+        (psav->Chipset == S3_SUPERSAVAGE) ||
+        (psav->Chipset == S3_SAVAGE2000) )
+	jStreamsControl = VGAIN8( vgaCRReg ) & NO_STREAMS;
+    else
+	jStreamsControl = VGAIN8( vgaCRReg ) & NO_STREAMS_OLD;
+
+    /* Wait for VBLANK. */
+
+    VerticalRetraceWait(psav);
+
+    /* Kill streams. */
+
+    VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
+
+    VGAOUT16( vgaCRIndex, 0x0093 );
+    VGAOUT8( vgaCRIndex, 0x92 );
+    VGAOUT8( vgaCRReg, VGAIN8(vgaCRReg) & 0x40 );
+
+}
+
diff --git a/src/savage_streams.h b/src/savage_streams.h
new file mode 100644
index 0000000..9707765
--- /dev/null
+++ b/src/savage_streams.h
@@ -0,0 +1,177 @@
+#ifndef __SAVAGE_STREAMS_H__
+
+# define __SAVAGE_STREAMS_H__
+
+/**************************************
+   S3 streams processor
+**************************************/
+
+#define EXT_MISC_CTRL2              0x67
+
+/* New streams */
+
+/* CR67[2] = 1 : enable stream 1 */
+#define ENABLE_STREAM1              0x04
+/* CR67[1] = 1 : enable stream 2 */
+#define ENABLE_STREAM2              0x02
+/* mask to clear CR67[2,1] */
+#define NO_STREAMS                  0xF9
+/* CR67[3] = 1 : Mem-mapped regs */
+#define USE_MM_FOR_PRI_STREAM       0x08
+
+#define HDM_SHIFT	16
+#define HDSCALE_4	(2 << HDM_SHIFT)
+#define HDSCALE_8	(3 << HDM_SHIFT)
+#define HDSCALE_16	(4 << HDM_SHIFT)
+#define HDSCALE_32	(5 << HDM_SHIFT)
+#define HDSCALE_64	(6 << HDM_SHIFT)
+
+/* Old Streams */
+
+#define ENABLE_STREAMS_OLD	    0x0c
+#define NO_STREAMS_OLD		    0xf3
+/* CR69[0] = 1 : Mem-mapped regs */
+#define USE_MM_FOR_PRI_STREAM_OLD   0x01
+
+
+/*
+ * There are two different streams engines used in the Savage line.
+ * The old engine is in the 3D, 4, Pro, and Twister.
+ * The new engine is in the 2000, MX, IX, and Super.
+ */
+
+
+/* streams registers for old engine */
+#define PSTREAM_CONTROL_REG		0x8180
+#define COL_CHROMA_KEY_CONTROL_REG	0x8184
+#define SSTREAM_CONTROL_REG		0x8190
+#define CHROMA_KEY_UPPER_BOUND_REG	0x8194
+#define SSTREAM_STRETCH_REG		0x8198
+#define COLOR_ADJUSTMENT_REG		0x819C
+#define BLEND_CONTROL_REG		0x81A0
+#define PSTREAM_FBADDR0_REG		0x81C0
+#define PSTREAM_FBADDR1_REG		0x81C4
+#define PSTREAM_STRIDE_REG		0x81C8
+#define DOUBLE_BUFFER_REG		0x81CC
+#define SSTREAM_FBADDR0_REG		0x81D0
+#define SSTREAM_FBADDR1_REG		0x81D4
+#define SSTREAM_STRIDE_REG		0x81D8
+#define SSTREAM_VSCALE_REG		0x81E0
+#define SSTREAM_VINITIAL_REG		0x81E4
+#define SSTREAM_LINES_REG		0x81E8
+#define STREAMS_FIFO_REG		0x81EC
+#define PSTREAM_WINDOW_START_REG	0x81F0
+#define PSTREAM_WINDOW_SIZE_REG		0x81F4
+#define SSTREAM_WINDOW_START_REG	0x81F8
+#define SSTREAM_WINDOW_SIZE_REG		0x81FC
+#define FIFO_CONTROL			0x8200
+#define PSTREAM_FBSIZE_REG		0x8300
+#define SSTREAM_FBSIZE_REG		0x8304
+#define SSTREAM_FBADDR2_REG		0x8308
+
+#define OS_XY(x,y)	(((x+1)<<16)|(y+1))
+#define OS_WH(x,y)	(((x-1)<<16)|(y))
+
+/* New Streams Processor */
+/* Stream Processor 1 */
+
+/* Primary Stream 1 Frame Buffer Address 0 */
+#define PRI_STREAM_FBUF_ADDR0           0x81c0
+/* Primary Stream 1 Frame Buffer Address 0 */
+#define PRI_STREAM_FBUF_ADDR1           0x81c4
+/* Primary Stream 1 Stride */
+#define PRI_STREAM_STRIDE               0x81c8
+/* Primary Stream 1 Frame Buffer Size */
+#define PRI_STREAM_BUFFERSIZE           0x8214
+
+/* Secondary stream 1 Color/Chroma Key Control */
+#define SEC_STREAM_CKEY_LOW             0x8184
+/* Secondary stream 1 Chroma Key Upper Bound */
+#define SEC_STREAM_CKEY_UPPER           0x8194
+/* Blend Control of Secondary Stream 1 & 2 */
+#define BLEND_CONTROL                   0x8190
+/* Secondary Stream 1 Color conversion/Adjustment 1 */
+#define SEC_STREAM_COLOR_CONVERT1       0x8198
+/* Secondary Stream 1 Color conversion/Adjustment 2 */
+#define SEC_STREAM_COLOR_CONVERT2       0x819c
+/* Secondary Stream 1 Color conversion/Adjustment 3 */
+#define SEC_STREAM_COLOR_CONVERT3       0x81e4
+/* Secondary Stream 1 Horizontal Scaling */
+#define SEC_STREAM_HSCALING             0x81a0
+/* Secondary Stream 1 Frame Buffer Size */
+#define SEC_STREAM_BUFFERSIZE           0x81a8
+/* Secondary Stream 1 Horizontal Scaling Normalization (2K only) */
+#define SEC_STREAM_HSCALE_NORMALIZE	0x81ac
+/* Secondary Stream 1 Horizontal Scaling */
+#define SEC_STREAM_VSCALING             0x81e8
+/* Secondary Stream 1 Frame Buffer Address 0 */
+#define SEC_STREAM_FBUF_ADDR0           0x81d0
+/* Secondary Stream 1 Frame Buffer Address 1 */
+#define SEC_STREAM_FBUF_ADDR1           0x81d4
+/* Secondary Stream 1 Frame Buffer Address 2 */
+#define SEC_STREAM_FBUF_ADDR2           0x81ec
+/* Secondary Stream 1 Stride */
+#define SEC_STREAM_STRIDE               0x81d8
+/* Secondary Stream 1 Window Start Coordinates */
+#define SEC_STREAM_WINDOW_START         0x81f8
+/* Secondary Stream 1 Window Size */
+#define SEC_STREAM_WINDOW_SZ            0x81fc
+/* Secondary Streams Tile Offset */
+#define SEC_STREAM_TILE_OFF             0x821c
+/* Secondary Stream 1 Opaque Overlay Control */
+#define SEC_STREAM_OPAQUE_OVERLAY       0x81dc
+
+
+/* Stream Processor 2 */
+
+/* Primary Stream 2 Frame Buffer Address 0 */
+#define PRI_STREAM2_FBUF_ADDR0          0x81b0
+/* Primary Stream 2 Frame Buffer Address 1 */
+#define PRI_STREAM2_FBUF_ADDR1          0x81b4
+/* Primary Stream 2 Stride */
+#define PRI_STREAM2_STRIDE              0x81b8
+/* Primary Stream 2 Frame Buffer Size */
+#define PRI_STREAM2_BUFFERSIZE          0x8218
+
+/* Secondary Stream 2 Color/Chroma Key Control */
+#define SEC_STREAM2_CKEY_LOW            0x8188
+/* Secondary Stream 2 Chroma Key Upper Bound */
+#define SEC_STREAM2_CKEY_UPPER          0x818c
+/* Secondary Stream 2 Horizontal Scaling */
+#define SEC_STREAM2_HSCALING            0x81a4
+/* Secondary Stream 2 Horizontal Scaling */
+#define SEC_STREAM2_VSCALING            0x8204
+/* Secondary Stream 2 Frame Buffer Size */
+#define SEC_STREAM2_BUFFERSIZE          0x81ac
+/* Secondary Stream 2 Frame Buffer Address 0 */
+#define SEC_STREAM2_FBUF_ADDR0          0x81bc
+/* Secondary Stream 2 Frame Buffer Address 1 */
+#define SEC_STREAM2_FBUF_ADDR1          0x81e0
+/* Secondary Stream 2 Frame Buffer Address 2 */
+#define SEC_STREAM2_FBUF_ADDR2          0x8208
+/* Multiple Buffer/LPB and Secondary Stream 2 Stride */
+#define SEC_STREAM2_STRIDE_LPB          0x81cc
+/* Secondary Stream 2 Color conversion/Adjustment 1 */
+#define SEC_STREAM2_COLOR_CONVERT1      0x81f0
+/* Secondary Stream 2 Color conversion/Adjustment 2 */
+#define SEC_STREAM2_COLOR_CONVERT2      0x81f4
+/* Secondary Stream 2 Color conversion/Adjustment 3 */
+#define SEC_STREAM2_COLOR_CONVERT3      0x8200
+/* Secondary Stream 2 Window Start Coordinates */
+#define SEC_STREAM2_WINDOW_START        0x820c
+/* Secondary Stream 2 Window Size */
+#define SEC_STREAM2_WINDOW_SZ           0x8210
+/* Secondary Stream 2 Opaque Overlay Control */
+#define SEC_STREAM2_OPAQUE_OVERLAY      0x8180
+
+
+#define BASE_PAD 0xf
+
+#define  STREAMS_MODE32 0x7
+#define  STREAMS_MODE24 0x6
+#define  STREAMS_MODE16 0x5 /* @@@ */
+
+#define SSTREAMS_MODE(bpp) (bpp > 16 ? (bpp > 24 ? STREAMS_MODE32 :\
+				       STREAMS_MODE24) : STREAMS_MODE16)
+
+#endif /*__SAVAGE_STREAMS_H__*/
diff --git a/src/savage_vbe.c b/src/savage_vbe.c
index ea37260..25e64da 100644
--- a/src/savage_vbe.c
+++ b/src/savage_vbe.c
@@ -35,18 +35,18 @@ SavageSetTextMode( SavagePtr psav )
 {
     /* Restore display device if changed. */
     if( psav->iDevInfo != psav->iDevInfoPrim ) {
-	SavageClearVM86Regs( psav->pInt10 );
-	psav->pInt10->ax = 0x4f14;
-	psav->pInt10->bx = 0x0003;
-	psav->pInt10->cx = psav->iDevInfoPrim;
-	xf86ExecX86int10( psav->pInt10 );
+	SavageClearVM86Regs( psav->pVbe->pInt10 );
+	psav->pVbe->pInt10->ax = 0x4f14;
+	psav->pVbe->pInt10->bx = 0x0003;
+	psav->pVbe->pInt10->cx = psav->iDevInfoPrim;
+	xf86ExecX86int10( psav->pVbe->pInt10 );
     }
 
-    SavageClearVM86Regs( psav->pInt10 );
+    SavageClearVM86Regs( psav->pVbe->pInt10 );
 
-    psav->pInt10->ax = 0x83;
+    psav->pVbe->pInt10->ax = 0x83;
 
-    xf86ExecX86int10( psav->pInt10 );
+    xf86ExecX86int10( psav->pVbe->pInt10 );
 }
 
 
@@ -69,31 +69,31 @@ SavageSetVESAMode( SavagePtr psav, int n, int Refresh )
 
     /* Establish the refresh rate for this mode. */
 
-    SavageClearVM86Regs( psav->pInt10 );
-    psav->pInt10->ax = 0x4f14;	/* S3 extensions */
-    psav->pInt10->bx = 0x0001;	/* Set default refresh rate */
-    psav->pInt10->cx = n & 0x3fff;
-    psav->pInt10->di = Refresh & 0xffff;
+    SavageClearVM86Regs( psav->pVbe->pInt10 );
+    psav->pVbe->pInt10->ax = 0x4f14;	/* S3 extensions */
+    psav->pVbe->pInt10->bx = 0x0001;	/* Set default refresh rate */
+    psav->pVbe->pInt10->cx = n & 0x3fff;
+    psav->pVbe->pInt10->di = Refresh & 0xffff;
 
-    xf86ExecX86int10( psav->pInt10 );
+    xf86ExecX86int10( psav->pVbe->pInt10 );
 
     /* Set TV type if TV is on. */
     if( psav->TvOn ) {
-	SavageClearVM86Regs( psav->pInt10 );
-	psav->pInt10->ax = 0x4f14;	/* S3 extensions */
-	psav->pInt10->bx = 0x0007;	/* TV extensions */
-	psav->pInt10->cx = psav->PAL ? 0x08 : 0x04;
-	psav->pInt10->dx = 0x0c;
-	xf86ExecX86int10( psav->pInt10 );
+	SavageClearVM86Regs( psav->pVbe->pInt10 );
+	psav->pVbe->pInt10->ax = 0x4f14;	/* S3 extensions */
+	psav->pVbe->pInt10->bx = 0x0007;	/* TV extensions */
+	psav->pVbe->pInt10->cx = psav->PAL ? 0x08 : 0x04;
+	psav->pVbe->pInt10->dx = 0x0c;
+	xf86ExecX86int10( psav->pVbe->pInt10 );
     }
 
     /* Manipulate output device set. */
     if( psav->iDevInfo != iDevInfo ) {
-	SavageClearVM86Regs( psav->pInt10 );
-	psav->pInt10->ax = 0x4f14;	/* S3 extensions */
-	psav->pInt10->bx = 0x0003;	/* set active devices */
-	psav->pInt10->cx = psav->PAL ? 0x08 : 0x04;
-	xf86ExecX86int10( psav->pInt10 );
+	SavageClearVM86Regs( psav->pVbe->pInt10 );
+	psav->pVbe->pInt10->ax = 0x4f14;	/* S3 extensions */
+	psav->pVbe->pInt10->bx = 0x0003;	/* set active devices */
+	psav->pVbe->pInt10->cx = psav->PAL ? 0x08 : 0x04;
+	xf86ExecX86int10( psav->pVbe->pInt10 );
 
 	/* Re-fetch actual device set. */
 	psav->iDevInfo = SavageGetDevice( psav );
@@ -127,13 +127,13 @@ SavageSetVESAMode( SavagePtr psav, int n, int Refresh )
 
 static int SavageGetDevice( SavagePtr psav )
 {
-    SavageClearVM86Regs( psav->pInt10 );
-    psav->pInt10->ax = 0x4f14;	/* S3 extensions */
-    psav->pInt10->bx = 0x0103;	/* get active devices */
+    SavageClearVM86Regs( psav->pVbe->pInt10 );
+    psav->pVbe->pInt10->ax = 0x4f14;	/* S3 extensions */
+    psav->pVbe->pInt10->bx = 0x0103;	/* get active devices */
 
-    xf86ExecX86int10( psav->pInt10 );
+    xf86ExecX86int10( psav->pVbe->pInt10 );
 
-    return ((psav->pInt10->cx) & 0xf);
+    return ((psav->pVbe->pInt10->cx) & 0xf);
 }
 
 
@@ -184,15 +184,14 @@ SavageGetBIOSModes(
     unsigned short iModeCount = 0;
     unsigned short int *mode_list;
     pointer vbeLinear = NULL;
-    vbeControllerInfoPtr vbe = NULL;
+    VbeInfoBlock *vbe;
     int vbeReal;
     struct vbe_mode_info_block * vmib;
 
     if( !psav->pVbe )
 	return 0;
 
-    vbe = (vbeControllerInfoPtr) psav->pVbe->memory;
-    vbeLinear = xf86Int10AllocPages( psav->pInt10, 1, &vbeReal );
+    vbeLinear = xf86Int10AllocPages( psav->pVbe->pInt10, 1, &vbeReal );
     if( !vbeLinear )
     {
 	ErrorF( "Cannot allocate scratch page in real mode memory." );
@@ -200,12 +199,11 @@ SavageGetBIOSModes(
     }
     vmib = (struct vbe_mode_info_block *) vbeLinear;
     
-    for (
-	mode_list = xf86int10Addr( psav->pInt10, L_ADD(vbe->VideoModePtr) );
-	*mode_list != 0xffff;
-	mode_list++
-    )
-    {
+    if (!(vbe = VBEGetVBEInfo(psav->pVbe)))
+	return 0;
+
+    for (mode_list = vbe->VideoModePtr; *mode_list != 0xffff; mode_list++) {
+
 	/*
 	 * This is a HACK to work around what I believe is a BUG in the
 	 * Toshiba Satellite BIOSes in 08/2000 and 09/2000.  The BIOS
@@ -221,15 +219,15 @@ SavageGetBIOSModes(
 	if( *mode_list >= 0x0200 )
 	    continue;
 
-	SavageClearVM86Regs( psav->pInt10 );
+	SavageClearVM86Regs( psav->pVbe->pInt10 );
 
-	psav->pInt10->ax = 0x4f01;
-	psav->pInt10->cx = *mode_list;
-	psav->pInt10->es = SEG_ADDR(vbeReal);
-	psav->pInt10->di = SEG_OFF(vbeReal);
-	psav->pInt10->num = 0x10;
+	psav->pVbe->pInt10->ax = 0x4f01;
+	psav->pVbe->pInt10->cx = *mode_list;
+	psav->pVbe->pInt10->es = SEG_ADDR(vbeReal);
+	psav->pVbe->pInt10->di = SEG_OFF(vbeReal);
+	psav->pVbe->pInt10->num = 0x10;
 
-	xf86ExecX86int10( psav->pInt10 );
+	xf86ExecX86int10( psav->pVbe->pInt10 );
 
 	if( 
 	   (vmib->bits_per_pixel == iDepth) &&
@@ -256,8 +254,8 @@ SavageGetBIOSModes(
 		
 		/* Query the refresh rates at this mode. */
 
-		psav->pInt10->cx = *mode_list;
-		psav->pInt10->dx = 0;
+		psav->pVbe->pInt10->cx = *mode_list;
+		psav->pVbe->pInt10->dx = 0;
 
 		do
 		{
@@ -281,14 +279,14 @@ SavageGetBIOSModes(
 			}
 		    }
 
-		    psav->pInt10->ax = 0x4f14;	/* S3 extended functions */
-		    psav->pInt10->bx = 0x0201;	/* query refresh rates */
-		    psav->pInt10->num = 0x10;
-		    xf86ExecX86int10( psav->pInt10 );
+		    psav->pVbe->pInt10->ax = 0x4f14;	/* S3 extended functions */
+		    psav->pVbe->pInt10->bx = 0x0201;	/* query refresh rates */
+		    psav->pVbe->pInt10->num = 0x10;
+		    xf86ExecX86int10( psav->pVbe->pInt10 );
 
-		    s3vModeTable->RefreshRate[iRefresh++] = psav->pInt10->di;
+		    s3vModeTable->RefreshRate[iRefresh++] = psav->pVbe->pInt10->di;
 		}
-		while( psav->pInt10->dx );
+		while( psav->pVbe->pInt10->dx );
 
 		s3vModeTable->RefreshCount = iRefresh;
 
@@ -297,7 +295,9 @@ SavageGetBIOSModes(
 	}
     }
 
-    xf86Int10FreePages( psav->pInt10, vbeLinear, 1 );
+    VBEFreeVBEInfo(vbe);
+
+    xf86Int10FreePages( psav->pVbe->pInt10, vbeLinear, 1 );
 
     return iModeCount;
 }
diff --git a/src/savage_video.c b/src/savage_video.c
index 4e9b5f3..56c9a8f 100644
--- a/src/savage_video.c
+++ b/src/savage_video.c
@@ -7,6 +7,7 @@
 #include "xaalocal.h"
 
 #include "savage_driver.h"
+#include "savage_streams.h"
 
 #define OFF_DELAY 	200  /* milliseconds */
 #define FREE_DELAY 	60000
@@ -17,7 +18,7 @@
 
 #define TIMER_MASK      (OFF_TIMER | FREE_TIMER)
 
-void myOUTREG( SavagePtr psav, unsigned long offset, unsigned long value );
+void savageOUTREG( SavagePtr psav, unsigned long offset, unsigned long value );
 
 static XF86VideoAdaptorPtr SavageSetupImageVideo(ScreenPtr);
 static void SavageInitOffscreenImages(ScreenPtr);
@@ -32,14 +33,8 @@ static int SavagePutImage( ScrnInfoPtr,
 static int SavageQueryImageAttributes(ScrnInfoPtr, 
 	int, unsigned short *, unsigned short *,  int *, int *);
 
-void SavageStreamsOn(ScrnInfoPtr pScrn, int id);
-void SavageStreamsOff(ScrnInfoPtr pScrn);
 void SavageResetVideo(ScrnInfoPtr pScrn); 
 
-static void SavageInitStreamsOld(ScrnInfoPtr pScrn);
-static void SavageInitStreamsNew(ScrnInfoPtr pScrn);
-static void (*SavageInitStreams)(ScrnInfoPtr pScrn) = NULL;
-
 static void SavageSetColorKeyOld(ScrnInfoPtr pScrn);
 static void SavageSetColorKeyNew(ScrnInfoPtr pScrn);
 static void (*SavageSetColorKey)(ScrnInfoPtr pScrn) = NULL;
@@ -73,9 +68,6 @@ static void (*SavageDisplayVideo)(
     short drw_w, short drw_h
 ) = NULL;
 
-static void OverlayParamInit(ScrnInfoPtr pScrn);
-static void InitStreamsForExpansion(ScrnInfoPtr pScrn);
-
 /*static void SavageBlockHandler(int, pointer, pointer, pointer);*/
 
 #define XVTRACE	4
@@ -207,76 +199,6 @@ typedef struct {
 #define GET_PORT_PRIVATE(pScrn) \
    (SavagePortPrivPtr)((SAVPTR(pScrn))->adaptor->pPortPrivates[0].ptr)
 
-/**************************************
-   S3 streams processor
-**************************************/
-
-#define EXT_MISC_CTRL2              0x67
-
-/* New streams */
-
-/* CR67[2] = 1 : enable stream 1 */
-#define ENABLE_STREAM1              0x04
-/* CR67[1] = 1 : enable stream 2 */
-#define ENABLE_STREAM2              0x02
-/* mask to clear CR67[2,1] */
-#define NO_STREAMS                  0xF9
-/* CR67[3] = 1 : Mem-mapped regs */
-#define USE_MM_FOR_PRI_STREAM       0x08
-
-#define HDM_SHIFT	16
-#define HDSCALE_4	(2 << HDM_SHIFT)
-#define HDSCALE_8	(3 << HDM_SHIFT)
-#define HDSCALE_16	(4 << HDM_SHIFT)
-#define HDSCALE_32	(5 << HDM_SHIFT)
-#define HDSCALE_64	(6 << HDM_SHIFT)
-
-/* Old Streams */
-
-#define ENABLE_STREAMS_OLD	    0x0c
-#define NO_STREAMS_OLD		    0xf3
-/* CR69[0] = 1 : Mem-mapped regs */
-#define USE_MM_FOR_PRI_STREAM_OLD   0x01
-
-
-/*
- * There are two different streams engines used in the Savage line.
- * The old engine is in the 3D, 4, Pro, and Twister.
- * The new engine is in the 2000, MX, IX, and Super.
- */
-
-
-/* streams registers for old engine */
-#define PSTREAM_CONTROL_REG		0x8180
-#define COL_CHROMA_KEY_CONTROL_REG	0x8184
-#define SSTREAM_CONTROL_REG		0x8190
-#define CHROMA_KEY_UPPER_BOUND_REG	0x8194
-#define SSTREAM_STRETCH_REG		0x8198
-#define COLOR_ADJUSTMENT_REG		0x819C
-#define BLEND_CONTROL_REG		0x81A0
-#define PSTREAM_FBADDR0_REG		0x81C0
-#define PSTREAM_FBADDR1_REG		0x81C4
-#define PSTREAM_STRIDE_REG		0x81C8
-#define DOUBLE_BUFFER_REG		0x81CC
-#define SSTREAM_FBADDR0_REG		0x81D0
-#define SSTREAM_FBADDR1_REG		0x81D4
-#define SSTREAM_STRIDE_REG		0x81D8
-#define SSTREAM_VSCALE_REG		0x81E0
-#define SSTREAM_VINITIAL_REG		0x81E4
-#define SSTREAM_LINES_REG		0x81E8
-#define STREAMS_FIFO_REG		0x81EC
-#define PSTREAM_WINDOW_START_REG	0x81F0
-#define PSTREAM_WINDOW_SIZE_REG		0x81F4
-#define SSTREAM_WINDOW_START_REG	0x81F8
-#define SSTREAM_WINDOW_SIZE_REG		0x81FC
-#define FIFO_CONTROL			0x8200
-#define PSTREAM_FBSIZE_REG		0x8300
-#define SSTREAM_FBSIZE_REG		0x8304
-#define SSTREAM_FBADDR2_REG		0x8308
-
-#define OS_XY(x,y)	(((x+1)<<16)|(y+1))
-#define OS_WH(x,y)	(((x-1)<<16)|(y))
-
 static
 unsigned int GetBlendForFourCC( int id )
 {
@@ -296,238 +218,31 @@ unsigned int GetBlendForFourCC( int id )
     }
 }
 
-void myOUTREG( SavagePtr psav, unsigned long offset, unsigned long value )
+void savageOUTREG( SavagePtr psav, unsigned long offset, unsigned long value )
 {
-    ErrorF( "MMIO %04lx, was %08lx, want %08lx,", 
-	offset, (unsigned long)MMIO_IN32( psav->MapBase, offset ), value );
+    ErrorF( "MMIO %08lx, was %08lx, want %08lx,", 
+	offset, (CARD32)MMIO_IN32( psav->MapBase, offset ), value );
     MMIO_OUT32( psav->MapBase, offset, value );
-    ErrorF( " now %08lx\n", (unsigned long)MMIO_IN32( psav->MapBase, offset ) );
+    ErrorF( " now %08lx\n", (CARD32)MMIO_IN32( psav->MapBase, offset ) );
 }
 
-void SavageInitStreamsOld(ScrnInfoPtr pScrn)
-{
-    SavagePtr psav = SAVPTR(pScrn);
-    unsigned long jDelta;
-    unsigned long format = 0;
-
-    /*
-     * For the OLD streams engine, several of these registers
-     * cannot be touched unless streams are on.  Seems backwards to me;
-     * I'd want to set 'em up, then cut 'em loose.
-     */
-
-    xf86ErrorFVerb(XVTRACE, "SavageInitStreams\n" );
 
-    /* Primary stream reflects the frame buffer. */
-
-    switch( pScrn->depth ) {
-    case  8: format = 0 << 24; break;
-    case 15: format = 3 << 24; break;
-    case 16: format = 5 << 24; break;
-    case 24: format = 7 << 24; break;
-    }
-
-    jDelta = pScrn->displayWidth * pScrn->bitsPerPixel / 8;
-    OUTREG( PSTREAM_WINDOW_START_REG, OS_XY(0,0) );
-    OUTREG( PSTREAM_WINDOW_SIZE_REG, OS_WH(pScrn->displayWidth, pScrn->virtualY) );
-    OUTREG( PSTREAM_FBADDR0_REG, pScrn->fbOffset );
-    OUTREG( PSTREAM_FBADDR1_REG, 0 );
-    OUTREG( PSTREAM_STRIDE_REG, jDelta );
-    OUTREG( PSTREAM_CONTROL_REG, format );
-    OUTREG( PSTREAM_FBSIZE_REG, jDelta * pScrn->virtualY >> 3 );
-
-    OUTREG( COL_CHROMA_KEY_CONTROL_REG, 0 );
-    OUTREG( SSTREAM_CONTROL_REG, 0 );
-    OUTREG( CHROMA_KEY_UPPER_BOUND_REG, 0 );
-    OUTREG( SSTREAM_STRETCH_REG, 0 );
-    OUTREG( COLOR_ADJUSTMENT_REG, 0 );
-    OUTREG( BLEND_CONTROL_REG, 1 << 24 );
-    OUTREG( DOUBLE_BUFFER_REG, 0 );
-    OUTREG( SSTREAM_FBADDR0_REG, 0 );
-    OUTREG( SSTREAM_FBADDR1_REG, 0 );
-    OUTREG( SSTREAM_FBADDR2_REG, 0 );
-/*    OUTREG( SSTREAM_FBSIZE_REG, 0 ); */
-    OUTREG( SSTREAM_STRIDE_REG, 0 );
-    OUTREG( SSTREAM_VSCALE_REG, 0 );
-    OUTREG( SSTREAM_LINES_REG, 0 );
-    OUTREG( SSTREAM_VINITIAL_REG, 0 );
-    OUTREG( SSTREAM_WINDOW_START_REG, OS_XY(0xfffe, 0xfffe) );
-    OUTREG( SSTREAM_WINDOW_SIZE_REG, OS_WH(10,2) );
-}
-
-#undef OUTREG
-#if 0
-#define OUTREG(a,v)	myOUTREG(psav,a,v)
-#else
-#define OUTREG(addr,val) MMIO_OUT32(psav->MapBase, addr, val)
-#endif
-
-void SavageInitStreamsNew(ScrnInfoPtr pScrn)
-{
-    SavagePtr psav = SAVPTR(pScrn);
-    unsigned long jDelta;
-
-    xf86ErrorFVerb(XVTRACE, "SavageInitStreams\n" );
-
-    if( 
-	S3_SAVAGE_MOBILE_SERIES(psav->Chipset) && 
-	!psav->CrtOnly && 
-	!psav->TvOn 
-    ) {
-	OverlayParamInit( pScrn );
-    }
-
-    /* Primary stream reflects the frame buffer. */
-
-    jDelta = pScrn->displayWidth * pScrn->bitsPerPixel / 8;
-    OUTREG( PRI_STREAM_BUFFERSIZE, jDelta * pScrn->virtualY >> 3 );
-    OUTREG( PRI_STREAM_FBUF_ADDR0, pScrn->fbOffset );
-    OUTREG( PRI_STREAM_STRIDE, jDelta );
-
-    OUTREG( SEC_STREAM_CKEY_LOW, 0 );
-    OUTREG( SEC_STREAM_CKEY_UPPER, 0 );
-    OUTREG( SEC_STREAM_HSCALING, 0 );
-    OUTREG( SEC_STREAM_VSCALING, 0 );
-    OUTREG( BLEND_CONTROL, 0 );
-    OUTREG( SEC_STREAM_FBUF_ADDR0, 0 );
-    OUTREG( SEC_STREAM_FBUF_ADDR1, 0 );
-    OUTREG( SEC_STREAM_FBUF_ADDR2, 0 );
-    OUTREG( SEC_STREAM_WINDOW_START, 0 );
-    OUTREG( SEC_STREAM_WINDOW_SZ, 0 );
-/*    OUTREG( SEC_STREAM_BUFFERSIZE, 0 ); */
-    OUTREG( SEC_STREAM_TILE_OFF, 0 );
-    OUTREG( SEC_STREAM_OPAQUE_OVERLAY, 0 );
-    OUTREG( SEC_STREAM_STRIDE, 0 );
-
-    /* These values specify brightness, contrast, saturation and hue. */
-    OUTREG( SEC_STREAM_COLOR_CONVERT1, 0x0000C892 );
-    OUTREG( SEC_STREAM_COLOR_CONVERT2, 0x00039F9A );
-    OUTREG( SEC_STREAM_COLOR_CONVERT3, 0x01F1547E );
-}
-
-void SavageStreamsOn(ScrnInfoPtr pScrn, int id)
+static void
+SavageClipVWindow(ScrnInfoPtr pScrn)
 {
     SavagePtr psav = SAVPTR(pScrn);
-    unsigned char jStreamsControl;
-    unsigned short vgaCRIndex = psav->vgaIOBase + 4;
-    unsigned short vgaCRReg = psav->vgaIOBase + 5;
-
-    xf86ErrorFVerb(XVTRACE, "SavageStreamsOn\n" );
-
-    /* Sequence stolen from streams.c in M7 NT driver */
-
-    xf86EnableIO();
-
-    /* Unlock extended registers. */
-
-    VGAOUT16(vgaCRIndex, 0x4838);
-    VGAOUT16(vgaCRIndex, 0xa039);
-    VGAOUT16(0x3c4, 0x0608);
-
-    if( 
-	S3_SAVAGE_MOBILE_SERIES(psav->Chipset) && 
-	!psav->CrtOnly && 
-	!psav->TvOn 
-    ) {
-	OverlayParamInit( pScrn );
-    }
-
-    VGAOUT8( vgaCRIndex, EXT_MISC_CTRL2 );
-
-    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
-#if 0 /* I don't think commenting this out is correct (EE) */
+  
+    if( (psav->Chipset == S3_SAVAGE_MX)  ||
 	(psav->Chipset == S3_SUPERSAVAGE) ||
-#endif
-        (psav->Chipset == S3_SAVAGE2000) )
-    {
-	jStreamsControl = VGAIN8( vgaCRReg ) | ENABLE_STREAM1;
-
-	/* Wait for VBLANK. */
-	
-	VerticalRetraceWait(psav);
-
-	/* Fire up streams! */
-
-	VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
-
-	psav->blendBase = GetBlendForFourCC( id ) << 9;
-	xf86ErrorFVerb(XVTRACE+1,"Format %4.4s, blend is %08x\n", (char *)&id, psav->blendBase );
-	OUTREG( BLEND_CONTROL, psav->blendBase | 0x08 );
-
-	/* These values specify brightness, contrast, saturation and hue. */
-	OUTREG( SEC_STREAM_COLOR_CONVERT1, 0x0000C892 );
-	OUTREG( SEC_STREAM_COLOR_CONVERT2, 0x00039F9A );
-	OUTREG( SEC_STREAM_COLOR_CONVERT3, 0x01F1547E );
-    }
-    else
-    {
-	jStreamsControl = VGAIN8( vgaCRReg ) | ENABLE_STREAMS_OLD;
-
-	/* Wait for VBLANK. */
-	
-	VerticalRetraceWait(psav);
-
-	/* Fire up streams! */
-
-	VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
-
-	SavageInitStreamsOld( pScrn );
+        (psav->Chipset == S3_SAVAGE2000) ) {
+	OUTREG(SEC_STREAM_WINDOW_SZ, 0);
+  
+    } else {
+	OUTREG( SSTREAM_WINDOW_SIZE_REG, 1);
+	OUTREG( SSTREAM_WINDOW_START_REG, 0x03ff03ff);
     }
-
-    /* Wait for VBLANK. */
-    
-    VerticalRetraceWait(psav);
-
-    /* Turn on secondary stream TV flicker filter, once we support TV. */
-
-    /* SR70 |= 0x10 */
-
-    psav->videoFlags |= VF_STREAMS_ON;
-    psav->videoFourCC = id;
-}
-
-
-void SavageStreamsOff(ScrnInfoPtr pScrn)
-{
-    SavagePtr psav = SAVPTR(pScrn);
-    unsigned char jStreamsControl;
-    unsigned short vgaCRIndex = psav->vgaIOBase + 4;
-    unsigned short vgaCRReg = psav->vgaIOBase + 5;
-
-    xf86ErrorFVerb(XVTRACE, "SavageStreamsOff\n" );
-
-    xf86EnableIO();
-
-    /* Unlock extended registers. */
-
-    VGAOUT16(vgaCRIndex, 0x4838);
-    VGAOUT16(vgaCRIndex, 0xa039);
-    VGAOUT16(0x3c4, 0x0608);
-
-    VGAOUT8( vgaCRIndex, EXT_MISC_CTRL2 );
-    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset)  ||
-        (psav->Chipset == S3_SUPERSAVAGE) ||
-        (psav->Chipset == S3_SAVAGE2000) )
-	jStreamsControl = VGAIN8( vgaCRReg ) & NO_STREAMS;
-    else
-	jStreamsControl = VGAIN8( vgaCRReg ) & NO_STREAMS_OLD;
-
-    /* Wait for VBLANK. */
-
-    VerticalRetraceWait(psav);
-
-    /* Kill streams. */
-
-    VGAOUT16( vgaCRIndex, (jStreamsControl << 8) | EXT_MISC_CTRL2 );
-
-    VGAOUT16( vgaCRIndex, 0x0093 );
-    VGAOUT8( vgaCRIndex, 0x92 );
-    VGAOUT8( vgaCRReg, VGAIN8(vgaCRReg) & 0x40 );
-
-    psav->videoFlags &= ~VF_STREAMS_ON;
 }
 
-
 void SavageInitVideo(ScreenPtr pScreen)
 {
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
@@ -546,7 +261,6 @@ void SavageInitVideo(ScreenPtr pScreen)
 	newAdaptor = SavageSetupImageVideo(pScreen);
 	SavageInitOffscreenImages(pScreen);
 
-	SavageInitStreams = SavageInitStreamsNew;
 	SavageSetColor = SavageSetColorNew;
 	SavageSetColorKey = SavageSetColorKeyNew;
 	SavageDisplayVideo = SavageDisplayVideoNew;
@@ -557,7 +271,6 @@ void SavageInitVideo(ScreenPtr pScreen)
 	SavageInitOffscreenImages(pScreen);
     /*DELETENEXTLINE*/
 	/* Since newAdaptor is still NULL, these are still disabled for now. */
-	SavageInitStreams = SavageInitStreamsOld;
 	SavageSetColor = SavageSetColorOld;
 	SavageSetColorKey = SavageSetColorKeyOld;
 	SavageDisplayVideo = SavageDisplayVideoOld;
@@ -590,9 +303,6 @@ void SavageInitVideo(ScreenPtr pScreen)
 
     if( newAdaptor )
     {
-	if( SavageInitStreams == SavageInitStreamsNew )
-	    SavageInitStreams(pScrn);
-	psav->videoFlags = 0;
 	psav->videoFourCC = 0;
     }
 }
@@ -967,7 +677,8 @@ SavageStopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
     REGION_EMPTY(pScrn->pScreen, &pPriv->clip);   
 
     if(shutdown) {
-	SavageStreamsOff( pScrn );
+	SavageClipVWindow(pScrn);
+/* 	SavageStreamsOff( pScrn ); */
 	if(pPriv->area) {
 	    xf86FreeOffscreenArea(pPriv->area);
 	    pPriv->area = NULL;
@@ -1178,6 +889,22 @@ SavageAllocateMemory(
 }
 
 static void
+SavageSetBlend(ScrnInfoPtr pScrn, int id)
+{
+    SavagePtr psav = SAVPTR(pScrn);
+
+    if( S3_SAVAGE_MOBILE_SERIES(psav->Chipset) ||
+        (psav->Chipset == S3_SUPERSAVAGE) ||
+        (psav->Chipset == S3_SAVAGE2000) )
+    {
+	psav->blendBase = GetBlendForFourCC( id ) << 9;
+	xf86ErrorFVerb(XVTRACE+1,"Format %4.4s, blend is %08x\n", (char*)&id, psav->blendBase );
+	OUTREG( BLEND_CONTROL, psav->blendBase | 0x08 );
+    }
+    psav->videoFourCC = id;
+}
+
+static void
 SavageDisplayVideoOld(
     ScrnInfoPtr pScrn,
     int id,
@@ -1194,26 +921,22 @@ SavageDisplayVideoOld(
     SavagePortPrivPtr pPriv = psav->adaptor->pPortPrivates[0].ptr;
     /*DisplayModePtr mode = pScrn->currentMode;*/
     int vgaCRIndex, vgaCRReg, vgaIOBase;
-    unsigned int ssControl;
+    CARD32 ssControl;
 
 
     vgaIOBase = hwp->IOBase;
     vgaCRIndex = vgaIOBase + 4;
     vgaCRReg = vgaIOBase + 5;
 
-    if( psav->videoFourCC != id )
-	SavageStreamsOff(pScrn);
-
-    if( !psav->videoFlags & VF_STREAMS_ON )
-    {
-	SavageStreamsOn(pScrn, id);
+    if ( psav->videoFourCC != id ) {
+	SavageSetBlend(pScrn,id);
 	SavageResetVideo(pScrn);
     }
 
     /* Set surface format. */
-
-    OUTREG(SSTREAM_CONTROL_REG, 
-	(GetBlendForFourCC(psav->videoFourCC) << 24) + src_w );
+    ssControl = (GetBlendForFourCC(psav->videoFourCC) << 24) | src_w;
+    
+    OUTREG(SSTREAM_CONTROL_REG, ssControl);
 
     /* Calculate horizontal scale factor. */
 
@@ -1227,15 +950,12 @@ SavageDisplayVideoOld(
 
     /* Set surface location and stride. */
 
-    OUTREG(SSTREAM_FBADDR0_REG, (offset + (x1>>15)) & 0x3ffff0 );
-    OUTREG(SSTREAM_FBADDR1_REG, 0 );
-    
+    OUTREG(SSTREAM_FBADDR0_REG, (offset + (x1>>15)) & (0x1ffffff & ~BASE_PAD) );
     OUTREG(SSTREAM_STRIDE_REG, pitch & 0xfff );
 
     OUTREG(SSTREAM_WINDOW_START_REG, OS_XY(dstBox->x1, dstBox->y1) );
-    OUTREG(SSTREAM_WINDOW_SIZE_REG, OS_WH(drw_w, drw_h) );
-
-    ssControl = 0;
+    OUTREG(SSTREAM_WINDOW_SIZE_REG, OS_WH(dstBox->x2-dstBox->x1,
+					  dstBox->y2-dstBox->y1));
 
     if( src_w > (drw_w << 1) )
     {
@@ -1276,7 +996,7 @@ SavageDisplayVideoOld(
 	VGAOUT8(vgaCRIndex, 0x93);
 	VGAOUT8(vgaCRReg, pitch);
     }
-
+    OUTREG(STREAMS_FIFO_REG, 0x2 | 25 << 5 | 32 << 11);
 }
 
 static void
@@ -1302,12 +1022,8 @@ SavageDisplayVideoNew(
     vgaCRIndex = vgaIOBase + 4;
     vgaCRReg = vgaIOBase + 5;
 
-    if( psav->videoFourCC != id )
-	SavageStreamsOff(pScrn);
-
-    if( !psav->videoFlags & VF_STREAMS_ON )
-    {
-	SavageStreamsOn(pScrn, id);
+    if ( psav->videoFourCC != id ) {
+	SavageSetBlend(pScrn,id);
 	SavageResetVideo(pScrn);
     }
 
@@ -1352,10 +1068,12 @@ SavageDisplayVideoNew(
      * are 2 bytes/pixel.
      */
 
-    OUTREG(SEC_STREAM_FBUF_ADDR0, (offset + (x1>>15)) & 0x7ffff0 );
+    OUTREG(SEC_STREAM_FBUF_ADDR0, (offset + (x1>>15)) 
+	   & (0x7ffffff & ~BASE_PAD));
     OUTREG(SEC_STREAM_STRIDE, pitch & 0xfff );
     OUTREG(SEC_STREAM_WINDOW_START, ((dstBox->x1+1) << 16) | (dstBox->y1+1) );
-    OUTREG(SEC_STREAM_WINDOW_SZ, ((drw_w) << 16) | drw_h );
+    OUTREG(SEC_STREAM_WINDOW_SZ, ((dstBox->x2-dstBox->x1) << 16) 
+	   | (dstBox->x2-dstBox->x1) );
 
 #if 0
     /* Set color key on primary. */
@@ -1402,20 +1120,6 @@ SavagePutImage(
     BoxRec dstBox;
     CARD32 tmp;
 /*    xf86ErrorFVerb(XVTRACE,"SavagePutImage\n"); */
-
-    if( psav->cxScreen != pScrn->currentMode->HDisplay )
-    {
-	/* The mode has changed.  Recompute the offsets. */
-
-	if( 
-	    S3_SAVAGE_MOBILE_SERIES(psav->Chipset) && 
-	    !psav->CrtOnly && 
-	    !psav->TvOn 
-	) {
-	    OverlayParamInit( pScrn );
-	}
-    }
-
     if(drw_w > 16384) drw_w = 16384;
 
     /* Clip */
@@ -1483,8 +1187,8 @@ SavagePutImage(
     npixels = ((((x2 + 0xffff) >> 16) + 1) & ~1) - left;
     left <<= 1;
 
-    offset = (pPriv->area->box.y1 * pitch) + (top * dstPitch);
-    dst_start = psav->FBBase + offset + left;
+    offset = ((pPriv->area->box.y1 * pitch)) + (top * dstPitch);
+    dst_start = (psav->FBBase + ((offset + left) & ~BASE_PAD));
 
     switch(id) {
     case FOURCC_YV12:		/* YV12 */
@@ -1577,50 +1281,6 @@ SavageQueryImageAttributes(
     return size;
 }
 
-#if 0
-
-static void
-CHIPSBlockHandler (
-    int i,
-    pointer     blockData,
-    pointer     pTimeout,
-    pointer     pReadmask
-){
-    ScreenPtr   pScreen = screenInfo.screens[i];
-    ScrnInfoPtr pScrn = xf86Screens[i];
-    CHIPSPtr    cPtr = CHIPSPTR(pScrn);
-    CHIPSPortPrivPtr pPriv = GET_PORT_PRIVATE(pScrn);
-    unsigned char mr3c;
-    
-    pScreen->BlockHandler = cPtr->BlockHandler;
-    
-    (*pScreen->BlockHandler) (i, blockData, pTimeout, pReadmask);
-
-    pScreen->BlockHandler = CHIPSBlockHandler;
-
-    CHIPSHiQVSync(pScrn);
-    if(pPriv->videoStatus & TIMER_MASK) {
-	UpdateCurrentTime();
-	if(pPriv->videoStatus & OFF_TIMER) {
-	    if(pPriv->offTime < currentTime.milliseconds) {
-		mr3c = cPtr->readMR(cPtr, 0x3C);
-		cPtr->writeMR(cPtr, 0x3C, (mr3c & 0xFE));
-		pPriv->videoStatus = FREE_TIMER;
-		pPriv->freeTime = currentTime.milliseconds + FREE_DELAY;
-	    }
-	} else {  /* FREE_TIMER */
-	    if(pPriv->freeTime < currentTime.milliseconds) {
-		if(pPriv->area) {
-		   xf86FreeOffscreenArea(pPriv->area);
-		   pPriv->area = NULL;
-		}
-		pPriv->videoStatus = 0;
-	    }
-        }
-    }
-}
-
-#endif
 
 /****************** Offscreen stuff ***************/
 
@@ -1688,7 +1348,7 @@ SavageStopSurface(
 
     if(pPriv->isOn) {
 	/*SavagePtr psav = SAVPTR(surface->pScrn);*/
-	SavageStreamsOff( surface->pScrn );
+	SavageClipVWindow(surface->pScrn);
 	pPriv->isOn = FALSE;
     }
 
@@ -1823,96 +1483,3 @@ SavageInitOffscreenImages(ScreenPtr pScreen)
     
     xf86XVRegisterOffscreenImages(pScreen, offscreenImages, 1);
 }
-
-/* Function to get lcd factor, display offset for overlay use
- * Input: pScrn; Output: x,yfactor, displayoffset in pScrn
- */
-static void OverlayParamInit(ScrnInfoPtr pScrn)
-{
-    SavagePtr psav = SAVPTR(pScrn);
-
-    psav = SAVPTR(pScrn);
-    psav->cxScreen = pScrn->currentMode->HDisplay;
-    InitStreamsForExpansion(pScrn);
-}
-
-/* Function to calculate lcd expansion x,y factor and offset for overlay
- */
-static void InitStreamsForExpansion(ScrnInfoPtr pScrn)
-{
-    SavagePtr psav = SAVPTR(pScrn);
-    int		PanelSizeX,PanelSizeY;
-    int		ViewPortWidth,ViewPortHeight;
-    int		XExpansion, YExpansion;
-    int		XFactor, YFactor;
-    int		Hstate, Vstate;
-
-    static CARD32 Xfactors[] = {
-	0x00010001,
-	0x00010001, /* 1 */
-	0,
-	0x00090008, /* 3 */
-	0x00050004, /* 4 */
-	0,
-	0x00030002, /* 6 */
-	0x00020001  /* 7 */
-    };
-
-    static CARD32 Yfactors[] = {
-	0x00010001,	0x00010001,
-	0,		0x00060005,
-	0x00050004,	0x00040003,
-	0,		0x00030002,
-	0x00020001,	0x00050002,
-	0x000C0005,	0x00080003,
-	0x00090004,	0,
-	0x00030001,	0x00040001,
-    };
-
-
-
-    PanelSizeX = psav->PanelX;
-    PanelSizeY = psav->PanelY;
-    ViewPortWidth = pScrn->currentMode->HDisplay;
-    ViewPortHeight = pScrn->currentMode->VDisplay;
-
-    if( PanelSizeX == 1408 )
-	PanelSizeX = 1400;
-
-    XExpansion = 0x00010001;
-    YExpansion = 0x00010001;
-
-    psav->displayXoffset = 0;
-    psav->displayYoffset = 0;
-
-    VGAOUT8(0x3C4, HZEXP_COMP_1);
-    Hstate = VGAIN8(0x3C5);
-    VGAOUT8(0x3C4, VTEXP_COMP_1);
-    Vstate = VGAIN8(0x3C5);
-    VGAOUT8(0x3C4, HZEXP_FACTOR_IGA1);
-    XFactor = VGAIN8(0x3C5);
-    VGAOUT8(0x3C4, VTEXP_FACTOR_IGA1);
-    YFactor = VGAIN8(0x3C5);
-
-    if( Hstate & EC1_EXPAND_ON )
-    {
-	XExpansion = Xfactors[XFactor>>4];
-    }
-
-    if( Vstate & EC1_EXPAND_ON )
-    {
-	YExpansion = Yfactors[YFactor>>4];
-    }
-
-    psav->XExp1 = XExpansion >> 16;
-    psav->XExp2 = XExpansion & 0xFFFF;
-
-    psav->YExp1 = YExpansion >> 16;
-    psav->YExp2 = YExpansion & 0xFFFF;
-
-    psav->displayXoffset = 
-       ((PanelSizeX - (psav->XExp1 * ViewPortWidth) / psav->XExp2) / 2 + 7) & 0xfff8;
-    psav->displayYoffset = 
-       ((PanelSizeY - (psav->YExp1 * ViewPortHeight) / psav->YExp2) / 2);
-
-}  /* InitStreamsForExpansionPM */