Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/driver/xf86-video-mga into pci-rework

14 files changed, 1334 insertions, 215 deletions

diff --git a/.gitignore b/.gitignore
index f421710..564d950 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+ChangeLog
 Makefile
 Makefile.in
 *.la
diff --git a/ChangeLog b/ChangeLog
deleted file mode 100644
index f9abbb1..0000000
--- a/ChangeLog
+++ /dev/null
@@ -1,117 +0,0 @@
-2006-04-12  Adam Jackson  <ajax@freedesktop.org>
-
-	* src/mga_arc.c:
-	Bug #6562: s/MAXSHORT/SHRT_MAX/ for POSIX.  (Matthieu Herrb)
-
-2006-04-07  Adam Jackson  <ajax@freedesktop.org>
-
-	* configure.ac:
-	* src/mga.h:
-	Bump to 1.4.1 for Xv changes.
-
-2006-04-07  Aaron Plattner  <aplattner@nvidia.com>
-
-	* src/mga_video.c: (MGAPutImage):
-	Add a DrawablePtr argument to the XV functions to pave the way for
-	redirected video.
-
-2006-04-07  Adam Jackson  <ajax@freedesktop.org>
-
-	* configure.ac:
-	* src/clientlx.c:
-	* src/mga.h:
-	* src/mga_arc.c:
-	* src/mga_bios.c:
-	* src/mga_dac3026.c:
-	* src/mga_dacG.c:
-	* src/mga_dga.c:
-	* src/mga_dh.c:
-	* src/mga_dri.c:
-	* src/mga_driver.c:
-	* src/mga_esc.c:
-	* src/mga_g450pll.c:
-	* src/mga_hwcurs.c:
-	* src/mga_merge.c:
-	* src/mga_shadow.c:
-	* src/mga_storm.c:
-	* src/mga_video.c:
-	Unlibcwrap.  Bump server version requirement.  Bump to 1.4.0.
-
-2006-04-01  Adam Jackson  <ajax@freedesktop.org>
-
-	* configure.ac:
-	* src/Makefile.am:
-	* src/mga.h:
-	* src/mga_bios.c:
-	* src/mga_dacG.c:
-	* src/mga_dga.c:
-	* src/mga_driver.c:
-	* src/mga_macros.h:
-	* src/mga_merge.c:
-	* src/mga_storm.c:
-	* src/mga_vga.c:
-	Bug #6328:  Add support for Matrox G200SE chips. (Matrox)
-
-2006-03-20  Adam Jackson  <ajax@freedesktop.org>
-
-	* src/Makefile.am:
-	* src/mga.h:
-	* src/mga_dga.c:
-	* src/mga_dri.c:
-	* src/mga_macros.h:
-	* src/mga_map.h:
-	* src/mga_storm.c:
-	* src/mga_video.c:
-	Bug #5587: Refactor mga_storm.c to only build once for all color
-	depths.  (Ian Romanick)
-
-2006-03-15  Adam Jackson  <ajax@freedesktop.org>
-
-	* src/mga_dri.c:
-	Coverity #92: Eliminate a dead code path.
-	Coverity #1009: Check for NULL first before assigning to pMGADRI.
-
-2005-12-20  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Update package version for X11R7 release.
-
-2005-12-14  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Update package version number for final X11R7 release candidate.
-
-2005-12-06  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* man/Makefile.am:
-	Change *man_SOURCES ==> *man_PRE to fix autotools warnings.
-
-2005-12-03  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Update package version number for X11R7 RC3 release.
-
-2005-12-01  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Remove extraneous AC_MSG_RESULT.
-
-2005-11-20  Adam Jackson  <ajax@freedesktop.org>
-
-	* configure.ac:
-	Bump libdrm dep to 2.0.
-
-2005-11-29  Adam Jackson  <ajax@freedesktop.org>
-
-	* configure.ac:
-	Only build dlloader modules by default.
-
-2005-11-09  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Update package version number for X11R7 RC2 release.
-
-2005-11-01  Kevin E. Martin  <kem-at-freedesktop-dot-org>
-
-	* configure.ac:
-	Update pkgcheck dependencies to work with separate build roots.
diff --git a/Makefile.am b/Makefile.am
index 4e76113..d05c5ca 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -21,4 +21,12 @@
 AUTOMAKE_OPTIONS = foreign
 SUBDIRS = src man util
 
-EXTRA_DIST = README_HALLIB mga_PInS.txt
+CLEANFILES = ChangeLog
+EXTRA_DIST = README_HALLIB mga_PInS.txt ChangeLog
+
+.PHONY: ChangeLog
+
+ChangeLog:
+	git-log > ChangeLog
+
+dist-hook: ChangeLog
diff --git a/configure.ac b/configure.ac
index ec8a5ca..8cddbac 100644
--- a/configure.ac
+++ b/configure.ac
@@ -22,7 +22,7 @@
 
 AC_PREREQ(2.57)
 AC_INIT([xf86-video-mga],
-        1.4.1,
+        1.4.2,
         [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
         xf86-video-mga)
 
@@ -51,6 +51,11 @@ AC_ARG_ENABLE(dri, AC_HELP_STRING([--disable-dri],
                                   [Disable DRI support [[default=auto]]]),
               [DRI="$enableval"],
               [DRI=auto])
+AC_ARG_ENABLE(exa,
+              AC_HELP_STRING([--disable-exa],
+                             [Disable EXA support [[default enabled]]]),
+              [EXA="$enableval"],
+              [EXA=yes])
 
 # Checks for extensions
 XORG_DRIVER_CHECK_EXT(RANDR, randrproto)
@@ -59,7 +64,7 @@ XORG_DRIVER_CHECK_EXT(XV, videoproto)
 XORG_DRIVER_CHECK_EXT(DPMSExtension, xextproto)
 
 # Checks for pkg-config packages
-PKG_CHECK_MODULES(XORG, [xorg-server >= 1.0.99.901 xproto fontsproto $REQUIRED_MODULES])
+PKG_CHECK_MODULES(XORG, [xorg-server >= 1.1.0 xproto fontsproto $REQUIRED_MODULES])
 sdkdir=$(pkg-config --variable=sdkdir xorg-server)
 
 # Checks for libraries.
@@ -95,6 +100,45 @@ if test "x$DRI" = xyes; then
         AC_DEFINE(XF86DRI_DEVEL,1,[Enable developmental DRI driver support])
 fi
 
+AM_CONDITIONAL(USE_XAA, true)
+AC_DEFINE(USE_XAA, 1, [Build support for XAA])
+
+# Properly handle EXA.
+AC_MSG_CHECKING([whether to enable EXA support])
+if test "x$EXA" = xyes; then
+    AC_MSG_RESULT(yes)
+
+    SAVE_CPPFLAGS="$CPPFLAGS"
+    CPPFLAGS="$CPPFLAGS $XORG_CFLAGS"
+    AC_CHECK_HEADER(exa.h,
+                   [have_exa_h="yes"], [have_exa_h="no"])
+    CPPFLAGS="$SAVE_CPPFLAGS"
+else
+    AC_MSG_RESULT(no)
+fi 
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$CPPFLAGS $XORG_CFLAGS"
+if test "x$have_exa_h" = xyes; then
+    AC_MSG_CHECKING([whether EXA version is at least 2.0.0])
+    AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
+#include "exa.h"
+#if EXA_VERSION_MAJOR < 2
+#error OLD EXA!
+#endif
+                      ]])],
+                      [USE_EXA=yes],
+                      [USE_EXA=no])
+    AC_MSG_RESULT($USE_EXA)
+
+    if test "x$USE_EXA" = xyes; then
+        AC_DEFINE(USE_EXA, 1, [Build support for Exa])
+    fi
+fi
+CPPFLAGS="$SAVE_CPPFLAGS"
+
+AM_CONDITIONAL(USE_EXA, test "x$USE_EXA" = xyes)
+
 AC_SUBST([DRI_CFLAGS])
 AC_SUBST([XORG_CFLAGS])
 AC_SUBST([moduledir])
diff --git a/man/mga.man b/man/mga.man
index 6646096..2ad75bc 100644
--- a/man/mga.man
+++ b/man/mga.man
@@ -52,10 +52,10 @@ Productiva G100
 Millennium G200 and Mystique G200
 .TP
 .B G400
-Millenium G400, Millenium G400 MAX, Millenium G450, and Marvel G450 eTV
+Millennium G400, Millennium G400 MAX, Millennium G450, and Marvel G450 eTV
 .TP 
 .B G550
-Millenium G550 and Millenium G550 Dual DVI
+Millennium G550 and Millennium G550 Dual DVI
 .SH "CONFIGURATION DETAILS"
 Please refer to __xconfigfile__(__filemansuffix__) for general configuration
 details.  This section only covers configuration details specific to this
@@ -107,6 +107,17 @@ specified in multihead configurations.  Default: auto\-detected.
 .BI "Option \*qNoAccel\*q \*q" boolean \*q
 Disable or enable acceleration.  Default: acceleration is enabled.
 .TP
+.BI "Option \*qAccelMethod\*q \*q" "string" \*q
+Chooses between available acceleration architectures.  Valid options are
+.B XAA
+and
+.B EXA.
+XAA is the traditional acceleration architecture and support for it is very
+stable.  EXA is a newer acceleration architecture with better performance for
+the Render and Composite extensions, but the rendering code for it is newer and
+possibly unstable.  The default is
+.B XAA.
+.TP
 .BI "Option \*qNoHal\*q \*q" boolean \*q
 Disable or enable loading the "mga_hal" module.  Default: the module is
 loaded when available and when using hardware that it supports.
diff --git a/src/Makefile.am b/src/Makefile.am
index 0fa8d93..17211bb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -54,7 +54,6 @@ mga_drv_la_SOURCES = \
          mga_reg.h \
          mga_sarea.h \
          mga_shadow.c \
-         mga_storm.c \
          mga_ucode.h \
 	 mga_vga.c \
          mga_video.c
@@ -65,3 +64,13 @@ mga_drv_la_SOURCES += \
         mga_dri.h \
         mga_dripriv.h
 endif
+
+if USE_EXA
+mga_drv_la_SOURCES += \
+    mga_exa.c
+endif
+
+if USE_XAA
+mga_drv_la_SOURCES += \
+    mga_storm.c
+endif
diff --git a/src/mga.h b/src/mga.h
index 3969183..f9afea3 100644
--- a/src/mga.h
+++ b/src/mga.h
@@ -20,6 +20,7 @@
 
 #include "compiler.h"
 #include "xaa.h"
+#include "exa.h"
 #include "xf86Cursor.h"
 #include "vgaHW.h"
 #include "colormapst.h"
@@ -81,7 +82,8 @@ typedef enum {
     OPTION_MONITOR2POS,
     OPTION_METAMODES,
     OPTION_OLDDMA,
-    OPTION_PCIDMA
+    OPTION_PCIDMA,
+    OPTION_ACCELMETHOD
 } MGAOpts;
 
 
@@ -192,13 +194,20 @@ typedef struct {
    int          contrast;
    Bool         doubleBuffer;
    unsigned char currentBuffer;
-   FBLinearPtr	linear;
    RegionRec	clip;
    CARD32	colorKey;
    CARD32	videoStatus;
    Time		offTime;
    Time		freeTime;
    int		lastPort;
+
+#ifdef USE_EXA
+   int              size;
+   ExaOffscreenArea *off_screen;
+#endif
+
+   void         *video_memory;
+   int           video_offset;
 } MGAPortPrivRec, *MGAPortPrivPtr;
 
 typedef struct {
@@ -447,6 +456,8 @@ typedef struct {
     MGARamdacRec	Dac;
     Bool		HasSDRAM;
     Bool		NoAccel;
+    Bool		Exa;
+    ExaDriverPtr 	ExaDriver;
     Bool		SyncOnGreen;
     Bool		HWCursor;
     Bool		UsePCIRetry;
@@ -566,6 +577,18 @@ typedef struct {
     Bool                HALLoaded;
 #endif
     OptionInfoPtr	Options;
+
+    /* Exa */
+    PicturePtr currentSrcPicture;
+    PicturePtr currentMaskPicture;
+    PixmapPtr currentSrc;
+    PixmapPtr currentMask;
+    int src_w2;
+    int src_h2;
+    int mask_w2;
+    int mask_h2;
+    CARD32 src_pitch; /* FIXME kill me */
+
 /* Merged Framebuffer data */
     Bool                MergedFB;
 
@@ -626,12 +649,19 @@ void MGAAdjustGranularity(ScrnInfoPtr pScrn, int* x, int* y);
 void MGA2064SetupFuncs(ScrnInfoPtr pScrn);
 void MGAGSetupFuncs(ScrnInfoPtr pScrn);
 
+/* #ifdef USE_XAA */
 void MGAStormSync(ScrnInfoPtr pScrn);
 void MGAStormEngineInit(ScrnInfoPtr pScrn);
 Bool MGAStormAccelInit(ScreenPtr pScreen);
+Bool mgaAccelInit(ScreenPtr pScreen);
+/* #endif */
+
+#ifdef USE_EXA
+Bool mgaExaInit(ScreenPtr pScreen);
+#endif
+
 Bool MGAHWCursorInit(ScreenPtr pScreen);
 
-Bool mgaAccelInit(ScreenPtr pScreen);
 
 void MGAPolyArcThinSolid(DrawablePtr, GCPtr, int, xArc*);
 
@@ -720,4 +750,30 @@ void MGAFillDisplayModeStruct(DisplayModePtr pMode, LPMGAMODEINFO pModeInfo);
 /************************************************/
 #endif
 
+static __inline__ void
+MGA_MARK_SYNC(MGAPtr pMga, ScrnInfoPtr pScrn)
+{
+#ifdef USE_EXA
+    if (pMga->Exa)
+        exaMarkSync(pScrn->pScreen);
+#endif
+#ifdef USE_XAA
+    if (!pMga->Exa)
+        SET_SYNC_FLAG(pMga->AccelInfoRec);
+#endif
+}
+
+static __inline__ void
+MGA_SYNC(MGAPtr pMga, ScrnInfoPtr pScrn)
+{
+#ifdef USE_EXA
+    if (pMga->Exa)
+        exaWaitSync(pScrn->pScreen);
+#endif
+#ifdef USE_XAA
+    if (!pMga->Exa && pMga->AccelInfoRec && pMga->AccelInfoRec->NeedToSync)
+        pMga->AccelInfoRec->Sync(pScrn);
+#endif
+}
+
 #endif
diff --git a/src/mga_dri.c b/src/mga_dri.c
index 56ad243..e8cd828 100644
--- a/src/mga_dri.c
+++ b/src/mga_dri.c
@@ -370,6 +370,9 @@ void MGAGetQuiescence( ScrnInfoPtr pScrn )
 
       MGAWaitForIdleDMA( pScrn );
 
+        /* FIXME what about EXA? */
+#ifdef USE_XAA
+        if (!pMga->Exa && pMga->AccelInfoRec) {
       WAITFIFO( 11 );
       OUTREG( MGAREG_MACCESS, pMga->MAccess );
       OUTREG( MGAREG_PITCH, pLayout->displayWidth );
@@ -390,7 +393,9 @@ void MGAGetQuiescence( ScrnInfoPtr pScrn )
       OUTREG( MGAREG_YTOP, 0x00000000 );    /* minPixelPointer */
       OUTREG( MGAREG_YBOT, 0x007FFFFF );    /* maxPixelPointer */
 
-      pMga->AccelFlags &= ~CLIPPER_ON;
+            pMga->AccelFlags &= ~CLIPPER_ON;
+        }
+#endif
    }
 }
 
@@ -406,7 +411,12 @@ void MGAGetQuiescenceShared( ScrnInfoPtr pScrn )
 
    if ( pMGAEnt->directRenderingEnabled ) {
       MGAWaitForIdleDMA( pMGAEnt->pScrn_1 );
-      pMga->RestoreAccelState( pScrn );
+
+        /* FIXME what about EXA? */
+#ifdef USE_XAA
+        if (!pMga->Exa && pMga->AccelInfoRec)
+            pMga->RestoreAccelState( pScrn );
+#endif
       xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
    }
 }
@@ -420,7 +430,8 @@ static void MGASwapContext( ScreenPtr pScreen )
     * appropriate.
     */
    pMga->haveQuiescense = 0;
-   pMga->AccelInfoRec->NeedToSync = TRUE;
+
+   MGA_MARK_SYNC(pMga, pScrn);
 }
 
 static void MGASwapContextShared( ScreenPtr pScreen )
@@ -432,11 +443,10 @@ static void MGASwapContextShared( ScreenPtr pScreen )
 
    pMga = MGAPTR(pMGAEnt->pScrn_1);
 
-   pMga->haveQuiescense = 0;
-   pMga->AccelInfoRec->NeedToSync = TRUE;
+   pMga->haveQuiescense = pMGA2->haveQuiescense = 0;
 
-   pMGA2->haveQuiescense = 0;
-   pMGA2->AccelInfoRec->NeedToSync = TRUE;
+   MGA_MARK_SYNC(pMga, pScrn);
+   MGA_MARK_SYNC(pMGA2, pMGAEnt->pScrn_2);
 }
 
 /* FIXME: This comment is out of date, since we aren't overriding
@@ -486,6 +496,7 @@ MGADRISwapContextShared( ScreenPtr pScreen, DRISyncType syncType,
    }
 }
 
+#ifdef USE_XAA
 void MGASelectBuffer( ScrnInfoPtr pScrn, int which )
 {
    MGAPtr pMga = MGAPTR(pScrn);
@@ -507,6 +518,7 @@ void MGASelectBuffer( ScrnInfoPtr pScrn, int which )
       break;
    }
 }
+#endif
 
 
 static unsigned int mylog2( unsigned int n )
diff --git a/src/mga_driver.c b/src/mga_driver.c
index 94d7f29..fbaab0c 100644
--- a/src/mga_driver.c
+++ b/src/mga_driver.c
@@ -83,7 +83,10 @@
 #include "mga_macros.h"
 #include "mga_maven.h"
 
+#ifdef USE_XAA
 #include "xaa.h"
+#endif
+
 #include "xf86cmap.h"
 #include "shadowfb.h"
 #include "fbdevhw.h"
@@ -292,6 +295,7 @@ static const OptionInfoRec MGAOptions[] = {
     { OPTION_METAMODES,   "MetaModes",  	OPTV_ANYSTR,	{0}, FALSE },
     { OPTION_OLDDMA,		"OldDmaInit",	OPTV_BOOLEAN,	{0}, FALSE },
     { OPTION_PCIDMA,		"ForcePciDma",	OPTV_BOOLEAN,	{0}, FALSE },
+    { OPTION_ACCELMETHOD,	"AccelMethod",	OPTV_ANYSTR,	{0}, FALSE },
     { -1,			NULL,		OPTV_NONE,	{0}, FALSE }
 };
 
@@ -336,6 +340,17 @@ static const char *xf8_32bppSymbols[] = {
     NULL
 };
 
+#ifdef USE_EXA
+static const char *exaSymbols[] = {
+    "exaDriverInit",
+    "exaDriverFini",
+    "exaGetPixmapOffset",
+    "exaGetVersion",
+    NULL
+};
+#endif
+
+#ifdef USE_XAA
 static const char *xaaSymbols[] = {
     "XAACachePlanarMonoStipple",
     "XAACreateInfoRec",
@@ -346,6 +361,7 @@ static const char *xaaSymbols[] = {
     "XAA_888_plus_PICT_a8_to_8888",
     NULL
 };
+#endif
 
 static const char *ramdacSymbols[] = {
     "xf86CreateCursorInfoRec",
@@ -513,7 +529,13 @@ mgaSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 	 * Tell the loader about symbols from other modules that this module
 	 * might refer to.
 	 */
-	LoaderRefSymLists(vgahwSymbols, xaaSymbols,
+	LoaderRefSymLists(vgahwSymbols,
+#ifdef USE_XAA
+                          xaaSymbols,
+#endif
+#ifdef USE_EXA
+                          exaSymbols,
+#endif
 			  xf8_32bppSymbols, ramdacSymbols,
 			  ddcSymbols, i2cSymbols, shadowSymbols,
 			  fbdevHWSymbols, vbeSymbols,
@@ -1494,6 +1516,21 @@ MGAPreInit(ScrnInfoPtr pScrn, int flags)
     if (xf86ReturnOptValBool(pMga->Options, OPTION_NOACCEL, FALSE)) {
 	pMga->NoAccel = TRUE;
 	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
+    } else {
+	int from = X_DEFAULT;
+#ifdef USE_EXA
+	char *s = xf86GetOptValString(pMga->Options, OPTION_ACCELMETHOD);
+#endif
+	pMga->NoAccel = FALSE;
+	pMga->Exa = FALSE;
+#ifdef USE_EXA
+	if (!xf86NameCmp(s, "EXA")) {
+	    pMga->Exa = TRUE;
+	    from = X_CONFIG;
+	}
+#endif
+	xf86DrvMsg(pScrn->scrnIndex, from, "Using %s acceleration\n",
+		   pMga->Exa ? "EXA" : "XAA");
     }
     if (xf86ReturnOptValBool(pMga->Options, OPTION_PCI_RETRY, FALSE)) {
 	pMga->UsePCIRetry = TRUE;
@@ -2235,11 +2272,23 @@ MGAPreInit(ScrnInfoPtr pScrn, int flags)
 
     /* Load XAA if needed */
     if (!pMga->NoAccel) {
-	if (!xf86LoadSubModule(pScrn, "xaa")) {
-	    MGAFreeRec(pScrn);
-	    return FALSE;
+#ifdef USE_EXA
+	if (pMga->Exa) {
+	    if (!xf86LoadSubModule(pScrn, "exa")) {
+		MGAFreeRec(pScrn);
+		return FALSE;
+	    } else xf86LoaderReqSymLists(exaSymbols, NULL);
+	} else {
+#endif
+#ifdef USE_XAA
+	    if (!xf86LoadSubModule(pScrn, "xaa")) {
+		MGAFreeRec(pScrn);
+		return FALSE;
+	    } else xf86LoaderReqSymLists(xaaSymbols, NULL);
+#endif
+#ifdef USE_EXA
 	}
-	xf86LoaderReqSymLists(xaaSymbols, NULL);
+#endif
     }
 
     /* Load ramdac if needed */
@@ -3227,8 +3276,16 @@ MGAScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     if(!pMga->ShadowFB) /* hardware cursor needs to wrap this layer */
 	MGADGAInit(pScreen);
 
-    if (!pMga->NoAccel)
-	MGAStormAccelInit(pScreen);
+    if (!pMga->NoAccel) {
+#ifdef USE_EXA
+	if (pMga->Exa)
+	    mgaExaInit(pScreen);
+	else
+#endif
+#ifdef USE_XAA
+	    MGAStormAccelInit(pScreen);
+#endif
+    }
 
     miInitializeBackingStore(pScreen);
     xf86SetBackingStore(pScreen);
@@ -3735,8 +3792,16 @@ MGACloseScreen(int scrnIndex, ScreenPtr pScreen)
    );	/* MGA_HAL */
 #endif
 
+#ifdef USE_XAA
     if (pMga->AccelInfoRec)
 	XAADestroyInfoRec(pMga->AccelInfoRec);
+#endif
+#ifdef USE_EXA
+    if (pMga->ExaDriver) {
+	exaDriverFini(pScreen);
+	xfree(pMga->ExaDriver);
+    }
+#endif
     if (pMga->CursorInfoRec)
     	xf86DestroyCursorInfoRec(pMga->CursorInfoRec);
     if (pMga->ShadowPtr)
diff --git a/src/mga_exa.c b/src/mga_exa.c
new file mode 100644
index 0000000..3242ea8
--- /dev/null
+++ b/src/mga_exa.c
@@ -0,0 +1,810 @@
+/*
+ * Copyright 2006 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software")
+ * to deal in the software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * them 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 MERCHANTIBILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS 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.
+ *
+ * Authors:
+ *    Adam Jackson <ajax@nwnk.net>
+ *    Tilman Sauerbeck <tilman@code-monkey.de>
+ */
+
+/*
+ * Sources:
+ * - mga kdrive accel by Anders Carlsson
+ * - mga g400 Render accel by Damien Ciabrini
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "xf86.h"
+
+#include "mga.h"
+#include "mga_reg.h"
+#include "mga_macros.h"
+
+#include "exa.h"
+#ifdef XF86DRI
+#include "mga_dri.h"
+#endif
+
+#include "xf86PciInfo.h"
+
+#if 0
+#define DEBUG_MSG(x)  ErrorF x
+#else
+#define DEBUG_MSG(x)
+#endif
+
+#define PMGA(x) \
+    MGAPtr pMga = xf86Screens[x->drawable.pScreen->myNum]->driverPrivate;
+
+#define QUIESCE_DMA(x) \
+    CHECK_DMA_QUIESCENT(pMga, xf86Screens[x->drawable.pScreen->myNum]);
+
+/* stuff stolen from mga_storm.c */
+#define BLIT_LEFT   1
+#define BLIT_UP        4
+
+/* FIXME
+ * We could use MGADWG_BLK for GXcopy if HaveSDRAM is FALSE.
+ * That will only work in some situations though (see mga_storm.c
+ * for details).
+ */
+static const CARD32 mgaRop[16] = {
+    /* GXclear        */  MGADWG_RPL  | 0x00000000,    /* 0 */
+    /* GXand          */  MGADWG_RSTR | 0x00080000,    /* src AND dst */
+    /* GXandReverse   */  MGADWG_RSTR | 0x00040000,    /* src AND NOT dst */
+    /* GXcopy         */  MGADWG_RSTR | 0x000c0000,    /* src */
+    /* GXandInverted  */  MGADWG_RSTR | 0x00020000,    /* NOT src AND dst */
+    /* GXnoop         */  MGADWG_RSTR | 0x000a0000,    /* dst */
+    /* GXxor          */  MGADWG_RSTR | 0x00060000,    /* src XOR dst */
+    /* GXor           */  MGADWG_RSTR | 0x000e0000,    /* src OR dst */
+    /* GXnor          */  MGADWG_RSTR | 0x00010000,    /* NOT src AND NOT dst */
+    /* GXequiv        */  MGADWG_RSTR | 0x00090000,    /* NOT src XOR dst */
+    /* GXinvert       */  MGADWG_RSTR | 0x00050000,    /* NOT dst */
+    /* GXorReverse    */  MGADWG_RSTR | 0x000d0000,    /* src OR NOT dst */
+    /* GXcopyInverted */  MGADWG_RPL  | 0x00030000,    /* NOT src */
+    /* GXorInverted   */  MGADWG_RSTR | 0x000b0000,    /* NOT src OR dst */
+    /* GXnand         */  MGADWG_RSTR | 0x00070000,    /* NOT src OR NOT dst */
+    /* GXset          */  MGADWG_RPL  | 0x000f0000    /* 1 */
+};
+
+static const struct {
+    Bool dst_alpha;
+    Bool src_alpha;
+    CARD32 blend_cntl;
+} mgaBlendOp[] = {
+    /* Clear */
+    {0, 0, MGA_SRC_ZERO                | MGA_DST_ZERO},
+    /* Src */
+    {0, 0, MGA_SRC_ONE                 | MGA_DST_ZERO},
+    /* Dst */
+    {0, 0, MGA_SRC_ZERO                | MGA_DST_ONE},
+    /* Over */
+    {0, 1, MGA_SRC_ONE                 | MGA_DST_ONE_MINUS_SRC_ALPHA},
+    /* OverReverse */
+    {1, 0, MGA_SRC_ONE_MINUS_DST_ALPHA | MGA_DST_ONE},
+    /* In */
+    {1, 0, MGA_SRC_DST_ALPHA           | MGA_DST_ZERO},
+    /* InReverse */
+    {0, 1, MGA_SRC_ZERO                | MGA_DST_SRC_ALPHA},
+    /* Out */
+    {1, 0, MGA_SRC_ONE_MINUS_DST_ALPHA | MGA_DST_ZERO},
+    /* OutReverse */
+    {0, 1, MGA_SRC_ZERO                | MGA_DST_ONE_MINUS_SRC_ALPHA},
+    /* Atop */
+    {1, 1, MGA_SRC_DST_ALPHA           | MGA_DST_ONE_MINUS_SRC_ALPHA},
+    /* AtopReverse */
+    {1, 1, MGA_SRC_ONE_MINUS_DST_ALPHA | MGA_DST_SRC_ALPHA},
+    /* Xor */
+    {1, 1, MGA_SRC_ONE_MINUS_DST_ALPHA | MGA_DST_ONE_MINUS_SRC_ALPHA},
+    /* Add */
+    {0, 0, MGA_SRC_ONE                 | MGA_DST_ONE},
+};
+
+static CARD32
+mgaGetPixmapPitch(PixmapPtr pPix)
+{
+    return exaGetPixmapPitch(pPix) / (pPix->drawable.bitsPerPixel >> 3);
+}
+
+static CARD32
+mgaGetMACCESS(PixmapPtr pixmap, PicturePtr pict)
+{
+    switch (pixmap->drawable.bitsPerPixel) {
+    case 8:
+        return MGAMAC_PW8 | MGAMAC_BYPASS332 | MGAMAC_NODITHER;
+    case 16:
+        if (pict &&
+            (pict->format == PICT_x1r5g5b5 || pict->format == PICT_a1r5g5b5))
+            return MGAMAC_PW16 | MGAMAC_DIT555;
+        else
+            return MGAMAC_PW16;
+    case 24:
+        return MGAMAC_PW24;
+    default:
+        return MGAMAC_PW32;
+    }
+}
+
+static Bool
+mgaSetup(MGAPtr pMga, PixmapPtr pixmap, PicturePtr pict, int wait)
+{
+    WAITFIFO(wait + 4);
+
+    /* Set the format of the destination pixmap */
+    OUTREG(MGAREG_MACCESS, mgaGetMACCESS(pixmap, pict));
+
+    OUTREG(MGAREG_CXBNDRY, 0xffff0000);
+    OUTREG(MGAREG_YTOP, 0x00000000);
+    OUTREG(MGAREG_YBOT, 0x007fffff);
+
+    return TRUE;
+}
+
+static void
+mgaNoopDone(PixmapPtr pPixmap)
+{
+}
+
+static Bool
+mgaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planemask, Pixel fg)
+{
+    PMGA(pPixmap);
+    int dwgctl;
+
+    /* FIXME
+     * Is this needed here? We don't use DMA stuff here...
+     */
+    QUIESCE_DMA(pPixmap);
+
+    /* We must pad planemask and fg depending on the format of the
+     * destination pixmap
+     */
+    switch (pPixmap->drawable.bitsPerPixel) {
+    case 8:
+        fg |= fg << 8;
+        planemask |= planemask << 8;
+        /* fall through */
+    case 16:
+        fg |= fg << 16;
+        planemask |= planemask << 16;
+        break;
+    }
+
+    dwgctl = MGADWG_TRAP | MGADWG_SOLID | MGADWG_ARZERO |
+             MGADWG_SGNZERO | MGADWG_SHIFTZERO | mgaRop[alu];
+
+    mgaSetup(pMga, pPixmap, NULL, 5);
+
+    OUTREG(MGAREG_PITCH, mgaGetPixmapPitch(pPixmap));
+    OUTREG(MGAREG_DSTORG, exaGetPixmapOffset(pPixmap));
+    OUTREG(MGAREG_FCOL, fg);
+    OUTREG(MGAREG_PLNWT, planemask);
+    OUTREG(MGAREG_DWGCTL, dwgctl);
+
+    return TRUE;
+}
+
+static void
+mgaSolid(PixmapPtr pPixmap, int x1, int y1, int x2, int y2)
+{
+    PMGA(pPixmap);
+
+    WAITFIFO(2);
+    OUTREG(MGAREG_FXBNDRY, (x2 << 16) | (x1 & 0xffff));
+    OUTREG(MGAREG_YDSTLEN | MGAREG_EXEC, (y1 << 16) | (y2 - y1));
+}
+
+static Bool
+mgaPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int xdir, int ydir, int alu,
+           Pixel planemask)
+{
+    PMGA(pSrc);
+    int blit_direction = 0;
+    int dwgctl = 0;
+
+    /* FIXME
+     * Is this needed here? We don't use DMA stuff here...
+     */
+    QUIESCE_DMA(pSrc);
+
+    DEBUG_MSG(("s: %x@%x d: %x@%x xdir %d ydir %d alu %d pm %d\n",
+           exaGetPixmapOffset(pSrc), exaGetPixmapPitch(pSrc),
+           exaGetPixmapOffset(pDst), exaGetPixmapPitch(pDst),
+           xdir, ydir, alu, planemask));
+
+    if (xdir < 0)
+        blit_direction |= BLIT_LEFT;
+
+    if (ydir < 0)
+        blit_direction |= BLIT_UP;
+
+    pMga->BltScanDirection = blit_direction;
+
+    dwgctl = mgaRop[alu] | MGADWG_SHIFTZERO | MGADWG_BITBLT | MGADWG_BFCOL;
+    pMga->src_pitch = mgaGetPixmapPitch(pSrc);
+
+    mgaSetup(pMga, pDst, NULL, 7);
+    OUTREG(MGAREG_PITCH, mgaGetPixmapPitch(pDst));
+    OUTREG(MGAREG_SRCORG, exaGetPixmapOffset(pSrc));
+    OUTREG(MGAREG_DSTORG, exaGetPixmapOffset(pDst));
+    OUTREG(MGAREG_DWGCTL, dwgctl);
+    OUTREG(MGAREG_SGN, blit_direction);
+    OUTREG(MGAREG_PLNWT, planemask);
+    OUTREG(MGAREG_AR5, (ydir < 0 ? -1 : 1) * pMga->src_pitch);
+
+    return TRUE;
+}
+
+static void
+mgaCopy(PixmapPtr pDst, int srcx, int srcy, int dstx, int dsty, int w, int h)
+{
+    PMGA(pDst);
+    int start, end;
+
+    DEBUG_MSG(("    %d,%d -> %d,%d %dx%d\n", srcx, srcy, dstx,dsty, w, h));
+
+    w--;
+
+    if (pMga->BltScanDirection & BLIT_UP) {
+        srcy += h - 1;
+        dsty += h - 1;
+    }
+
+    start = end = srcy * pMga->src_pitch + srcx;
+
+    if (pMga->BltScanDirection & BLIT_LEFT)
+        start += w;
+    else
+        end += w;
+
+    DEBUG_MSG(("        end %d start %d dstx %d dsty %d w %d h %d\n",
+              end, start, dstx, dsty, w, h));
+
+    WAITFIFO(4);
+    OUTREG(MGAREG_AR0, end);
+    OUTREG(MGAREG_AR3, start);
+    OUTREG(MGAREG_FXBNDRY, ((dstx + w) << 16) | (dstx & 0xffff));
+    OUTREG(MGAREG_YDSTLEN | MGAREG_EXEC, (dsty << 16) | h);
+}
+
+static int
+MGA_LOG2(int val)
+{
+    int ret = 0;
+
+    if (val == 1)
+        return 0;
+
+    while (val >> ret)
+        ret++;
+
+    return ((1 << (ret - 1)) == val) ? (ret - 1) : ret;
+}
+
+static CARD32
+mgaGetTexFormat(PicturePtr pPict)
+{
+    static const struct {
+        int fmt;
+        CARD32 card_fmt;
+    } *ptr, texformats[] = {
+        { PICT_a8r8g8b8, MGA_TW32 },
+        { PICT_x8r8g8b8, MGA_TW32 },
+        { PICT_r5g6b5, MGA_TW16 },
+        { PICT_a1r5g5b5, MGA_TW15 },
+        { PICT_x1r5g5b5, MGA_TW15 },
+        { PICT_a4r4g4b4, MGA_TW12 },
+        { PICT_x4r4g4b4, MGA_TW12 },
+        { PICT_a8, MGA_TW8A },
+        { 0, 0}
+    };
+
+    for (ptr = texformats; ptr->fmt; ptr++)
+        if (ptr->fmt == pPict->format)
+            return ptr->card_fmt;
+
+    return 0;
+}
+
+static Bool
+mgaCheckSourceTexture(int tmu, PicturePtr pPict)
+{
+    int w = pPict->pDrawable->width;
+    int h = pPict->pDrawable->height;
+
+    if ((w > 2047) || (h > 2047)){
+        DEBUG_MSG(("Picture w/h too large (%dx%d)\n", w, h));
+        return FALSE;
+    }
+
+    if (!mgaGetTexFormat(pPict)) {
+        DEBUG_MSG(("Unsupported picture format 0x%x\n", pPict->format));
+        return FALSE;
+    }
+
+    if (pPict->repeat && ((w & (w - 1)) != 0 || (h & (h - 1)) != 0)) {
+        DEBUG_MSG(("NPOT repeat unsupported (%dx%d)\n", w, h));
+        return FALSE;
+    }
+
+    if (pPict->filter != PictFilterNearest &&
+        pPict->filter != PictFilterBilinear) {
+        DEBUG_MSG(("Unsupported filter 0x%x\n", pPict->filter));
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static Bool
+mgaCheckComposite(int op, PicturePtr pSrcPict, PicturePtr pMaskPict,
+                  PicturePtr pDstPict)
+{
+    if (op >= sizeof(mgaBlendOp) / sizeof(mgaBlendOp[0])) {
+        DEBUG_MSG(("unsupported op %x\n", op));
+        return FALSE;
+    }
+
+    if (!mgaCheckSourceTexture(0, pSrcPict))
+        return FALSE;
+
+    if (pMaskPict) {
+        if (!mgaCheckSourceTexture(1, pMaskPict))
+            return FALSE;
+
+        if (pMaskPict->componentAlpha) {
+            DEBUG_MSG(("Component alpha unsupported\n"));
+            return FALSE;
+        }
+    }
+
+    if (PICT_FORMAT_TYPE(pDstPict->format) == PICT_TYPE_ABGR) {
+        DEBUG_MSG(("render to (A)BGR unsupported\n"));
+        return FALSE;
+    }
+
+    /* FIXME
+     * Doing this operation in hardware is broken atm :/
+     */
+    if (op == PictOpAdd && pSrcPict->format == PICT_a8 &&
+        pDstPict->format == PICT_a8)
+        return FALSE;
+
+    return TRUE;
+}
+
+static void
+PrepareSourceTexture(int tmu, PicturePtr pSrcPicture, PixmapPtr pSrc)
+{
+    PMGA(pSrc);
+    int pitch = mgaGetPixmapPitch(pSrc);
+    int w = pSrc->drawable.width;
+    int h = pSrc->drawable.height;
+    int w_log2 = MGA_LOG2(w);
+    int h_log2 = MGA_LOG2(h);
+
+    int texctl = MGA_PITCHLIN | ((pitch & (2048 - 1)) << 9) |
+                 MGA_NOPERSPECTIVE | MGA_TAKEY;
+    int texctl2 = MGA_G400_TC2_MAGIC | MGA_TC2_CKSTRANSDIS;
+    int texfilter = MGA_FILTERALPHA | (0x10 << 21);
+
+    texctl |= mgaGetTexFormat(pSrcPicture);
+
+    if (pSrcPicture->filter == PictFilterBilinear)
+        texfilter |= MGA_MAG_BILIN | MGA_MIN_BILIN;
+    else
+        texfilter |= MGA_MAG_NRST | MGA_MIN_NRST;
+
+    if (!pSrcPicture->repeat)
+        texctl |= MGA_CLAMPUV;
+
+    if (tmu == 1)
+        texctl2 |= MGA_TC2_DUALTEX | MGA_TC2_SELECT_TMU1;
+
+    WAITFIFO(6);
+    OUTREG(MGAREG_TEXCTL2, texctl2);
+    OUTREG(MGAREG_TEXCTL, texctl);
+
+    /* Source (texture) address + pitch */
+    OUTREG(MGAREG_TEXORG, exaGetPixmapOffset(pSrc));
+    OUTREG(MGAREG_TEXWIDTH, (w - 1) << 18 | ((8 - w_log2) & 63) << 9 | w_log2);
+    OUTREG(MGAREG_TEXHEIGHT, (h - 1) << 18 | ((8 - h_log2) & 63) << 9 | h_log2);
+
+    /* Set blit filtering flags */
+    OUTREG(MGAREG_TEXFILTER, texfilter);
+
+    if (tmu == 1) {
+        WAITFIFO(1);
+        OUTREG(MGAREG_TEXCTL2, texctl2 & ~MGA_TC2_SELECT_TMU1);
+    }
+}
+
+/*
+ *  The formals params are the elements of the following matrix:
+ *
+ *     Dest            Transform             Src
+ *    coords                                coords
+ *   / Xdst \   / X_incx X_incy X_init \   / Xsrc \
+ *   | Ydst | = | Y_incx Y_incy Y_init | x | Ysrc |
+ *   \  1   /   \ H_incx H_incy H_init /   \  1   /
+ *
+ * matrix elements are 32bits fixed points (16.16)
+ * mga_fx_* is the size of the fixed point for the TMU
+ */
+static void
+setTMIncrementsRegs(PixmapPtr pPix, int X_incx, int X_incy, int X_init,
+                    int Y_incx, int Y_incy, int Y_init,
+                    int H_incx, int H_incy, int H_init,
+                    int mga_fx_width_size, int mga_fx_height_size)
+{
+    PMGA(pPix);
+
+    int decalw = mga_fx_width_size - 16;
+    int decalh = mga_fx_height_size - 16;
+
+    /* Convert 16 bits fixpoint -> MGA variable size fixpoint */
+    if (decalw >= 0) {
+        X_incx <<= decalw;
+        X_incy <<= decalw;
+        X_init <<= decalw;
+    } else {
+        decalw = -decalw;
+        X_incx >>= decalw;
+        X_incy >>= decalw;
+        X_init >>= decalw;
+    }
+
+    /* Convert 16 bits fixpoint -> MGA variable size fixpoint */
+    if (decalh >= 0) {
+        Y_incx <<= decalh;
+        Y_incy <<= decalh;
+        Y_init <<= decalh;
+    } else {
+        decalh = -decalh;
+        Y_incx >>= decalh;
+        Y_incy >>= decalh;
+        Y_init >>= decalh;
+    }
+
+    /* Set TM registers */
+    WAITFIFO(9);
+    OUTREG(MGAREG_TMR0, X_incx);
+    OUTREG(MGAREG_TMR1, Y_incx);
+    OUTREG(MGAREG_TMR2, X_incy);
+    OUTREG(MGAREG_TMR3, Y_incy);
+    OUTREG(MGAREG_TMR4, H_incx);
+    OUTREG(MGAREG_TMR5, H_incy);
+    OUTREG(MGAREG_TMR6, X_init);
+    OUTREG(MGAREG_TMR7, Y_init);
+    OUTREG(MGAREG_TMR8, H_init);
+}
+
+/* XXX these look like magic */
+#define C_ARG1_CUR              0x0
+#define C_ARG1_ALPHA            MGA_TDS_COLOR_ARG1_REPLICATEALPHA
+#define C_ARG2_DIFFUSE          MGA_TDS_COLOR_ARG2_DIFFUSE
+#define C_ARG2_FCOL             MGA_TDS_COLOR_ARG2_FCOL
+#define C_ARG2_PREV             MGA_TDS_COLOR_ARG2_PREVSTAGE
+#define C_ARG1_INV              MGA_TDS_COLOR_ARG1_INV
+#define C_ARG2_INV              MGA_TDS_COLOR_ARG2_INV
+#define COLOR_MUL               MGA_TDS_COLOR_SEL_MUL
+#define COLOR_ARG1              MGA_TDS_COLOR_SEL_ARG1
+#define COLOR_ARG2              MGA_TDS_COLOR_SEL_ARG2
+#define A_ARG1_CUR              0x0
+#define A_ARG2_IGN              A_ARG2_DIFFUSE
+#define A_ARG2_FCOL             MGA_TDS_ALPHA_ARG2_FCOL
+#define A_ARG2_DIFFUSE          MGA_TDS_ALPHA_ARG2_DIFFUSE
+#define A_ARG2_PREV             MGA_TDS_ALPHA_ARG2_PREVSTAGE
+#define ALPHA_MUL               MGA_TDS_ALPHA_SEL_MUL
+#define ALPHA_ARG1              MGA_TDS_ALPHA_SEL_ARG1
+#define ALPHA_ARG2              MGA_TDS_ALPHA_SEL_ARG2
+
+static Bool
+mgaPrepareComposite(int op, PicturePtr pSrcPict, PicturePtr pMaskPict,
+                    PicturePtr pDstPict, PixmapPtr pSrc, PixmapPtr pMask,
+                    PixmapPtr pDst)
+{
+    PMGA(pDst);
+    CARD32 fcol = 0xff000000, ds0 = 0, ds1 = 0, cmd, blendcntl;
+
+    mgaSetup(pMga, pDst, pDstPict, 2);
+    OUTREG(MGAREG_DSTORG, exaGetPixmapOffset(pDst));
+    OUTREG(MGAREG_PITCH, mgaGetPixmapPitch(pDst));
+
+    PrepareSourceTexture(0, pSrcPict, pSrc);
+
+    if (pMask)
+        PrepareSourceTexture(1, pMaskPict, pMask);
+    else
+        PrepareSourceTexture(1, pSrcPict, pSrc);
+
+    /* For A8 writes, the desired alpha value needs to be replicated
+     * to the color channels - if the source texture doesn't have an
+     * alpha channel, set it to 0xff instead.
+     * Otherwise, use the color channels if available, or set them
+     * to black.
+     */
+    if (pDstPict->format == PICT_a8 && !PICT_FORMAT_A(pSrcPict->format)) {
+        fcol = 0xffffffff;
+        ds0 |= C_ARG2_FCOL | COLOR_ARG2; /* C = 0xff */
+    } else if (pDstPict->format == PICT_a8)
+        ds0 |= C_ARG1_ALPHA | COLOR_ARG1; /* C = As */
+    else if (pSrcPict->format == PICT_a8)
+        ds0 |= C_ARG2_FCOL | COLOR_ARG2; /* C = 0 */
+    else
+        ds0 |= C_ARG1_CUR | COLOR_ARG1; /* C = Cs */
+
+    /* If the source texture has an alpha channel, use it.
+     * Otherwise, set the alpha channel to 0xff (see FCOL setting above).
+     */
+    if (PICT_FORMAT_A(pSrcPict->format))
+        ds0 |= A_ARG1_CUR | ALPHA_ARG1; /* A = As */
+    else
+        ds0 |= A_ARG2_FCOL | ALPHA_ARG2; /* A = 0xff */
+
+    if (!pMask)
+        ds1 = ds0;
+    else {
+        /* As or Am might be NULL. in this case we don't multiply because,
+         * the alpha component holds garbage.
+         */
+        if (!PICT_FORMAT_A(pMaskPict->format))
+            ds1 |= C_ARG2_PREV | COLOR_ARG2; /* C = Cs */
+        else
+            ds1 |= C_ARG1_ALPHA | C_ARG2_PREV | COLOR_MUL; /* C = Am * Cs */
+
+        if (!PICT_FORMAT_A(pMaskPict->format))
+            ds1 |= A_ARG2_PREV | ALPHA_ARG2; /* A = As */
+        else if (!PICT_FORMAT_A(pSrcPict->format))
+            ds1 |= A_ARG1_CUR | ALPHA_ARG1; /* A = Am */
+        else
+            ds1 |= A_ARG1_CUR | A_ARG2_PREV | ALPHA_MUL; /* A = Am * As */
+    }
+
+    cmd = MGADWG_TEXTURE_TRAP | MGADWG_I | 0x000c0000 |
+          MGADWG_SHIFTZERO | MGADWG_SGNZERO | MGADWG_ARZERO;
+    blendcntl = mgaBlendOp[op].blend_cntl;
+
+    if (!PICT_FORMAT_A(pDstPict->format) && mgaBlendOp[op].dst_alpha) {
+        int sblend = blendcntl & MGA_SRC_BLEND_MASK;
+
+        if (sblend == MGA_SRC_DST_ALPHA)
+            blendcntl = (blendcntl & ~MGA_SRC_BLEND_MASK) | MGA_SRC_ONE;
+        else if (sblend == MGA_SRC_ONE_MINUS_DST_ALPHA)
+            blendcntl = (blendcntl & ~MGA_SRC_BLEND_MASK) | MGA_SRC_ZERO;
+    }
+
+    if (!PICT_FORMAT_A(pSrcPict->format) && mgaBlendOp[op].src_alpha) {
+        int dblend = blendcntl & MGA_DST_BLEND_MASK;
+
+        if (dblend == MGA_DST_SRC_ALPHA)
+            blendcntl = (blendcntl & ~MGA_DST_BLEND_MASK) | MGA_DST_ONE;
+        else if (dblend == MGA_DST_ONE_MINUS_SRC_ALPHA)
+            blendcntl = (blendcntl & ~MGA_DST_BLEND_MASK) | MGA_DST_ZERO;
+    }
+
+    WAITFIFO(5);
+    OUTREG(MGAREG_FCOL, fcol);
+    OUTREG(MGAREG_TDUALSTAGE0, ds0);
+    OUTREG(MGAREG_TDUALSTAGE1, ds1);
+    OUTREG(MGAREG_DWGCTL, cmd);
+    OUTREG(MGAREG_ALPHACTRL, MGA_ALPHACHANNEL | blendcntl);
+
+    pMga->currentSrcPicture = pSrcPict;
+    pMga->currentMaskPicture = pMaskPict;
+    pMga->currentSrc = pSrc;
+    pMga->currentMask = pMask;
+
+    pMga->src_w2 = MGA_LOG2 (pSrc->drawable.width);
+    pMga->src_h2 = MGA_LOG2 (pSrc->drawable.height);
+
+    if (pMask) {
+        pMga->mask_w2 = MGA_LOG2 (pMask->drawable.width);
+        pMga->mask_h2 = MGA_LOG2 (pMask->drawable.height);
+    }
+
+    return TRUE;
+}
+
+static void
+mgaComposite(PixmapPtr pDst, int srcx, int srcy, int maskx, int masky,
+             int dstx, int dsty, int w, int h)
+{
+    PMGA(pDst);
+    PictTransformPtr t;
+    int texctl2;
+
+    srcx %= pMga->currentSrc->drawable.width;
+    srcy %= pMga->currentSrc->drawable.height;
+
+    if (pMga->currentMask) {
+        maskx %= pMga->currentMask->drawable.width;
+        masky %= pMga->currentMask->drawable.height;
+    }
+
+    t = pMga->currentSrcPicture->transform;
+
+    if (t)
+        setTMIncrementsRegs(pMga->currentSrc,
+                            t->matrix[0][0],
+                            t->matrix[0][1],
+                            t->matrix[0][2] + (srcx << 16),
+                            t->matrix[1][0],
+                            t->matrix[1][1],
+                            t->matrix[1][2] + (srcy << 16),
+                            t->matrix[2][0],
+                            t->matrix[2][1],
+                            t->matrix[2][2],
+                            20 - pMga->src_w2,
+                            20 - pMga->src_h2);
+    else
+        setTMIncrementsRegs(pMga->currentSrc,
+                            1 << 16, 0, srcx << 16,
+                            0, 1 << 16, srcy << 16,
+                            0, 0, 1 << 16,
+                            20 - pMga->src_w2,
+                            20 - pMga->src_h2);
+
+    if (pMga->currentMask) {
+        texctl2 = MGA_G400_TC2_MAGIC | MGA_TC2_CKSTRANSDIS | MGA_TC2_DUALTEX;
+
+        WAITFIFO(1);
+        OUTREG(MGAREG_TEXCTL2, texctl2 | MGA_TC2_SELECT_TMU1);
+
+        t = pMga->currentMaskPicture->transform;
+
+        if (t)
+            setTMIncrementsRegs(pMga->currentMask,
+                                t->matrix[0][0],
+                                t->matrix[0][1],
+                                t->matrix[0][2] + (maskx << 16),
+                                t->matrix[1][0],
+                                t->matrix[1][1],
+                                t->matrix[1][2] + (masky << 16),
+                                t->matrix[2][0],
+                                t->matrix[2][1],
+                                t->matrix[2][2],
+                                20 - pMga->mask_w2,
+                                20 - pMga->mask_h2);
+        else
+            setTMIncrementsRegs(pMga->currentMask,
+                                1 << 16, 0, maskx << 16,
+                                0, 1 << 16, masky << 16,
+                                0, 0, 1 << 16,
+                                20 - pMga->mask_w2,
+                                20 - pMga->mask_h2);
+
+        WAITFIFO(1);
+        OUTREG(MGAREG_TEXCTL2, texctl2 & ~MGA_TC2_SELECT_TMU1);
+    }
+
+    WAITFIFO(2);
+    OUTREG(MGAREG_FXBNDRY, ((dstx + w) << 16) | (dstx & 0xffff));
+    OUTREG(MGAREG_YDSTLEN | MGAREG_EXEC, (dsty << 16) | (h & 0xffff));
+}
+
+static Bool
+mgaUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h,
+                  char *src, int src_pitch)
+{
+    PMGA(pDst);
+    int bytes_padded = ((pDst->drawable.bitsPerPixel * w + 31) / 32) * 4;
+
+    QUIESCE_DMA(pDst);
+
+    mgaSetup(pMga, pDst, NULL, 10);
+
+    OUTREG(MGAREG_OPMODE, MGAOPM_DMA_BLIT);
+    OUTREG(MGAREG_DSTORG, exaGetPixmapOffset(pDst));
+    OUTREG(MGAREG_PITCH, mgaGetPixmapPitch(pDst));
+    OUTREG(MGAREG_PLNWT, 0xffffffff);
+    OUTREG(MGAREG_DWGCTL, MGADWG_ILOAD | MGADWG_BFCOL |
+           MGADWG_SGNZERO | MGADWG_SHIFTZERO |
+           MGADWG_RSTR | 0x000c0000);
+    OUTREG(MGAREG_AR0, w - 1);
+    OUTREG(MGAREG_AR3, 0);
+    OUTREG(MGAREG_AR5, 0);
+    OUTREG(MGAREG_FXBNDRY, ((x + w - 1) << 16) | (x & 0xffff));
+    OUTREG(MGAREG_YDSTLEN | MGAREG_EXEC, (y << 16) | (h & 0xffff));
+
+    while (h--) {
+        memcpy (pMga->ILOADBase, src, bytes_padded);
+        src += src_pitch;
+    }
+
+    return TRUE;
+}
+
+static void
+mgaWaitMarker(ScreenPtr pScreen, int marker)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    MGAPtr pMga = pScrn->driverPrivate;
+
+    WAITFIFO(1);
+
+    OUTREG(MGAREG_CACHEFLUSH, 0);
+
+    /* wait until the "drawing engine busy" bit is unset */
+    while (INREG (MGAREG_Status) & 0x10000);
+}
+
+Bool
+mgaExaInit(ScreenPtr pScreen)
+{
+    ExaDriverPtr pExa;
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    MGAPtr pMga = pScrn->driverPrivate;
+
+    pExa = exaDriverAlloc();
+    if (!pExa) {
+        pMga->NoAccel = TRUE;
+        return FALSE;
+    }
+
+    pMga->ExaDriver = pExa;
+
+    pExa->exa_major = EXA_VERSION_MAJOR;
+    pExa->exa_minor = EXA_VERSION_MINOR;
+
+    pExa->flags = EXA_OFFSCREEN_PIXMAPS | EXA_OFFSCREEN_ALIGN_POT;
+    pExa->memoryBase = pMga->FbStart;
+    pExa->memorySize = pMga->FbUsableSize - 4096;
+    pExa->offScreenBase = (pScrn->virtualX * pScrn->virtualY *
+                           pScrn->bitsPerPixel / 8) + 4096;
+
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "X %d Y %d bpp %d\n",
+               pScrn->virtualX, pScrn->virtualY, pScrn->bitsPerPixel);
+    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Start at %p, size %x, osb %x\n",
+               pExa->memoryBase, pExa->memorySize, pExa->offScreenBase);
+
+    /* In PW24 mode, we need to align to "3 64-bytes" */
+    pExa->pixmapOffsetAlign = 192;
+
+    /* Pitch alignment is in sets of 32 pixels, and we need to cover
+     * 32bpp, so it's 128 bytes.
+     */
+    pExa->pixmapPitchAlign = 128;
+
+    pExa->maxX = 2048;
+    pExa->maxY = 2048;
+
+    pExa->WaitMarker = mgaWaitMarker;
+    pExa->PrepareSolid = mgaPrepareSolid;
+    pExa->Solid = mgaSolid;
+    pExa->DoneSolid = mgaNoopDone;
+    pExa->PrepareCopy = mgaPrepareCopy;
+    pExa->Copy = mgaCopy;
+    pExa->DoneCopy = mgaNoopDone;
+
+    if (pMga->Chipset == PCI_CHIP_MGAG400) {
+        pExa->CheckComposite = mgaCheckComposite;
+        pExa->PrepareComposite = mgaPrepareComposite;
+        pExa->Composite = mgaComposite;
+        pExa->DoneComposite = mgaNoopDone;
+    }
+
+    pExa->UploadToScreen = mgaUploadToScreen;
+
+    return exaDriverInit(pScreen, pExa);
+}
diff --git a/src/mga_reg.h b/src/mga_reg.h
index 0d6a20b..874c4ed 100644
--- a/src/mga_reg.h
+++ b/src/mga_reg.h
@@ -109,6 +109,7 @@
 
 #define	MGAREG_FIFOSTATUS	0x1e10
 #define	MGAREG_Status		0x1e14
+#define MGAREG_CACHEFLUSH       0x1fff
 #define	MGAREG_ICLEAR		0x1e18
 #define	MGAREG_IEN		0x1e1c
 
@@ -132,6 +133,15 @@
 #define MGAOPM_DMA_BLIT		(0x01 << 2)
 #define MGAOPM_DMA_VECTOR	(0x10 << 2)
 
+/* MACCESS register additives */
+#define MGAMAC_PW8               0x00
+#define MGAMAC_PW16              0x01
+#define MGAMAC_PW24              0x03 /* not a typo */
+#define MGAMAC_PW32              0x02 /* not a typo */
+#define MGAMAC_BYPASS332         0x10000000
+#define MGAMAC_NODITHER          0x40000000
+#define MGAMAC_DIT555            0x80000000
+
 /* DWGCTL register additives */
 
 /* Lines */
@@ -143,7 +153,7 @@
 
 /* Trapezoids */
 #define MGADWG_TRAP		0x04
-#define MGADWG_TEXTURE_TRAP	0x05
+#define MGADWG_TEXTURE_TRAP	0x06
 
 /* BitBlts */
 
@@ -465,14 +475,116 @@
 #define MGAREG_TEXWIDTH		0x2c28
 #define MGAREG_TEXHEIGHT	0x2c2c
 #define MGAREG_TEXCTL		0x2c30
+#    define MGA_TW4                             (0x00000000)
+#    define MGA_TW8                             (0x00000001)
+#    define MGA_TW15                            (0x00000002)
+#    define MGA_TW16                            (0x00000003)
+#    define MGA_TW12                            (0x00000004)
+#    define MGA_TW32                            (0x00000006)
+#    define MGA_TW8A                            (0x00000007)
+#    define MGA_TW8AL                           (0x00000008)
+#    define MGA_TW422                           (0x0000000A)
+#    define MGA_TW422UYVY                       (0x0000000B)
+#    define MGA_PITCHLIN                        (0x00000100)
+#    define MGA_NOPERSPECTIVE                   (0x00200000)
+#    define MGA_TAKEY                           (0x02000000)
+#    define MGA_TAMASK                          (0x04000000)
+#    define MGA_CLAMPUV                         (0x18000000)
+#    define MGA_TEXMODULATE                     (0x20000000)
 #define MGAREG_TEXCTL2		0x2c3c
+#    define MGA_G400_TC2_MAGIC                  (0x00008000)
+#    define MGA_TC2_DECALBLEND                  (0x00000001)
+#    define MGA_TC2_IDECAL                      (0x00000002)
+#    define MGA_TC2_DECALDIS                    (0x00000004)
+#    define MGA_TC2_CKSTRANSDIS                 (0x00000010)
+#    define MGA_TC2_BORDEREN                    (0x00000020)
+#    define MGA_TC2_SPECEN                      (0x00000040)
+#    define MGA_TC2_DUALTEX                     (0x00000080)
+#    define MGA_TC2_TABLEFOG                    (0x00000100)
+#    define MGA_TC2_BUMPMAP                     (0x00000200)
+#    define MGA_TC2_SELECT_TMU1                 (0x80000000)
 #define MGAREG_TEXTRANS		0x2c34
 #define MGAREG_TEXTRANSHIGH	0x2c38
 #define MGAREG_TEXFILTER	0x2c58
+#    define MGA_MIN_NRST                        (0x00000000)
+#    define MGA_MIN_BILIN                       (0x00000002)
+#    define MGA_MIN_ANISO                       (0x0000000D)
+#    define MGA_MAG_NRST                        (0x00000000)
+#    define MGA_MAG_BILIN                       (0x00000020)
+#    define MGA_FILTERALPHA                     (0x00100000)
 #define MGAREG_ALPHASTART	0x2c70
 #define MGAREG_ALPHAXINC	0x2c74
 #define MGAREG_ALPHAYINC	0x2c78
 #define MGAREG_ALPHACTRL	0x2c7c
+#    define MGA_SRC_ZERO                        (0x00000000)
+#    define MGA_SRC_ONE                         (0x00000001)
+#    define MGA_SRC_DST_COLOR                   (0x00000002)
+#    define MGA_SRC_ONE_MINUS_DST_COLOR         (0x00000003)
+#    define MGA_SRC_ALPHA                       (0x00000004)
+#    define MGA_SRC_ONE_MINUS_SRC_ALPHA         (0x00000005)
+#    define MGA_SRC_DST_ALPHA                   (0x00000006)
+#    define MGA_SRC_ONE_MINUS_DST_ALPHA         (0x00000007)
+#    define MGA_SRC_SRC_ALPHA_SATURATE          (0x00000008)
+#    define MGA_SRC_BLEND_MASK                  (0x0000000f)
+#    define MGA_DST_ZERO                        (0x00000000)
+#    define MGA_DST_ONE                         (0x00000010)
+#    define MGA_DST_SRC_COLOR                   (0x00000020)
+#    define MGA_DST_ONE_MINUS_SRC_COLOR         (0x00000030)
+#    define MGA_DST_SRC_ALPHA                   (0x00000040)
+#    define MGA_DST_ONE_MINUS_SRC_ALPHA         (0x00000050)
+#    define MGA_DST_DST_ALPHA                   (0x00000060)
+#    define MGA_DST_ONE_MINUS_DST_ALPHA         (0x00000070)
+#    define MGA_DST_BLEND_MASK                  (0x00000070)
+#    define MGA_ALPHACHANNEL                    (0x00000100)
+#    define MGA_VIDEOALPHA                      (0x00000200)
+#    define MGA_DIFFUSEDALPHA                   (0x01000000)
+#    define MGA_MODULATEDALPHA                  (0x02000000)
+#define MGAREG_TDUALSTAGE0                      (0x2CF8)
+#define MGAREG_TDUALSTAGE1                      (0x2CFC)
+#    define MGA_TDS_COLOR_ARG2_DIFFUSE          (0x00000000)
+#    define MGA_TDS_COLOR_ARG2_SPECULAR         (0x00000001)
+#    define MGA_TDS_COLOR_ARG2_FCOL             (0x00000002)
+#    define MGA_TDS_COLOR_ARG2_PREVSTAGE        (0x00000003)
+#    define MGA_TDS_COLOR_ALPHA_DIFFUSE         (0x00000000)
+#    define MGA_TDS_COLOR_ALPHA_FCOL            (0x00000004)
+#    define MGA_TDS_COLOR_ALPHA_CURRTEX         (0x00000008)
+#    define MGA_TDS_COLOR_ALPHA_PREVTEX         (0x0000000c)
+#    define MGA_TDS_COLOR_ALPHA_PREVSTAGE       (0x00000010)
+#    define MGA_TDS_COLOR_ARG1_REPLICATEALPHA   (0x00000020)
+#    define MGA_TDS_COLOR_ARG1_INV              (0x00000040)
+#    define MGA_TDS_COLOR_ARG2_REPLICATEALPHA   (0x00000080)
+#    define MGA_TDS_COLOR_ARG2_INV              (0x00000100)
+#    define MGA_TDS_COLOR_ALPHA1INV             (0x00000200)
+#    define MGA_TDS_COLOR_ALPHA2INV             (0x00000400)
+#    define MGA_TDS_COLOR_ARG1MUL_ALPHA1        (0x00000800)
+#    define MGA_TDS_COLOR_ARG2MUL_ALPHA2        (0x00001000)
+#    define MGA_TDS_COLOR_ARG1ADD_MULOUT        (0x00002000)
+#    define MGA_TDS_COLOR_ARG2ADD_MULOUT        (0x00004000)
+#    define MGA_TDS_COLOR_MODBRIGHT_2X          (0x00008000)
+#    define MGA_TDS_COLOR_MODBRIGHT_4X          (0x00010000)
+#    define MGA_TDS_COLOR_ADD_SUB               (0x00000000)
+#    define MGA_TDS_COLOR_ADD_ADD               (0x00020000)
+#    define MGA_TDS_COLOR_ADD2X                 (0x00040000)
+#    define MGA_TDS_COLOR_ADDBIAS               (0x00080000)
+#    define MGA_TDS_COLOR_BLEND                 (0x00100000)
+#    define MGA_TDS_COLOR_SEL_ARG1              (0x00000000)
+#    define MGA_TDS_COLOR_SEL_ARG2              (0x00200000)
+#    define MGA_TDS_COLOR_SEL_ADD               (0x00400000)
+#    define MGA_TDS_COLOR_SEL_MUL               (0x00600000)
+#    define MGA_TDS_ALPHA_ARG1_INV              (0x00800000)
+#    define MGA_TDS_ALPHA_ARG2_DIFFUSE          (0x00000000)
+#    define MGA_TDS_ALPHA_ARG2_FCOL             (0x01000000)
+#    define MGA_TDS_ALPHA_ARG2_PREVTEX          (0x02000000)
+#    define MGA_TDS_ALPHA_ARG2_PREVSTAGE        (0x03000000)
+#    define MGA_TDS_ALPHA_ARG2_INV              (0x04000000)
+#    define MGA_TDS_ALPHA_ADD                   (0x08000000)
+#    define MGA_TDS_ALPHA_ADDBIAS               (0x10000000)
+#    define MGA_TDS_ALPHA_ADD2X                 (0x20000000)
+#    define MGA_TDS_ALPHA_SEL_ARG1              (0x00000000)
+#    define MGA_TDS_ALPHA_SEL_ARG2              (0x40000000)
+#    define MGA_TDS_ALPHA_SEL_ADD               (0x80000000)
+#    define MGA_TDS_ALPHA_SEL_MUL               (0xc0000000)
+
 #define MGAREG_DWGSYNC		0x2c4c
 
 #define MGAREG_AGP_PLL		0x1e4c
diff --git a/src/mga_storm.c b/src/mga_storm.c
index 88e8fe0..7fb66c9 100644
--- a/src/mga_storm.c
+++ b/src/mga_storm.c
@@ -304,6 +304,7 @@ Bool MGASetupForCPUToScreenAlphaTextureFaked( ScrnInfoPtr pScrn, int op,
 					      int height, int flags )
 {
     int log2w, log2h, pitch, sizeNeeded, offset;
+    unsigned int texctl, dwgctl, alphactrl;
     MGAPtr pMga = MGAPTR(pScrn);
 
     if(op != PictOpOver)  /* only one tested */
@@ -358,11 +359,19 @@ Bool MGASetupForCPUToScreenAlphaTextureFaked( ScrnInfoPtr pScrn, int op,
                                 ((width - 1) << 18));
     OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
                                 ((height - 1) << 18));
-    OUTREG(MGAREG_TEXCTL, 0x1A000106 | ((pitch & 0x07FF) << 9));
-    OUTREG(MGAREG_TEXCTL2, 0x00000014);
-    OUTREG(MGAREG_DWGCTL, 0x000c7076);
-    OUTREG(MGAREG_TEXFILTER, 0x01e00020);
-    OUTREG(MGAREG_ALPHACTRL, 0x00000154);
+
+    texctl = MGA_TW32 | MGA_PITCHLIN | MGA_TAKEY | MGA_CLAMPUV |
+             ((pitch & 0x07FF) << 9);
+    dwgctl = MGADWG_TEXTURE_TRAP | MGADWG_I | MGADWG_ARZERO |
+             MGADWG_SGNZERO | MGADWG_SHIFTZERO | 0xc0000;
+    alphactrl = MGA_SRC_ALPHA | MGA_DST_ONE_MINUS_SRC_ALPHA |
+                MGA_ALPHACHANNEL;
+
+    OUTREG(MGAREG_TEXCTL, texctl);
+    OUTREG(MGAREG_TEXCTL2, MGA_TC2_DECALDIS | MGA_TC2_CKSTRANSDIS);
+    OUTREG(MGAREG_DWGCTL, dwgctl);
+    OUTREG(MGAREG_TEXFILTER, ((0x1e << 20) | MGA_MAG_BILIN));
+    OUTREG(MGAREG_ALPHACTRL, alphactrl);
 
     return TRUE;
 }
@@ -383,6 +392,7 @@ MGASetupForCPUToScreenAlphaTexture (
    int		flags
 ){
     int log2w, log2h, i, pitch, sizeNeeded, offset;
+    unsigned int texctl, dwgctl, alphactrl;
     CARD8 *dst;
     MGAPtr pMga = MGAPTR(pScrn);
 
@@ -456,11 +466,20 @@ MGASetupForCPUToScreenAlphaTexture (
                                 ((width - 1) << 18));
     OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
                                 ((height - 1) << 18));
-    OUTREG(MGAREG_TEXCTL, 0x3A000107 | ((pitch & 0x07FF) << 9));
-    OUTREG(MGAREG_TEXCTL2, 0x00000014);
-    OUTREG(MGAREG_DWGCTL, 0x000c7076);
-    OUTREG(MGAREG_TEXFILTER, 0x01e00020);
-    OUTREG(MGAREG_ALPHACTRL, 0x02000151);
+
+    texctl = MGA_TW8A | MGA_PITCHLIN | MGA_TAKEY | MGA_CLAMPUV |
+             MGA_TEXMODULATE |
+             ((pitch & 0x07FF) << 9);
+    dwgctl = MGADWG_TEXTURE_TRAP | MGADWG_I | MGADWG_ARZERO |
+             MGADWG_SGNZERO | MGADWG_SHIFTZERO | 0xc0000;
+    alphactrl = MGA_SRC_ONE | MGA_DST_ONE_MINUS_SRC_ALPHA |
+                MGA_ALPHACHANNEL | MGA_MODULATEDALPHA;
+
+    OUTREG(MGAREG_TEXCTL, texctl);
+    OUTREG(MGAREG_TEXCTL2, MGA_TC2_DECALDIS | MGA_TC2_CKSTRANSDIS);
+    OUTREG(MGAREG_DWGCTL, dwgctl);
+    OUTREG(MGAREG_TEXFILTER, ((0x1e << 20) | MGA_MAG_BILIN));
+    OUTREG(MGAREG_ALPHACTRL, alphactrl);
 
     return TRUE;
 }
@@ -478,6 +497,7 @@ MGASetupForCPUToScreenTexture (
    int		flags
 ){
     int log2w, log2h, i, pitch, sizeNeeded, offset;
+    unsigned int texctl, dwgctl, alphactrl;
     MGAPtr pMga = MGAPTR(pScrn);
 
     if(op != PictOpOver)  /* only one tested */
@@ -537,11 +557,19 @@ MGASetupForCPUToScreenTexture (
                                 ((width - 1) << 18));
     OUTREG(MGAREG_TEXHEIGHT, log2h | (((8 - log2h) & 63) << 9) |
                                 ((height - 1) << 18));
-    OUTREG(MGAREG_TEXCTL, 0x1A000106 | ((pitch & 0x07FF) << 9));
-    OUTREG(MGAREG_TEXCTL2, 0x00000014);
-    OUTREG(MGAREG_DWGCTL, 0x000c7076);
-    OUTREG(MGAREG_TEXFILTER, 0x01e00020);
-    OUTREG(MGAREG_ALPHACTRL, 0x00000151);
+
+    texctl = MGA_TW32 | MGA_PITCHLIN | MGA_TAKEY | MGA_CLAMPUV |
+             ((pitch & 0x07FF) << 9);
+    dwgctl = MGADWG_TEXTURE_TRAP | MGADWG_I | MGADWG_ARZERO |
+             MGADWG_SGNZERO | MGADWG_SHIFTZERO | 0xc0000;
+    alphactrl = MGA_SRC_ONE | MGA_DST_ONE_MINUS_SRC_ALPHA |
+                MGA_ALPHACHANNEL;
+
+    OUTREG(MGAREG_TEXCTL, texctl);
+    OUTREG(MGAREG_TEXCTL2, MGA_TC2_DECALDIS | MGA_TC2_CKSTRANSDIS);
+    OUTREG(MGAREG_DWGCTL, dwgctl);
+    OUTREG(MGAREG_TEXFILTER, ((0x1e << 20) | MGA_MAG_BILIN));
+    OUTREG(MGAREG_ALPHACTRL, alphactrl);
 
     return TRUE;
 }
diff --git a/src/mga_video.c b/src/mga_video.c
index 1f0e87d..30ae6fc 100644
--- a/src/mga_video.c
+++ b/src/mga_video.c
@@ -19,7 +19,12 @@
 #include "xf86xv.h"
 #include <X11/extensions/Xv.h>
 #include "xaa.h"
+
+#ifdef USE_XAA
+#include "xaa.h"
 #include "xaalocal.h"
+#endif
+
 #include "dixstruct.h"
 #include "fourcc.h"
 
@@ -52,7 +57,7 @@ static int  MGAPutImage(ScrnInfoPtr, short, short, short, short, short,
 			short, Bool, RegionPtr, pointer, DrawablePtr);
 static int  MGAQueryImageAttributes(ScrnInfoPtr, int, unsigned short *, 
 			unsigned short *,  int *, int *);
-
+static void MGAFreeMemory(ScrnInfoPtr pScrn, void *mem_struct);
 
 static void MGAResetVideoOverlay(ScrnInfoPtr);
 
@@ -63,6 +68,19 @@ static void MGAVideoTimerCallback(ScrnInfoPtr pScrn, Time time);
 
 static Atom xvBrightness, xvContrast, xvColorKey, xvDoubleBuffer;
 
+#ifdef USE_EXA
+static void
+MGAVideoSave(ScreenPtr pScreen, ExaOffscreenArea *area)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+    MGAPtr pMga = MGAPTR(pScrn);
+    MGAPortPrivPtr pPriv = pMga->portPrivate;
+
+    if (pPriv->video_memory == area)
+        pPriv->video_memory = NULL;
+}
+#endif /* USE_EXA */
+
 void MGAInitVideo(ScreenPtr pScreen)
 {
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
@@ -331,9 +349,9 @@ MGAStopVideo(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
   if(shutdown) {
      if(pPriv->videoStatus & CLIENT_VIDEO_ON)
 	OUTREG(MGAREG_BESCTL, 0);
-     if(pPriv->linear) {
-	xf86FreeOffscreenLinear(pPriv->linear);
-	pPriv->linear = NULL;
+     if (pPriv->video_memory) {
+         MGAFreeMemory(pScrn, pPriv->video_memory);
+         pPriv->video_memory = NULL;
      }
      pPriv->videoStatus = 0;
   } else {
@@ -527,45 +545,109 @@ MGACopyMungedData(
 }
 
 
-static FBLinearPtr
+static CARD32
 MGAAllocateMemory(
    ScrnInfoPtr pScrn,
-   FBLinearPtr linear,
+   void **mem_struct,
    int size
 ){
-   ScreenPtr pScreen;
-   FBLinearPtr new_linear;
+   MGAPtr pMga = MGAPTR(pScrn);
+   ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];
+   int offset = 0;
+
+#ifdef USE_EXA
+   if (pMga->Exa) {
+       ExaOffscreenArea *area = *mem_struct;
+
+	if (area) {
+	    if (area->size >= size)
+		return area->offset;
 
-   if(linear) {
-	if(linear->size >= size) 
-	   return linear;
-        
-        if(xf86ResizeOffscreenLinear(linear, size))
-	   return linear;
+	    exaOffscreenFree(pScrn->pScreen, area);
+	}
+
+	area = exaOffscreenAlloc(pScrn->pScreen, size, 64, TRUE, MGAVideoSave,
+				 NULL);
+	*mem_struct = area;
+
+	if (!area)
+	    return 0;
 
-	xf86FreeOffscreenLinear(linear);
+	offset = area->offset;
    }
+#endif /* USE_EXA */
+#ifdef USE_XAA
+   FBLinearPtr linear = *mem_struct;
+   int cpp = pMga->CurrentLayout.bitsPerPixel / 8;
+
+   /* XAA allocates in units of pixels at the screen bpp, so adjust size
+    * appropriately.
+    */
+   size = (size + cpp - 1) / cpp;
+
+   if (!pMga->Exa) {
+       if (linear) {
+           if (linear->size >= size)
+               return linear->offset * cpp;
 
-   pScreen = screenInfo.screens[pScrn->scrnIndex];
+           if (xf86ResizeOffscreenLinear(linear, size))
+               return linear->offset * cpp;
 
-   new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16, 
-   						NULL, NULL, NULL);
+           xf86FreeOffscreenLinear(linear);
+       }
 
-   if(!new_linear) {
-	int max_size;
 
-	xf86QueryLargestOffscreenLinear(pScreen, &max_size, 16, 
-						PRIORITY_EXTREME);
-	
-	if(max_size < size)
-	   return NULL;
+       linear = xf86AllocateOffscreenLinear(pScreen, size, 16,
+                                            NULL, NULL, NULL);
+       *mem_struct = linear;
 
-	xf86PurgeUnlockedOffscreenAreas(pScreen);
-	new_linear = xf86AllocateOffscreenLinear(pScreen, size, 16, 
-						NULL, NULL, NULL);
+       if (!linear) {
+           int max_size;
+
+           xf86QueryLargestOffscreenLinear(pScreen, &max_size, 16,
+                                           PRIORITY_EXTREME);
+
+           if (max_size < size)
+               return 0;
+
+           xf86PurgeUnlockedOffscreenAreas(pScreen);
+
+           linear = xf86AllocateOffscreenLinear(pScreen, size, 16,
+                                                NULL, NULL, NULL);
+           *mem_struct = linear;
+
+           if (!linear)
+               return 0;
+       }
+
+       offset = linear->offset * cpp;
    }
+#endif /* USE_XAA */
 
-   return new_linear;
+   return offset;
+}
+
+static void
+MGAFreeMemory(ScrnInfoPtr pScrn, void *mem_struct)
+{
+    MGAPtr pMga = MGAPTR(pScrn);
+
+#ifdef USE_EXA
+    if (pMga->Exa) {
+	ExaOffscreenArea *area = mem_struct;
+
+	if (area)
+	    exaOffscreenFree(pScrn->pScreen, area);
+    }
+#endif /* USE_EXA */
+#ifdef USE_XAA
+    if (!pMga->Exa) {
+	FBLinearPtr linear = mem_struct;
+
+	if (linear)
+	    xf86FreeOffscreenLinear(linear);
+    }
+#endif /* USE_XAA */
 }
 
 static void
@@ -740,7 +822,7 @@ MGADisplayVideoTexture(
 	pbox++;
     }
 
-    pMga->AccelInfoRec->NeedToSync = TRUE;
+    MGA_MARK_SYNC(pMga, pScrn);
 }
 
 static int 
@@ -762,7 +844,7 @@ MGAPutImage(
    unsigned char *dst_start;
    int new_size, offset, offset2 = 0, offset3 = 0;
    int srcPitch, srcPitch2 = 0, dstPitch;
-   int top, left, npixels, nlines, bpp;
+   int top, left, npixels, nlines;
    BoxRec dstBox;
    CARD32 tmp;
 
@@ -788,10 +870,8 @@ MGAPutImage(
 	dstBox.y2 -= pScrn->frameY0;
    }
 
-   bpp = pScrn->bitsPerPixel >> 3;
-
    dstPitch = ((width << 1) + 15) & ~15;
-   new_size = ((dstPitch * height) + bpp - 1) / bpp;
+   new_size = dstPitch * height;
    
    switch(id) {
    case FOURCC_YV12:
@@ -808,11 +888,12 @@ MGAPutImage(
 	break;
    }  
 
-   if(!(pPriv->linear = MGAAllocateMemory(pScrn, pPriv->linear, 
-						pPriv->doubleBuffer ? (new_size << 1) : new_size)))
-   {
+   pPriv->video_offset = MGAAllocateMemory(pScrn, &pPriv->video_memory,
+					   pPriv->doubleBuffer ?
+                                           (new_size << 1) : new_size);
+   if (!pPriv->video_offset)
 	return BadAlloc;
-   }
+
    pPriv->currentBuffer ^= 1;
 
     /* copy data */
@@ -821,16 +902,13 @@ MGAPutImage(
    npixels = ((((x2 + 0xffff) >> 16) + 1) & ~1) - left;
    left <<= 1;
 
-   offset = pPriv->linear->offset * bpp;
+   offset = pPriv->video_offset;
    if(pPriv->doubleBuffer)
-        offset += pPriv->currentBuffer * new_size * bpp;
+        offset += pPriv->currentBuffer * new_size;
    dst_start = pMga->FbStart + offset + left + (top * dstPitch);
 
-   if(pMga->TexturedVideo && pMga->AccelInfoRec->NeedToSync &&
-	((long)data != pPriv->lastPort)) 
-   {
-	MGAStormSync(pScrn);
-   }
+   if (pMga->TexturedVideo && ((long)data != pPriv->lastPort))
+       MGA_SYNC(pMga, pScrn);
 
    switch(id) {
     case FOURCC_YV12:
@@ -949,9 +1027,9 @@ MGAVideoTimerCallback(ScrnInfoPtr pScrn, Time time)
 	    }
 	} else {  /* FREE_TIMER */
 	    if(pPriv->freeTime < time) {
-		if(pPriv->linear) {
-		   xf86FreeOffscreenLinear(pPriv->linear);
-		   pPriv->linear = NULL;
+		if (pPriv->video_memory) {
+                   MGAFreeMemory(pScrn, pPriv->video_memory);
+		   pPriv->video_memory = NULL;
 		}
 		pPriv->videoStatus = 0;
 	        pMga->VideoTimerCallback = NULL;
@@ -965,7 +1043,7 @@ MGAVideoTimerCallback(ScrnInfoPtr pScrn, Time time)
 /****************** Offscreen stuff ***************/
 
 typedef struct {
-  FBLinearPtr linear;
+  void *surface_memory;
   Bool isOn;
 } OffscreenPrivRec, * OffscreenPrivPtr;
 
@@ -977,8 +1055,8 @@ MGAAllocateSurface(
     unsigned short h,
     XF86SurfacePtr surface
 ){
-    FBLinearPtr linear;
-    int pitch, size, bpp;
+    void *surface_memory = NULL;
+    int pitch, size, bpp, offset;
     OffscreenPrivPtr pPriv;
 
     if((w > 1024) || (h > 1024))
@@ -989,35 +1067,36 @@ MGAAllocateSurface(
     bpp = pScrn->bitsPerPixel >> 3;
     size = ((pitch * h) + bpp - 1) / bpp;
 
-    if(!(linear = MGAAllocateMemory(pScrn, NULL, size)))
+    offset = MGAAllocateMemory(pScrn, &surface_memory, size);
+    if (!offset)
 	return BadAlloc;
 
     surface->width = w;
     surface->height = h;
 
     if(!(surface->pitches = xalloc(sizeof(int)))) {
-	xf86FreeOffscreenLinear(linear);
+        MGAFreeMemory(pScrn, surface_memory);
 	return BadAlloc;
     }
     if(!(surface->offsets = xalloc(sizeof(int)))) {
 	xfree(surface->pitches);
-	xf86FreeOffscreenLinear(linear);
+        MGAFreeMemory(pScrn, surface_memory);
 	return BadAlloc;
     }
     if(!(pPriv = xalloc(sizeof(OffscreenPrivRec)))) {
 	xfree(surface->pitches);
 	xfree(surface->offsets);
-	xf86FreeOffscreenLinear(linear);
+        MGAFreeMemory(pScrn, surface_memory);
 	return BadAlloc;
     }
 
-    pPriv->linear = linear;
+    pPriv->surface_memory = surface_memory;
     pPriv->isOn = FALSE;
 
     surface->pScrn = pScrn;
     surface->id = id;   
     surface->pitches[0] = pitch;
-    surface->offsets[0] = linear->offset * bpp;
+    surface->offsets[0] = offset;
     surface->devPrivate.ptr = (pointer)pPriv;
 
     return Success;
@@ -1044,11 +1123,12 @@ static int
 MGAFreeSurface(
     XF86SurfacePtr surface
 ){
+    ScrnInfoPtr pScrn = surface->pScrn;
     OffscreenPrivPtr pPriv = (OffscreenPrivPtr)surface->devPrivate.ptr;
 
     if(pPriv->isOn)
 	MGAStopSurface(surface);
-    xf86FreeOffscreenLinear(pPriv->linear);
+    MGAFreeMemory(pScrn, pPriv->surface_memory);
     xfree(surface->pitches);
     xfree(surface->offsets);
     xfree(surface->devPrivate.ptr);
diff --git a/util/Makefile.am b/util/Makefile.am
index 8f64bcf..734c7b3 100644
--- a/util/Makefile.am
+++ b/util/Makefile.am
@@ -1,7 +1,7 @@
 # $XFree86: $
 
 # this is not even built in the monolith, so don't install it
-bin_PROGRAMS = stormdwg
+noinst_PROGRAMS = stormdwg
 
 stormdwg_SOURCES = stormdwg.c