xserver mesa git update 10 Mar 2011

6 files changed, 999 insertions, 999 deletions

diff --git a/xorg-server/exa/exa.h b/xorg-server/exa/exa.h
index 8c93d156f..6de63008e 100644
--- a/xorg-server/exa/exa.h
+++ b/xorg-server/exa/exa.h
@@ -712,7 +712,7 @@ typedef struct _ExaDriver {
      * driver MUST fill out new_fb_pitch with valid pitch of pixmap
      */
     void *(*CreatePixmap2)(ScreenPtr pScreen, int width, int height,
-			   int depth, int usage_hint, int bitsPerPixel,
+			   int depth, int class, int bitsPerPixel,
 			   int *new_fb_pitch);
     /** @} */
 } ExaDriverRec, *ExaDriverPtr;
diff --git a/xorg-server/exa/exa_classic.c b/xorg-server/exa/exa_classic.c
index 1a1467848..640b26a12 100644
--- a/xorg-server/exa/exa_classic.c
+++ b/xorg-server/exa/exa_classic.c
@@ -1,266 +1,266 @@
-/*

- * Copyright © 2009 Maarten Maathuis

- *

- * 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, sublicense,

- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

- * THE AUTHORS OR COPYRIGHT HOLDERS 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 HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <string.h>

-

-#include "exa_priv.h"

-#include "exa.h"

-

-/* This file holds the classic exa specific implementation. */

-

-static _X_INLINE void*

-ExaGetPixmapAddress(PixmapPtr p)

-{

-    ExaPixmapPriv(p);

-

-    if (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr)

-	return pExaPixmap->fb_ptr;

-    else

-	return pExaPixmap->sys_ptr;

-}

-

-/**

- * exaCreatePixmap() creates a new pixmap.

- *

- * If width and height are 0, this won't be a full-fledged pixmap and it will

- * get ModifyPixmapHeader() called on it later.  So, we mark it as pinned, because

- * ModifyPixmapHeader() would break migration.  These types of pixmaps are used

- * for scratch pixmaps, or to represent the visible screen.

- */

-PixmapPtr

-exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,

-		unsigned usage_hint)

-{

-    PixmapPtr pPixmap;

-    ExaPixmapPrivPtr	pExaPixmap;

-    BoxRec box;

-    int bpp;

-    ExaScreenPriv(pScreen);

-

-    if (w > 32767 || h > 32767)

-	return NullPixmap;

-

-    swap(pExaScr, pScreen, CreatePixmap);

-    pPixmap = pScreen->CreatePixmap (pScreen, w, h, depth, usage_hint);

-    swap(pExaScr, pScreen, CreatePixmap);

-

-    if (!pPixmap)

-        return NULL;

-

-    pExaPixmap = ExaGetPixmapPriv(pPixmap);

-    pExaPixmap->driverPriv = NULL;

-

-    bpp = pPixmap->drawable.bitsPerPixel;

-

-    pExaPixmap->driverPriv = NULL;

-    /* Scratch pixmaps may have w/h equal to zero, and may not be

-     * migrated.

-     */

-    if (!w || !h)

-	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;

-    else

-	pExaPixmap->score = EXA_PIXMAP_SCORE_INIT;

-

-    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;

-    pExaPixmap->sys_pitch = pPixmap->devKind;

-

-    pPixmap->devPrivate.ptr = NULL;

-    pExaPixmap->use_gpu_copy = FALSE;

-

-    pExaPixmap->fb_ptr = NULL;

-    exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);

-    pExaPixmap->fb_size = pExaPixmap->fb_pitch * h;

-

-    if (pExaPixmap->fb_pitch > 131071) {

-	swap(pExaScr, pScreen, DestroyPixmap);

-	pScreen->DestroyPixmap (pPixmap);

-	swap(pExaScr, pScreen, DestroyPixmap);

-	return NULL;

-    }

-

-    /* Set up damage tracking */

-    pExaPixmap->pDamage = DamageCreate (NULL, NULL,

-					DamageReportNone, TRUE,

-					pScreen, pPixmap);

-

-    if (pExaPixmap->pDamage == NULL) {

-	swap(pExaScr, pScreen, DestroyPixmap);

-	pScreen->DestroyPixmap (pPixmap);

-	swap(pExaScr, pScreen, DestroyPixmap);

-	return NULL;

-    }

-

-    DamageRegister (&pPixmap->drawable, pExaPixmap->pDamage);

-    /* This ensures that pending damage reflects the current operation. */

-    /* This is used by exa to optimize migration. */

-    DamageSetReportAfterOp (pExaPixmap->pDamage, TRUE);

-

-    pExaPixmap->area = NULL;

-

-    /* We set the initial pixmap as completely valid for a simple reason.

-     * Imagine a 1000x1000 pixmap, it has 1 million pixels, 250000 of which

-     * could form single pixel rects as part of a region. Setting the complete region

-     * as valid is a natural defragmentation of the region.

-     */

-    box.x1 = 0;

-    box.y1 = 0;

-    box.x2 = w;

-    box.y2 = h;

-    RegionInit(&pExaPixmap->validSys, &box, 0);

-    RegionInit(&pExaPixmap->validFB, &box, 0);

-

-    exaSetAccelBlock(pExaScr, pExaPixmap,

-                     w, h, bpp);

-

-    /* During a fallback we must prepare access. */

-    if (pExaScr->fallback_counter)

-	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);

-

-    return pPixmap;

-}

-

-Bool

-exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,

-		      int bitsPerPixel, int devKind, pointer pPixData)

-{

-    ScreenPtr pScreen;

-    ExaScreenPrivPtr pExaScr;

-    ExaPixmapPrivPtr pExaPixmap;

-    Bool ret;

-

-    if (!pPixmap)

-        return FALSE;

-

-    pScreen = pPixmap->drawable.pScreen;

-    pExaScr = ExaGetScreenPriv(pScreen);

-    pExaPixmap = ExaGetPixmapPriv(pPixmap);

-

-    if (pExaPixmap) {

-        if (pPixData)

-            pExaPixmap->sys_ptr = pPixData;

-

-        if (devKind > 0)

-            pExaPixmap->sys_pitch = devKind;

-

-	/* Classic EXA:

-	 * - Framebuffer.

-	 * - Scratch pixmap with gpu memory.

-	 */

-	if (pExaScr->info->memoryBase && pPixData) {

-	    if ((CARD8 *)pPixData >= pExaScr->info->memoryBase &&

-		((CARD8 *)pPixData - pExaScr->info->memoryBase) <

-				pExaScr->info->memorySize) {

-		pExaPixmap->fb_ptr = pPixData;

-		pExaPixmap->fb_pitch = devKind;

-		pExaPixmap->use_gpu_copy = TRUE;

-	    }

-	}

-

-        if (width > 0 && height > 0 && bitsPerPixel > 0) {

-            exaSetFbPitch(pExaScr, pExaPixmap,

-                          width, height, bitsPerPixel);

-

-            exaSetAccelBlock(pExaScr, pExaPixmap,

-                             width, height, bitsPerPixel);

-        }

-

-	/* Pixmaps subject to ModifyPixmapHeader will be pinned to system or

-	 * gpu memory, so there's no need to track damage.

-	 */

-	if (pExaPixmap->pDamage) {

-	    DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);

-	    DamageDestroy(pExaPixmap->pDamage);

-	    pExaPixmap->pDamage = NULL;

-	}

-    }

-

-    swap(pExaScr, pScreen, ModifyPixmapHeader);

-    ret = pScreen->ModifyPixmapHeader(pPixmap, width, height, depth,

-					    bitsPerPixel, devKind, pPixData);

-    swap(pExaScr, pScreen, ModifyPixmapHeader);

-

-    /* Always NULL this, we don't want lingering pointers. */

-    pPixmap->devPrivate.ptr = NULL;

-

-    return ret;

-}

-

-Bool

-exaDestroyPixmap_classic (PixmapPtr pPixmap)

-{

-    ScreenPtr	pScreen = pPixmap->drawable.pScreen;

-    ExaScreenPriv(pScreen);

-    Bool ret;

-

-    if (pPixmap->refcnt == 1)

-    {

-	ExaPixmapPriv (pPixmap);

-

-	exaDestroyPixmap(pPixmap);

-

-	if (pExaPixmap->area)

-	{

-	    DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n",

-                        (void*)pPixmap->drawable.id,

-			 ExaGetPixmapPriv(pPixmap)->area->offset,

-			 pPixmap->drawable.width,

-			 pPixmap->drawable.height));

-	    /* Free the offscreen area */

-	    exaOffscreenFree (pPixmap->drawable.pScreen, pExaPixmap->area);

-	    pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;

-	    pPixmap->devKind = pExaPixmap->sys_pitch;

-	}

-	RegionUninit(&pExaPixmap->validSys);

-	RegionUninit(&pExaPixmap->validFB);

-    }

-

-    swap(pExaScr, pScreen, DestroyPixmap);

-    ret = pScreen->DestroyPixmap (pPixmap);

-    swap(pExaScr, pScreen, DestroyPixmap);

-

-    return ret;

-}

-

-Bool

-exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap)

-{

-    ScreenPtr pScreen = pPixmap->drawable.pScreen;

-    ExaScreenPriv(pScreen);

-    ExaPixmapPriv(pPixmap);

-    Bool ret;

-

-    if (pExaScr->info->PixmapIsOffscreen) {

-	void* old_ptr = pPixmap->devPrivate.ptr;

-	pPixmap->devPrivate.ptr = ExaGetPixmapAddress(pPixmap);

-	ret = pExaScr->info->PixmapIsOffscreen(pPixmap);

-	pPixmap->devPrivate.ptr = old_ptr;

-    } else

-	ret = (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr);

-

-    return ret;

-}

+/*
+ * Copyright © 2009 Maarten Maathuis
+ *
+ * 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, sublicense,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <string.h>
+
+#include "exa_priv.h"
+#include "exa.h"
+
+/* This file holds the classic exa specific implementation. */
+
+static _X_INLINE void*
+ExaGetPixmapAddress(PixmapPtr p)
+{
+    ExaPixmapPriv(p);
+
+    if (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr)
+	return pExaPixmap->fb_ptr;
+    else
+	return pExaPixmap->sys_ptr;
+}
+
+/**
+ * exaCreatePixmap() creates a new pixmap.
+ *
+ * If width and height are 0, this won't be a full-fledged pixmap and it will
+ * get ModifyPixmapHeader() called on it later.  So, we mark it as pinned, because
+ * ModifyPixmapHeader() would break migration.  These types of pixmaps are used
+ * for scratch pixmaps, or to represent the visible screen.
+ */
+PixmapPtr
+exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
+		unsigned class)
+{
+    PixmapPtr pPixmap;
+    ExaPixmapPrivPtr	pExaPixmap;
+    BoxRec box;
+    int bpp;
+    ExaScreenPriv(pScreen);
+
+    if (w > 32767 || h > 32767)
+	return NullPixmap;
+
+    swap(pExaScr, pScreen, CreatePixmap);
+    pPixmap = pScreen->CreatePixmap (pScreen, w, h, depth, class);
+    swap(pExaScr, pScreen, CreatePixmap);
+
+    if (!pPixmap)
+        return NULL;
+
+    pExaPixmap = ExaGetPixmapPriv(pPixmap);
+    pExaPixmap->driverPriv = NULL;
+
+    bpp = pPixmap->drawable.bitsPerPixel;
+
+    pExaPixmap->driverPriv = NULL;
+    /* Scratch pixmaps may have w/h equal to zero, and may not be
+     * migrated.
+     */
+    if (!w || !h)
+	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
+    else
+	pExaPixmap->score = EXA_PIXMAP_SCORE_INIT;
+
+    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
+    pExaPixmap->sys_pitch = pPixmap->devKind;
+
+    pPixmap->devPrivate.ptr = NULL;
+    pExaPixmap->use_gpu_copy = FALSE;
+
+    pExaPixmap->fb_ptr = NULL;
+    exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
+    pExaPixmap->fb_size = pExaPixmap->fb_pitch * h;
+
+    if (pExaPixmap->fb_pitch > 131071) {
+	swap(pExaScr, pScreen, DestroyPixmap);
+	pScreen->DestroyPixmap (pPixmap);
+	swap(pExaScr, pScreen, DestroyPixmap);
+	return NULL;
+    }
+
+    /* Set up damage tracking */
+    pExaPixmap->pDamage = DamageCreate (NULL, NULL,
+					DamageReportNone, TRUE,
+					pScreen, pPixmap);
+
+    if (pExaPixmap->pDamage == NULL) {
+	swap(pExaScr, pScreen, DestroyPixmap);
+	pScreen->DestroyPixmap (pPixmap);
+	swap(pExaScr, pScreen, DestroyPixmap);
+	return NULL;
+    }
+
+    DamageRegister (&pPixmap->drawable, pExaPixmap->pDamage);
+    /* This ensures that pending damage reflects the current operation. */
+    /* This is used by exa to optimize migration. */
+    DamageSetReportAfterOp (pExaPixmap->pDamage, TRUE);
+
+    pExaPixmap->area = NULL;
+
+    /* We set the initial pixmap as completely valid for a simple reason.
+     * Imagine a 1000x1000 pixmap, it has 1 million pixels, 250000 of which
+     * could form single pixel rects as part of a region. Setting the complete region
+     * as valid is a natural defragmentation of the region.
+     */
+    box.x1 = 0;
+    box.y1 = 0;
+    box.x2 = w;
+    box.y2 = h;
+    RegionInit(&pExaPixmap->validSys, &box, 0);
+    RegionInit(&pExaPixmap->validFB, &box, 0);
+
+    exaSetAccelBlock(pExaScr, pExaPixmap,
+                     w, h, bpp);
+
+    /* During a fallback we must prepare access. */
+    if (pExaScr->fallback_counter)
+	exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
+
+    return pPixmap;
+}
+
+Bool
+exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,
+		      int bitsPerPixel, int devKind, pointer pPixData)
+{
+    ScreenPtr pScreen;
+    ExaScreenPrivPtr pExaScr;
+    ExaPixmapPrivPtr pExaPixmap;
+    Bool ret;
+
+    if (!pPixmap)
+        return FALSE;
+
+    pScreen = pPixmap->drawable.pScreen;
+    pExaScr = ExaGetScreenPriv(pScreen);
+    pExaPixmap = ExaGetPixmapPriv(pPixmap);
+
+    if (pExaPixmap) {
+        if (pPixData)
+            pExaPixmap->sys_ptr = pPixData;
+
+        if (devKind > 0)
+            pExaPixmap->sys_pitch = devKind;
+
+	/* Classic EXA:
+	 * - Framebuffer.
+	 * - Scratch pixmap with gpu memory.
+	 */
+	if (pExaScr->info->memoryBase && pPixData) {
+	    if ((CARD8 *)pPixData >= pExaScr->info->memoryBase &&
+		((CARD8 *)pPixData - pExaScr->info->memoryBase) <
+				pExaScr->info->memorySize) {
+		pExaPixmap->fb_ptr = pPixData;
+		pExaPixmap->fb_pitch = devKind;
+		pExaPixmap->use_gpu_copy = TRUE;
+	    }
+	}
+
+        if (width > 0 && height > 0 && bitsPerPixel > 0) {
+            exaSetFbPitch(pExaScr, pExaPixmap,
+                          width, height, bitsPerPixel);
+
+            exaSetAccelBlock(pExaScr, pExaPixmap,
+                             width, height, bitsPerPixel);
+        }
+
+	/* Pixmaps subject to ModifyPixmapHeader will be pinned to system or
+	 * gpu memory, so there's no need to track damage.
+	 */
+	if (pExaPixmap->pDamage) {
+	    DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
+	    DamageDestroy(pExaPixmap->pDamage);
+	    pExaPixmap->pDamage = NULL;
+	}
+    }
+
+    swap(pExaScr, pScreen, ModifyPixmapHeader);
+    ret = pScreen->ModifyPixmapHeader(pPixmap, width, height, depth,
+					    bitsPerPixel, devKind, pPixData);
+    swap(pExaScr, pScreen, ModifyPixmapHeader);
+
+    /* Always NULL this, we don't want lingering pointers. */
+    pPixmap->devPrivate.ptr = NULL;
+
+    return ret;
+}
+
+Bool
+exaDestroyPixmap_classic (PixmapPtr pPixmap)
+{
+    ScreenPtr	pScreen = pPixmap->drawable.pScreen;
+    ExaScreenPriv(pScreen);
+    Bool ret;
+
+    if (pPixmap->refcnt == 1)
+    {
+	ExaPixmapPriv (pPixmap);
+
+	exaDestroyPixmap(pPixmap);
+
+	if (pExaPixmap->area)
+	{
+	    DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n",
+                        (void*)pPixmap->drawable.id,
+			 ExaGetPixmapPriv(pPixmap)->area->offset,
+			 pPixmap->drawable.width,
+			 pPixmap->drawable.height));
+	    /* Free the offscreen area */
+	    exaOffscreenFree (pPixmap->drawable.pScreen, pExaPixmap->area);
+	    pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
+	    pPixmap->devKind = pExaPixmap->sys_pitch;
+	}
+	RegionUninit(&pExaPixmap->validSys);
+	RegionUninit(&pExaPixmap->validFB);
+    }
+
+    swap(pExaScr, pScreen, DestroyPixmap);
+    ret = pScreen->DestroyPixmap (pPixmap);
+    swap(pExaScr, pScreen, DestroyPixmap);
+
+    return ret;
+}
+
+Bool
+exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap)
+{
+    ScreenPtr pScreen = pPixmap->drawable.pScreen;
+    ExaScreenPriv(pScreen);
+    ExaPixmapPriv(pPixmap);
+    Bool ret;
+
+    if (pExaScr->info->PixmapIsOffscreen) {
+	void* old_ptr = pPixmap->devPrivate.ptr;
+	pPixmap->devPrivate.ptr = ExaGetPixmapAddress(pPixmap);
+	ret = pExaScr->info->PixmapIsOffscreen(pPixmap);
+	pPixmap->devPrivate.ptr = old_ptr;
+    } else
+	ret = (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr);
+
+    return ret;
+}
diff --git a/xorg-server/exa/exa_driver.c b/xorg-server/exa/exa_driver.c
index b9903d1bc..4d2a1a5df 100644
--- a/xorg-server/exa/exa_driver.c
+++ b/xorg-server/exa/exa_driver.c
@@ -48,7 +48,7 @@ ExaGetPixmapAddress(PixmapPtr p)
  */
 PixmapPtr
 exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint)
+		unsigned class)
 {
     PixmapPtr pPixmap;
     ExaPixmapPrivPtr	pExaPixmap;
@@ -60,7 +60,7 @@ exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
 	return NullPixmap;
 
     swap(pExaScr, pScreen, CreatePixmap);
-    pPixmap = pScreen->CreatePixmap(pScreen, 0, 0, depth, usage_hint);
+    pPixmap = pScreen->CreatePixmap(pScreen, 0, 0, depth, class);
     swap(pExaScr, pScreen, CreatePixmap);
 
     if (!pPixmap)
@@ -78,7 +78,7 @@ exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
 
     if (pExaScr->info->CreatePixmap2) {
 	int new_pitch = 0;
-	pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, usage_hint, bpp, &new_pitch);
+	pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, class, bpp, &new_pitch);
 	paddedWidth = pExaPixmap->fb_pitch = new_pitch;
     }
     else {
diff --git a/xorg-server/exa/exa_migration_mixed.c b/xorg-server/exa/exa_migration_mixed.c
index fb4715135..a563357be 100644
--- a/xorg-server/exa/exa_migration_mixed.c
+++ b/xorg-server/exa/exa_migration_mixed.c
@@ -39,7 +39,7 @@ exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
     ExaPixmapPriv(pPixmap);
     int w = pPixmap->drawable.width, h = pPixmap->drawable.height;
     int depth = pPixmap->drawable.depth, bpp = pPixmap->drawable.bitsPerPixel;
-    int usage_hint = pPixmap->usage_hint;
+    int class = pPixmap->drawable.class;
     int paddedWidth = pExaPixmap->sys_pitch;
 
     /* Already done. */
@@ -55,7 +55,7 @@ exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
 
     if (pExaScr->info->CreatePixmap2) {
 	int new_pitch = 0;
-        pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, usage_hint, bpp, &new_pitch);
+        pExaPixmap->driverPriv = pExaScr->info->CreatePixmap2(pScreen, w, h, depth, class, bpp, &new_pitch);
 	paddedWidth = pExaPixmap->fb_pitch = new_pitch;
     } else {
 	if (paddedWidth < pExaPixmap->fb_pitch)
diff --git a/xorg-server/exa/exa_mixed.c b/xorg-server/exa/exa_mixed.c
index fd1afb246..24fce7645 100644
--- a/xorg-server/exa/exa_mixed.c
+++ b/xorg-server/exa/exa_mixed.c
@@ -47,7 +47,7 @@ ExaGetPixmapAddress(PixmapPtr p)
  */
 PixmapPtr
 exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint)
+		unsigned class)
 {
     PixmapPtr pPixmap;
     ExaPixmapPrivPtr	pExaPixmap;
@@ -59,7 +59,7 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
 	return NullPixmap;
 
     swap(pExaScr, pScreen, CreatePixmap);
-    pPixmap = pScreen->CreatePixmap(pScreen, 0, 0, depth, usage_hint);
+    pPixmap = pScreen->CreatePixmap(pScreen, 0, 0, depth, class);
     swap(pExaScr, pScreen, CreatePixmap);
 
     if (!pPixmap)
diff --git a/xorg-server/exa/exa_priv.h b/xorg-server/exa/exa_priv.h
index 1b8cf294a..1f6dede94 100644
--- a/xorg-server/exa/exa_priv.h
+++ b/xorg-server/exa/exa_priv.h
@@ -1,725 +1,725 @@
-/*

- *

- * Copyright (C) 2000 Keith Packard, member of The XFree86 Project, Inc.

- *               2005 Zack Rusin, Trolltech

- *

- * Permission to use, copy, modify, distribute, and sell this software and its

- * documentation for any purpose is hereby granted without fee, provided that

- * the above copyright notice appear in all copies and that both that

- * copyright notice and this permission notice appear in supporting

- * documentation, and that the name of Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

- * representations about the suitability of this software for any purpose.  It

- * is provided "as is" without express or implied warranty.

- *

- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

- * SOFTWARE.

- */

-

-#ifndef EXAPRIV_H

-#define EXAPRIV_H

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include "exa.h"

-

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#ifdef MITSHM

-#include "shmint.h"

-#endif

-#include "scrnintstr.h"

-#include "pixmapstr.h"

-#include "windowstr.h"

-#include "servermd.h"

-#include "mibstore.h"

-#include "colormapst.h"

-#include "gcstruct.h"

-#include "input.h"

-#include "mipointer.h"

-#include "mi.h"

-#include "dix.h"

-#include "fb.h"

-#include "fboverlay.h"

-#include "fbpict.h"

-#include "glyphstr.h"

-#include "damage.h"

-

-#define DEBUG_TRACE_FALL	0

-#define DEBUG_MIGRATE		0

-#define DEBUG_PIXMAP		0

-#define DEBUG_OFFSCREEN		0

-#define DEBUG_GLYPH_CACHE	0

-

-#if DEBUG_TRACE_FALL

-#define EXA_FALLBACK(x)     					\

-do {								\

-	ErrorF("EXA fallback at %s: ", __FUNCTION__);		\

-	ErrorF x;						\

-} while (0)

-

-char

-exaDrawableLocation(DrawablePtr pDrawable);

-#else

-#define EXA_FALLBACK(x)

-#endif

-

-#if DEBUG_PIXMAP

-#define DBG_PIXMAP(a) ErrorF a

-#else

-#define DBG_PIXMAP(a)

-#endif

-

-#ifndef EXA_MAX_FB

-#define EXA_MAX_FB   FB_OVERLAY_MAX

-#endif

-

-#ifdef DEBUG

-#define EXA_FatalErrorDebug(x) FatalError x

-#define EXA_FatalErrorDebugWithRet(x, ret) FatalError x

-#else

-#define EXA_FatalErrorDebug(x) ErrorF x

-#define EXA_FatalErrorDebugWithRet(x, ret) \

-do { \

-    ErrorF x; \

-    return ret; \

-} while (0)

-#endif

-

-/**

- * This is the list of migration heuristics supported by EXA.  See

- * exaDoMigration() for what their implementations do.

- */

-enum ExaMigrationHeuristic {

-    ExaMigrationGreedy,

-    ExaMigrationAlways,

-    ExaMigrationSmart

-};

-

-typedef struct {

-    unsigned char sha1[20];

-} ExaCachedGlyphRec, *ExaCachedGlyphPtr;

-

-typedef struct {

-    /* The identity of the cache, statically configured at initialization */

-    unsigned int format;

-    int glyphWidth;

-    int glyphHeight;

-

-    int size; /* Size of cache; eventually this should be dynamically determined */

-

-    /* Hash table mapping from glyph sha1 to position in the glyph; we use

-     * open addressing with a hash table size determined based on size and large

-     * enough so that we always have a good amount of free space, so we can

-     * use linear probing. (Linear probing is preferrable to double hashing

-     * here because it allows us to easily remove entries.)

-     */

-    int *hashEntries;

-    int hashSize;

-    

-    ExaCachedGlyphPtr glyphs;

-    int glyphCount; /* Current number of glyphs */

-    

-    PicturePtr picture;   /* Where the glyphs of the cache are stored */

-    int yOffset;          /* y location within the picture where the cache starts */

-    int columns;          /* Number of columns the glyphs are layed out in */

-    int evictionPosition; /* Next random position to evict a glyph */

-} ExaGlyphCacheRec, *ExaGlyphCachePtr;

-

-#define EXA_NUM_GLYPH_CACHES 4

-

-#define EXA_FALLBACK_COPYWINDOW (1 << 0)

-#define EXA_ACCEL_COPYWINDOW (1 << 1)

-

-typedef struct _ExaMigrationRec {

-    Bool as_dst;

-    Bool as_src;

-    PixmapPtr pPix;

-    RegionPtr pReg;

-} ExaMigrationRec, *ExaMigrationPtr;

-

-typedef void (*EnableDisableFBAccessProcPtr)(int, Bool);

-typedef struct {

-    ExaDriverPtr info;

-    ScreenBlockHandlerProcPtr	 SavedBlockHandler;

-    ScreenWakeupHandlerProcPtr	 SavedWakeupHandler;

-    CreateGCProcPtr 		 SavedCreateGC;

-    CloseScreenProcPtr 		 SavedCloseScreen;

-    GetImageProcPtr 		 SavedGetImage;

-    GetSpansProcPtr 		 SavedGetSpans;

-    CreatePixmapProcPtr 	 SavedCreatePixmap;

-    DestroyPixmapProcPtr 	 SavedDestroyPixmap;

-    CopyWindowProcPtr 		 SavedCopyWindow;

-    ChangeWindowAttributesProcPtr SavedChangeWindowAttributes;

-    BitmapToRegionProcPtr        SavedBitmapToRegion;

-    CreateScreenResourcesProcPtr SavedCreateScreenResources;

-    ModifyPixmapHeaderProcPtr    SavedModifyPixmapHeader;

-    SourceValidateProcPtr        SavedSourceValidate;

-    CompositeProcPtr             SavedComposite;

-    TrianglesProcPtr		 SavedTriangles;

-    GlyphsProcPtr                SavedGlyphs;

-    TrapezoidsProcPtr            SavedTrapezoids;

-    AddTrapsProcPtr		 SavedAddTraps;

-    void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

-    Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);

-    void (*do_move_in_pixmap) (PixmapPtr pPixmap);

-    void (*do_move_out_pixmap) (PixmapPtr pPixmap);

-    void (*prepare_access_reg)(PixmapPtr pPixmap, int index, RegionPtr pReg);

-

-    Bool			 swappedOut;

-    enum ExaMigrationHeuristic	 migration;

-    Bool			 checkDirtyCorrectness;

-    unsigned			 disableFbCount;

-    Bool			 optimize_migration;

-    unsigned			 offScreenCounter;

-    unsigned			 numOffscreenAvailable;

-    CARD32			 lastDefragment;

-    CARD32			 nextDefragment;

-    PixmapPtr			 deferred_mixed_pixmap;

-

-    /* Reference counting for accessed pixmaps */

-    struct {

-	PixmapPtr pixmap;

-	int count;

-	Bool retval;

-    } access[EXA_NUM_PREPARE_INDICES];

-

-    /* Holds information on fallbacks that cannot be relayed otherwise. */

-    unsigned int fallback_flags;

-    unsigned int fallback_counter;

-

-    ExaGlyphCacheRec             glyphCaches[EXA_NUM_GLYPH_CACHES];

-

-    /**

-     * Regions affected by fallback composite source / mask operations.

-     */

-

-    RegionRec srcReg;

-    RegionRec maskReg;

-    PixmapPtr srcPix;

-

-} ExaScreenPrivRec, *ExaScreenPrivPtr;

-

-/*

- * This is the only completely portable way to

- * compute this info.

- */

-#ifndef BitsPerPixel

-#define BitsPerPixel(d) (\

-    PixmapWidthPaddingInfo[d].notPower2 ? \

-    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \

-    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \

-    (PixmapWidthPaddingInfo[d].padRoundUp+1)))

-#endif

-

-extern DevPrivateKeyRec exaScreenPrivateKeyRec;

-#define exaScreenPrivateKey (&exaScreenPrivateKeyRec)

-extern DevPrivateKeyRec exaPixmapPrivateKeyRec;

-#define exaPixmapPrivateKey (&exaPixmapPrivateKeyRec)

-extern DevPrivateKeyRec exaGCPrivateKeyRec;

-#define exaGCPrivateKey (&exaGCPrivateKeyRec)

-

-#define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixLookupPrivate(&(s)->devPrivates, exaScreenPrivateKey))

-#define ExaScreenPriv(s)	ExaScreenPrivPtr    pExaScr = ExaGetScreenPriv(s)

-

-#define ExaGetGCPriv(gc) ((ExaGCPrivPtr)dixLookupPrivate(&(gc)->devPrivates, exaGCPrivateKey))

-#define ExaGCPriv(gc) ExaGCPrivPtr pExaGC = ExaGetGCPriv(gc)

-

-/*

- * Some macros to deal with function wrapping.

- */

-#define wrap(priv, real, mem, func) {\

-    priv->Saved##mem = real->mem; \

-    real->mem = func; \

-}

-

-#define unwrap(priv, real, mem) {\

-    real->mem = priv->Saved##mem; \

-}

-

-#define swap(priv, real, mem) {\

-    void *tmp = priv->Saved##mem; \

-    priv->Saved##mem = real->mem; \

-    real->mem = tmp; \

-}

-

-#define EXA_PRE_FALLBACK(_screen_) \

-    ExaScreenPriv(_screen_); \

-    pExaScr->fallback_counter++;

-

-#define EXA_POST_FALLBACK(_screen_) \

-    pExaScr->fallback_counter--;

-

-#define EXA_PRE_FALLBACK_GC(_gc_) \

-    ExaScreenPriv(_gc_->pScreen); \

-    ExaGCPriv(_gc_); \

-    pExaScr->fallback_counter++; \

-    swap(pExaGC, _gc_, ops);

-

-#define EXA_POST_FALLBACK_GC(_gc_) \

-    pExaScr->fallback_counter--; \

-    swap(pExaGC, _gc_, ops);

-

-/** Align an offset to an arbitrary alignment */

-#define EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \

-	(((offset) + (align) - 1) % (align)))

-/** Align an offset to a power-of-two alignment */

-#define EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))

-

-#define EXA_PIXMAP_SCORE_MOVE_IN    10

-#define EXA_PIXMAP_SCORE_MAX	    20

-#define EXA_PIXMAP_SCORE_MOVE_OUT   -10

-#define EXA_PIXMAP_SCORE_MIN	    -20

-#define EXA_PIXMAP_SCORE_PINNED	    1000

-#define EXA_PIXMAP_SCORE_INIT	    1001

-

-#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixLookupPrivate(&(p)->devPrivates, exaPixmapPrivateKey))

-#define ExaSetPixmapPriv(p,a) dixSetPrivate(&(p)->devPrivates, exaPixmapPrivateKey, a)

-#define ExaPixmapPriv(p)	ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p)

-

-#define EXA_RANGE_PITCH (1 << 0)

-#define EXA_RANGE_WIDTH (1 << 1)

-#define EXA_RANGE_HEIGHT (1 << 2)

-

-typedef struct {

-    ExaOffscreenArea *area;

-    int		    score;	/**< score for the move-in vs move-out heuristic */

-    Bool	    use_gpu_copy;

-

-    CARD8	    *sys_ptr;	/**< pointer to pixmap data in system memory */

-    int		    sys_pitch;	/**< pitch of pixmap in system memory */

-

-    CARD8	    *fb_ptr;	/**< pointer to pixmap data in framebuffer memory */

-    int		    fb_pitch;	/**< pitch of pixmap in framebuffer memory */

-    unsigned int    fb_size;	/**< size of pixmap in framebuffer memory */

-

-    /**

-     * Holds information about whether this pixmap can be used for

-     * acceleration (== 0) or not (> 0).

-     *

-     * Contains a OR'ed combination of the following values:

-     * EXA_RANGE_PITCH - set if the pixmap's pitch is out of range

-     * EXA_RANGE_WIDTH - set if the pixmap's width is out of range

-     * EXA_RANGE_HEIGHT - set if the pixmap's height is out of range

-     */

-    unsigned int    accel_blocked;

-

-    /**

-     * The damage record contains the areas of the pixmap's current location

-     * (framebuffer or system) that have been damaged compared to the other

-     * location.

-     */

-    DamagePtr	    pDamage;

-    /**

-     * The valid regions mark the valid bits (at least, as they're derived from

-     * damage, which may be overreported) of a pixmap's system and FB copies.

-     */

-    RegionRec	    validSys, validFB;

-    /**

-     * Driver private storage per EXA pixmap

-     */

-    void *driverPriv;

-} ExaPixmapPrivRec, *ExaPixmapPrivPtr;

-

-typedef struct {

-    /* GC values from the layer below. */

-    GCOps *Savedops;

-    GCFuncs *Savedfuncs;

-} ExaGCPrivRec, *ExaGCPrivPtr;

-

-typedef struct {

-    PicturePtr pDst;

-    INT16 xSrc;

-    INT16 ySrc;

-    INT16 xMask;

-    INT16 yMask;

-    INT16 xDst;

-    INT16 yDst;

-    INT16 width;

-    INT16 height;

-} ExaCompositeRectRec, *ExaCompositeRectPtr;

-

-/**

- * exaDDXDriverInit must be implemented by the DDX using EXA, and is the place

- * to set EXA options or hook in screen functions to handle using EXA as the AA.

-  */

-void exaDDXDriverInit (ScreenPtr pScreen);

-

-/* exa_unaccel.c */

-void

-exaPrepareAccessGC(GCPtr pGC);

-

-void

-exaFinishAccessGC(GCPtr pGC);

-

-void

-ExaCheckFillSpans  (DrawablePtr pDrawable, GCPtr pGC, int nspans,

-		   DDXPointPtr ppt, int *pwidth, int fSorted);

-

-void

-ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,

-		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);

-

-void

-ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,

-		 int x, int y, int w, int h, int leftPad, int format,

-		 char *bits);

-

-void

-ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,

-	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 

-	     Bool upsidedown, Pixel bitplane, void *closure);

-

-RegionPtr

-ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,

-		 int srcx, int srcy, int w, int h, int dstx, int dsty);

-

-RegionPtr

-ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,

-		  int srcx, int srcy, int w, int h, int dstx, int dsty,

-		  unsigned long bitPlane);

-

-void

-ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,

-		  DDXPointPtr pptInit);

-

-void

-ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,

-		  int mode, int npt, DDXPointPtr ppt);

-

-void

-ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,

-		    int nsegInit, xSegment *pSegInit);

-

-void

-ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,

-		int narcs, xArc *pArcs);

-

-void

-ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,

-		     int nrect, xRectangle *prect);

-

-void

-ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,

-		      int x, int y, unsigned int nglyph,

-		      CharInfoPtr *ppci, pointer pglyphBase);

-

-void

-ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,

-		     int x, int y, unsigned int nglyph,

-		     CharInfoPtr *ppci, pointer pglyphBase);

-

-void

-ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,

-		   DrawablePtr pDrawable,

-		   int w, int h, int x, int y);

-

-void

-ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);

-

-void

-ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,

-		unsigned int format, unsigned long planeMask, char *d);

-

-void

-ExaCheckGetSpans (DrawablePtr pDrawable,

-		 int wMax,

-		 DDXPointPtr ppt,

-		 int *pwidth,

-		 int nspans,

-		 char *pdstStart);

-

-void

-ExaCheckAddTraps (PicturePtr	pPicture,

-		  INT16		x_off,

-		  INT16		y_off,

-		  int		ntrap,

-		  xTrap		*traps);

-

-/* exa_accel.c */

-

-static _X_INLINE Bool

-exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask,

-		      unsigned int fillStyle, unsigned char alu,

-		      unsigned int clientClipType)

-{

-    return ((alu != GXcopy && alu != GXclear && alu != GXset &&

-	     alu != GXcopyInverted) || fillStyle == FillStippled ||

-	    clientClipType != CT_NONE || !EXA_PM_IS_SOLID(pDrawable, planemask));

-}

-

-void

-exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);

-

-Bool

-exaFillRegionTiled (DrawablePtr	pDrawable, RegionPtr pRegion, PixmapPtr pTile,

-		    DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,

-		    unsigned int clientClipType);

-

-void

-exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,

-	     unsigned int format, unsigned long planeMask, char *d);

-

-RegionPtr

-exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,

-	    int srcx, int srcy, int width, int height, int dstx, int dsty);

-

-Bool

-exaHWCopyNtoN (DrawablePtr    pSrcDrawable,

-	     DrawablePtr    pDstDrawable,

-	     GCPtr	    pGC,

-	     BoxPtr	    pbox,

-	     int	    nbox,

-	     int	    dx,

-	     int	    dy,

-	     Bool	    reverse,

-	     Bool	    upsidedown);

-

-void

-exaCopyNtoN (DrawablePtr    pSrcDrawable,

-	     DrawablePtr    pDstDrawable,

-	     GCPtr	    pGC,

-	     BoxPtr	    pbox,

-	     int	    nbox,

-	     int	    dx,

-	     int	    dy,

-	     Bool	    reverse,

-	     Bool	    upsidedown,

-	     Pixel	    bitplane,

-	     void	    *closure);

-

-extern const GCOps exaOps;

-

-void

-ExaCheckComposite (CARD8      op,

-		  PicturePtr pSrc,

-		  PicturePtr pMask,

-		  PicturePtr pDst,

-		  INT16      xSrc,

-		  INT16      ySrc,

-		  INT16      xMask,

-		  INT16      yMask,

-		  INT16      xDst,

-		  INT16      yDst,

-		  CARD16     width,

-		  CARD16     height);

-

-void

-ExaCheckGlyphs (CARD8	      op,

-		PicturePtr    pSrc,

-		PicturePtr    pDst,

-		PictFormatPtr maskFormat,

-		INT16	      xSrc,

-		INT16	      ySrc,

-		int	      nlist,

-		GlyphListPtr  list,

-		GlyphPtr      *glyphs);

-

-/* exa_offscreen.c */

-void

-ExaOffscreenSwapOut (ScreenPtr pScreen);

-

-void

-ExaOffscreenSwapIn (ScreenPtr pScreen);

-

-ExaOffscreenArea*

-ExaOffscreenDefragment (ScreenPtr pScreen);

-

-Bool

-exaOffscreenInit(ScreenPtr pScreen);

-

-void

-ExaOffscreenFini (ScreenPtr pScreen);

-

-/* exa.c */

-Bool

-ExaDoPrepareAccess(PixmapPtr pPixmap, int index);

-

-void

-exaPrepareAccess(DrawablePtr pDrawable, int index);

-

-void

-exaFinishAccess(DrawablePtr pDrawable, int index);

-

-void

-exaDestroyPixmap(PixmapPtr pPixmap);

-

-void

-exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);

-

-void

-exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,

-		      int *xp, int *yp);

-

-Bool

-exaPixmapHasGpuCopy(PixmapPtr p);

-

-PixmapPtr

-exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp);

-

-PixmapPtr

-exaGetDrawablePixmap(DrawablePtr pDrawable);

-

-void

-exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,

-              int w, int h, int bpp);

-

-void

-exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,

-                 int w, int h, int bpp);

-

-void

-exaDoMigration (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

-

-Bool

-exaPixmapIsPinned (PixmapPtr pPix);

-

-extern const GCFuncs exaGCFuncs;

-

-/* exa_classic.c */

-PixmapPtr

-exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,

-		unsigned usage_hint);

-

-Bool

-exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,

-		      int bitsPerPixel, int devKind, pointer pPixData);

-

-Bool

-exaDestroyPixmap_classic (PixmapPtr pPixmap);

-

-Bool

-exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);

-

-/* exa_driver.c */

-PixmapPtr

-exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,

-		unsigned usage_hint);

-

-Bool

-exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth,

-		      int bitsPerPixel, int devKind, pointer pPixData);

-

-Bool

-exaDestroyPixmap_driver (PixmapPtr pPixmap);

-

-Bool

-exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);

-

-/* exa_mixed.c */

-PixmapPtr

-exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,

-		unsigned usage_hint);

-

-Bool

-exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,

-		      int bitsPerPixel, int devKind, pointer pPixData);

-

-Bool

-exaDestroyPixmap_mixed(PixmapPtr pPixmap);

-

-Bool

-exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);

-

-/* exa_migration_mixed.c */

-void

-exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);

-

-void

-exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

-

-void

-exaMoveInPixmap_mixed(PixmapPtr pPixmap);

-

-void

-exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);

-

-void

-exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);

-

-/* exa_render.c */

-Bool

-exaOpReadsDestination (CARD8 op);

-

-void

-exaComposite(CARD8	op,

-	     PicturePtr pSrc,

-	     PicturePtr pMask,

-	     PicturePtr pDst,

-	     INT16	xSrc,

-	     INT16	ySrc,

-	     INT16	xMask,

-	     INT16	yMask,

-	     INT16	xDst,

-	     INT16	yDst,

-	     CARD16	width,

-	     CARD16	height);

-

-void

-exaCompositeRects(CARD8	              op,

-		  PicturePtr	      Src,

-		  PicturePtr	      pMask,

-		  PicturePtr	      pDst,

-		  int                 nrect,

-		  ExaCompositeRectPtr rects);

-

-void

-exaTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst,

-               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,

-               int ntrap, xTrapezoid *traps);

-

-void

-exaTriangles (CARD8 op, PicturePtr pSrc, PicturePtr pDst,

-	      PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,

-	      int ntri, xTriangle *tris);

-

-/* exa_glyph.c */

-void

-exaGlyphsInit(ScreenPtr pScreen);

-

-void

-exaGlyphsFini (ScreenPtr pScreen);

-

-void

-exaGlyphs (CARD8	op,

-	  PicturePtr	pSrc,

-	  PicturePtr	pDst,

-	  PictFormatPtr	maskFormat,

-	  INT16		xSrc,

-	  INT16		ySrc,

-	  int		nlist,

-	  GlyphListPtr	list,

-	  GlyphPtr	*glyphs);

-

-/* exa_migration_classic.c */

-void

-exaCopyDirtyToSys (ExaMigrationPtr migrate);

-

-void

-exaCopyDirtyToFb (ExaMigrationPtr migrate);

-

-void

-exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

-

-void

-exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area);

-

-void

-exaMoveOutPixmap_classic (PixmapPtr pPixmap);

-

-void

-exaMoveInPixmap_classic (PixmapPtr pPixmap);

-

-void

-exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);

-

-#endif /* EXAPRIV_H */

+/*
+ *
+ * Copyright (C) 2000 Keith Packard, member of The XFree86 Project, Inc.
+ *               2005 Zack Rusin, Trolltech
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#ifndef EXAPRIV_H
+#define EXAPRIV_H
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "exa.h"
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#ifdef MITSHM
+#include "shmint.h"
+#endif
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "servermd.h"
+#include "mibstore.h"
+#include "colormapst.h"
+#include "gcstruct.h"
+#include "input.h"
+#include "mipointer.h"
+#include "mi.h"
+#include "dix.h"
+#include "fb.h"
+#include "fboverlay.h"
+#include "fbpict.h"
+#include "glyphstr.h"
+#include "damage.h"
+
+#define DEBUG_TRACE_FALL	0
+#define DEBUG_MIGRATE		0
+#define DEBUG_PIXMAP		0
+#define DEBUG_OFFSCREEN		0
+#define DEBUG_GLYPH_CACHE	0
+
+#if DEBUG_TRACE_FALL
+#define EXA_FALLBACK(x)     					\
+do {								\
+	ErrorF("EXA fallback at %s: ", __FUNCTION__);		\
+	ErrorF x;						\
+} while (0)
+
+char
+exaDrawableLocation(DrawablePtr pDrawable);
+#else
+#define EXA_FALLBACK(x)
+#endif
+
+#if DEBUG_PIXMAP
+#define DBG_PIXMAP(a) ErrorF a
+#else
+#define DBG_PIXMAP(a)
+#endif
+
+#ifndef EXA_MAX_FB
+#define EXA_MAX_FB   FB_OVERLAY_MAX
+#endif
+
+#ifdef DEBUG
+#define EXA_FatalErrorDebug(x) FatalError x
+#define EXA_FatalErrorDebugWithRet(x, ret) FatalError x
+#else
+#define EXA_FatalErrorDebug(x) ErrorF x
+#define EXA_FatalErrorDebugWithRet(x, ret) \
+do { \
+    ErrorF x; \
+    return ret; \
+} while (0)
+#endif
+
+/**
+ * This is the list of migration heuristics supported by EXA.  See
+ * exaDoMigration() for what their implementations do.
+ */
+enum ExaMigrationHeuristic {
+    ExaMigrationGreedy,
+    ExaMigrationAlways,
+    ExaMigrationSmart
+};
+
+typedef struct {
+    unsigned char sha1[20];
+} ExaCachedGlyphRec, *ExaCachedGlyphPtr;
+
+typedef struct {
+    /* The identity of the cache, statically configured at initialization */
+    unsigned int format;
+    int glyphWidth;
+    int glyphHeight;
+
+    int size; /* Size of cache; eventually this should be dynamically determined */
+
+    /* Hash table mapping from glyph sha1 to position in the glyph; we use
+     * open addressing with a hash table size determined based on size and large
+     * enough so that we always have a good amount of free space, so we can
+     * use linear probing. (Linear probing is preferrable to double hashing
+     * here because it allows us to easily remove entries.)
+     */
+    int *hashEntries;
+    int hashSize;
+    
+    ExaCachedGlyphPtr glyphs;
+    int glyphCount; /* Current number of glyphs */
+    
+    PicturePtr picture;   /* Where the glyphs of the cache are stored */
+    int yOffset;          /* y location within the picture where the cache starts */
+    int columns;          /* Number of columns the glyphs are layed out in */
+    int evictionPosition; /* Next random position to evict a glyph */
+} ExaGlyphCacheRec, *ExaGlyphCachePtr;
+
+#define EXA_NUM_GLYPH_CACHES 4
+
+#define EXA_FALLBACK_COPYWINDOW (1 << 0)
+#define EXA_ACCEL_COPYWINDOW (1 << 1)
+
+typedef struct _ExaMigrationRec {
+    Bool as_dst;
+    Bool as_src;
+    PixmapPtr pPix;
+    RegionPtr pReg;
+} ExaMigrationRec, *ExaMigrationPtr;
+
+typedef void (*EnableDisableFBAccessProcPtr)(int, Bool);
+typedef struct {
+    ExaDriverPtr info;
+    ScreenBlockHandlerProcPtr	 SavedBlockHandler;
+    ScreenWakeupHandlerProcPtr	 SavedWakeupHandler;
+    CreateGCProcPtr 		 SavedCreateGC;
+    CloseScreenProcPtr 		 SavedCloseScreen;
+    GetImageProcPtr 		 SavedGetImage;
+    GetSpansProcPtr 		 SavedGetSpans;
+    CreatePixmapProcPtr 	 SavedCreatePixmap;
+    DestroyPixmapProcPtr 	 SavedDestroyPixmap;
+    CopyWindowProcPtr 		 SavedCopyWindow;
+    ChangeWindowAttributesProcPtr SavedChangeWindowAttributes;
+    BitmapToRegionProcPtr        SavedBitmapToRegion;
+    CreateScreenResourcesProcPtr SavedCreateScreenResources;
+    ModifyPixmapHeaderProcPtr    SavedModifyPixmapHeader;
+    SourceValidateProcPtr        SavedSourceValidate;
+    CompositeProcPtr             SavedComposite;
+    TrianglesProcPtr		 SavedTriangles;
+    GlyphsProcPtr                SavedGlyphs;
+    TrapezoidsProcPtr            SavedTrapezoids;
+    AddTrapsProcPtr		 SavedAddTraps;
+    void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+    Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);
+    void (*do_move_in_pixmap) (PixmapPtr pPixmap);
+    void (*do_move_out_pixmap) (PixmapPtr pPixmap);
+    void (*prepare_access_reg)(PixmapPtr pPixmap, int index, RegionPtr pReg);
+
+    Bool			 swappedOut;
+    enum ExaMigrationHeuristic	 migration;
+    Bool			 checkDirtyCorrectness;
+    unsigned			 disableFbCount;
+    Bool			 optimize_migration;
+    unsigned			 offScreenCounter;
+    unsigned			 numOffscreenAvailable;
+    CARD32			 lastDefragment;
+    CARD32			 nextDefragment;
+    PixmapPtr			 deferred_mixed_pixmap;
+
+    /* Reference counting for accessed pixmaps */
+    struct {
+	PixmapPtr pixmap;
+	int count;
+	Bool retval;
+    } access[EXA_NUM_PREPARE_INDICES];
+
+    /* Holds information on fallbacks that cannot be relayed otherwise. */
+    unsigned int fallback_flags;
+    unsigned int fallback_counter;
+
+    ExaGlyphCacheRec             glyphCaches[EXA_NUM_GLYPH_CACHES];
+
+    /**
+     * Regions affected by fallback composite source / mask operations.
+     */
+
+    RegionRec srcReg;
+    RegionRec maskReg;
+    PixmapPtr srcPix;
+
+} ExaScreenPrivRec, *ExaScreenPrivPtr;
+
+/*
+ * This is the only completely portable way to
+ * compute this info.
+ */
+#ifndef BitsPerPixel
+#define BitsPerPixel(d) (\
+    PixmapWidthPaddingInfo[d].notPower2 ? \
+    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
+    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
+    (PixmapWidthPaddingInfo[d].padRoundUp+1)))
+#endif
+
+extern DevPrivateKeyRec exaScreenPrivateKeyRec;
+#define exaScreenPrivateKey (&exaScreenPrivateKeyRec)
+extern DevPrivateKeyRec exaPixmapPrivateKeyRec;
+#define exaPixmapPrivateKey (&exaPixmapPrivateKeyRec)
+extern DevPrivateKeyRec exaGCPrivateKeyRec;
+#define exaGCPrivateKey (&exaGCPrivateKeyRec)
+
+#define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixLookupPrivate(&(s)->devPrivates, exaScreenPrivateKey))
+#define ExaScreenPriv(s)	ExaScreenPrivPtr    pExaScr = ExaGetScreenPriv(s)
+
+#define ExaGetGCPriv(gc) ((ExaGCPrivPtr)dixLookupPrivate(&(gc)->devPrivates, exaGCPrivateKey))
+#define ExaGCPriv(gc) ExaGCPrivPtr pExaGC = ExaGetGCPriv(gc)
+
+/*
+ * Some macros to deal with function wrapping.
+ */
+#define wrap(priv, real, mem, func) {\
+    priv->Saved##mem = real->mem; \
+    real->mem = func; \
+}
+
+#define unwrap(priv, real, mem) {\
+    real->mem = priv->Saved##mem; \
+}
+
+#define swap(priv, real, mem) {\
+    void *tmp = priv->Saved##mem; \
+    priv->Saved##mem = real->mem; \
+    real->mem = tmp; \
+}
+
+#define EXA_PRE_FALLBACK(_screen_) \
+    ExaScreenPriv(_screen_); \
+    pExaScr->fallback_counter++;
+
+#define EXA_POST_FALLBACK(_screen_) \
+    pExaScr->fallback_counter--;
+
+#define EXA_PRE_FALLBACK_GC(_gc_) \
+    ExaScreenPriv(_gc_->pScreen); \
+    ExaGCPriv(_gc_); \
+    pExaScr->fallback_counter++; \
+    swap(pExaGC, _gc_, ops);
+
+#define EXA_POST_FALLBACK_GC(_gc_) \
+    pExaScr->fallback_counter--; \
+    swap(pExaGC, _gc_, ops);
+
+/** Align an offset to an arbitrary alignment */
+#define EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \
+	(((offset) + (align) - 1) % (align)))
+/** Align an offset to a power-of-two alignment */
+#define EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))
+
+#define EXA_PIXMAP_SCORE_MOVE_IN    10
+#define EXA_PIXMAP_SCORE_MAX	    20
+#define EXA_PIXMAP_SCORE_MOVE_OUT   -10
+#define EXA_PIXMAP_SCORE_MIN	    -20
+#define EXA_PIXMAP_SCORE_PINNED	    1000
+#define EXA_PIXMAP_SCORE_INIT	    1001
+
+#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixLookupPrivate(&(p)->devPrivates, exaPixmapPrivateKey))
+#define ExaSetPixmapPriv(p,a) dixSetPrivate(&(p)->devPrivates, exaPixmapPrivateKey, a)
+#define ExaPixmapPriv(p)	ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p)
+
+#define EXA_RANGE_PITCH (1 << 0)
+#define EXA_RANGE_WIDTH (1 << 1)
+#define EXA_RANGE_HEIGHT (1 << 2)
+
+typedef struct {
+    ExaOffscreenArea *area;
+    int		    score;	/**< score for the move-in vs move-out heuristic */
+    Bool	    use_gpu_copy;
+
+    CARD8	    *sys_ptr;	/**< pointer to pixmap data in system memory */
+    int		    sys_pitch;	/**< pitch of pixmap in system memory */
+
+    CARD8	    *fb_ptr;	/**< pointer to pixmap data in framebuffer memory */
+    int		    fb_pitch;	/**< pitch of pixmap in framebuffer memory */
+    unsigned int    fb_size;	/**< size of pixmap in framebuffer memory */
+
+    /**
+     * Holds information about whether this pixmap can be used for
+     * acceleration (== 0) or not (> 0).
+     *
+     * Contains a OR'ed combination of the following values:
+     * EXA_RANGE_PITCH - set if the pixmap's pitch is out of range
+     * EXA_RANGE_WIDTH - set if the pixmap's width is out of range
+     * EXA_RANGE_HEIGHT - set if the pixmap's height is out of range
+     */
+    unsigned int    accel_blocked;
+
+    /**
+     * The damage record contains the areas of the pixmap's current location
+     * (framebuffer or system) that have been damaged compared to the other
+     * location.
+     */
+    DamagePtr	    pDamage;
+    /**
+     * The valid regions mark the valid bits (at least, as they're derived from
+     * damage, which may be overreported) of a pixmap's system and FB copies.
+     */
+    RegionRec	    validSys, validFB;
+    /**
+     * Driver private storage per EXA pixmap
+     */
+    void *driverPriv;
+} ExaPixmapPrivRec, *ExaPixmapPrivPtr;
+
+typedef struct {
+    /* GC values from the layer below. */
+    GCOps *Savedops;
+    GCFuncs *Savedfuncs;
+} ExaGCPrivRec, *ExaGCPrivPtr;
+
+typedef struct {
+    PicturePtr pDst;
+    INT16 xSrc;
+    INT16 ySrc;
+    INT16 xMask;
+    INT16 yMask;
+    INT16 xDst;
+    INT16 yDst;
+    INT16 width;
+    INT16 height;
+} ExaCompositeRectRec, *ExaCompositeRectPtr;
+
+/**
+ * exaDDXDriverInit must be implemented by the DDX using EXA, and is the place
+ * to set EXA options or hook in screen functions to handle using EXA as the AA.
+  */
+void exaDDXDriverInit (ScreenPtr pScreen);
+
+/* exa_unaccel.c */
+void
+exaPrepareAccessGC(GCPtr pGC);
+
+void
+exaFinishAccessGC(GCPtr pGC);
+
+void
+ExaCheckFillSpans  (DrawablePtr pDrawable, GCPtr pGC, int nspans,
+		   DDXPointPtr ppt, int *pwidth, int fSorted);
+
+void
+ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,
+		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
+
+void
+ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
+		 int x, int y, int w, int h, int leftPad, int format,
+		 char *bits);
+
+void
+ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
+	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 
+	     Bool upsidedown, Pixel bitplane, void *closure);
+
+RegionPtr
+ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+		 int srcx, int srcy, int w, int h, int dstx, int dsty);
+
+RegionPtr
+ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+		  int srcx, int srcy, int w, int h, int dstx, int dsty,
+		  unsigned long bitPlane);
+
+void
+ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
+		  DDXPointPtr pptInit);
+
+void
+ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
+		  int mode, int npt, DDXPointPtr ppt);
+
+void
+ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
+		    int nsegInit, xSegment *pSegInit);
+
+void
+ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
+		int narcs, xArc *pArcs);
+
+void
+ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
+		     int nrect, xRectangle *prect);
+
+void
+ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
+		      int x, int y, unsigned int nglyph,
+		      CharInfoPtr *ppci, pointer pglyphBase);
+
+void
+ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
+		     int x, int y, unsigned int nglyph,
+		     CharInfoPtr *ppci, pointer pglyphBase);
+
+void
+ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
+		   DrawablePtr pDrawable,
+		   int w, int h, int x, int y);
+
+void
+ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
+
+void
+ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
+		unsigned int format, unsigned long planeMask, char *d);
+
+void
+ExaCheckGetSpans (DrawablePtr pDrawable,
+		 int wMax,
+		 DDXPointPtr ppt,
+		 int *pwidth,
+		 int nspans,
+		 char *pdstStart);
+
+void
+ExaCheckAddTraps (PicturePtr	pPicture,
+		  INT16		x_off,
+		  INT16		y_off,
+		  int		ntrap,
+		  xTrap		*traps);
+
+/* exa_accel.c */
+
+static _X_INLINE Bool
+exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask,
+		      unsigned int fillStyle, unsigned char alu,
+		      unsigned int clientClipType)
+{
+    return ((alu != GXcopy && alu != GXclear && alu != GXset &&
+	     alu != GXcopyInverted) || fillStyle == FillStippled ||
+	    clientClipType != CT_NONE || !EXA_PM_IS_SOLID(pDrawable, planemask));
+}
+
+void
+exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
+
+Bool
+exaFillRegionTiled (DrawablePtr	pDrawable, RegionPtr pRegion, PixmapPtr pTile,
+		    DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
+		    unsigned int clientClipType);
+
+void
+exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,
+	     unsigned int format, unsigned long planeMask, char *d);
+
+RegionPtr
+exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
+	    int srcx, int srcy, int width, int height, int dstx, int dsty);
+
+Bool
+exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
+	     DrawablePtr    pDstDrawable,
+	     GCPtr	    pGC,
+	     BoxPtr	    pbox,
+	     int	    nbox,
+	     int	    dx,
+	     int	    dy,
+	     Bool	    reverse,
+	     Bool	    upsidedown);
+
+void
+exaCopyNtoN (DrawablePtr    pSrcDrawable,
+	     DrawablePtr    pDstDrawable,
+	     GCPtr	    pGC,
+	     BoxPtr	    pbox,
+	     int	    nbox,
+	     int	    dx,
+	     int	    dy,
+	     Bool	    reverse,
+	     Bool	    upsidedown,
+	     Pixel	    bitplane,
+	     void	    *closure);
+
+extern const GCOps exaOps;
+
+void
+ExaCheckComposite (CARD8      op,
+		  PicturePtr pSrc,
+		  PicturePtr pMask,
+		  PicturePtr pDst,
+		  INT16      xSrc,
+		  INT16      ySrc,
+		  INT16      xMask,
+		  INT16      yMask,
+		  INT16      xDst,
+		  INT16      yDst,
+		  CARD16     width,
+		  CARD16     height);
+
+void
+ExaCheckGlyphs (CARD8	      op,
+		PicturePtr    pSrc,
+		PicturePtr    pDst,
+		PictFormatPtr maskFormat,
+		INT16	      xSrc,
+		INT16	      ySrc,
+		int	      nlist,
+		GlyphListPtr  list,
+		GlyphPtr      *glyphs);
+
+/* exa_offscreen.c */
+void
+ExaOffscreenSwapOut (ScreenPtr pScreen);
+
+void
+ExaOffscreenSwapIn (ScreenPtr pScreen);
+
+ExaOffscreenArea*
+ExaOffscreenDefragment (ScreenPtr pScreen);
+
+Bool
+exaOffscreenInit(ScreenPtr pScreen);
+
+void
+ExaOffscreenFini (ScreenPtr pScreen);
+
+/* exa.c */
+Bool
+ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
+
+void
+exaPrepareAccess(DrawablePtr pDrawable, int index);
+
+void
+exaFinishAccess(DrawablePtr pDrawable, int index);
+
+void
+exaDestroyPixmap(PixmapPtr pPixmap);
+
+void
+exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
+
+void
+exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,
+		      int *xp, int *yp);
+
+Bool
+exaPixmapHasGpuCopy(PixmapPtr p);
+
+PixmapPtr
+exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp);
+
+PixmapPtr
+exaGetDrawablePixmap(DrawablePtr pDrawable);
+
+void
+exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
+              int w, int h, int bpp);
+
+void
+exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
+                 int w, int h, int bpp);
+
+void
+exaDoMigration (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+
+Bool
+exaPixmapIsPinned (PixmapPtr pPix);
+
+extern const GCFuncs exaGCFuncs;
+
+/* exa_classic.c */
+PixmapPtr
+exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
+		unsigned class);
+
+Bool
+exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,
+		      int bitsPerPixel, int devKind, pointer pPixData);
+
+Bool
+exaDestroyPixmap_classic (PixmapPtr pPixmap);
+
+Bool
+exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
+
+/* exa_driver.c */
+PixmapPtr
+exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
+		unsigned class);
+
+Bool
+exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth,
+		      int bitsPerPixel, int devKind, pointer pPixData);
+
+Bool
+exaDestroyPixmap_driver (PixmapPtr pPixmap);
+
+Bool
+exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
+
+/* exa_mixed.c */
+PixmapPtr
+exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
+		unsigned class);
+
+Bool
+exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
+		      int bitsPerPixel, int devKind, pointer pPixData);
+
+Bool
+exaDestroyPixmap_mixed(PixmapPtr pPixmap);
+
+Bool
+exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
+
+/* exa_migration_mixed.c */
+void
+exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
+
+void
+exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+
+void
+exaMoveInPixmap_mixed(PixmapPtr pPixmap);
+
+void
+exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
+
+void
+exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
+
+/* exa_render.c */
+Bool
+exaOpReadsDestination (CARD8 op);
+
+void
+exaComposite(CARD8	op,
+	     PicturePtr pSrc,
+	     PicturePtr pMask,
+	     PicturePtr pDst,
+	     INT16	xSrc,
+	     INT16	ySrc,
+	     INT16	xMask,
+	     INT16	yMask,
+	     INT16	xDst,
+	     INT16	yDst,
+	     CARD16	width,
+	     CARD16	height);
+
+void
+exaCompositeRects(CARD8	              op,
+		  PicturePtr	      Src,
+		  PicturePtr	      pMask,
+		  PicturePtr	      pDst,
+		  int                 nrect,
+		  ExaCompositeRectPtr rects);
+
+void
+exaTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+               int ntrap, xTrapezoid *traps);
+
+void
+exaTriangles (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+	      PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+	      int ntri, xTriangle *tris);
+
+/* exa_glyph.c */
+void
+exaGlyphsInit(ScreenPtr pScreen);
+
+void
+exaGlyphsFini (ScreenPtr pScreen);
+
+void
+exaGlyphs (CARD8	op,
+	  PicturePtr	pSrc,
+	  PicturePtr	pDst,
+	  PictFormatPtr	maskFormat,
+	  INT16		xSrc,
+	  INT16		ySrc,
+	  int		nlist,
+	  GlyphListPtr	list,
+	  GlyphPtr	*glyphs);
+
+/* exa_migration_classic.c */
+void
+exaCopyDirtyToSys (ExaMigrationPtr migrate);
+
+void
+exaCopyDirtyToFb (ExaMigrationPtr migrate);
+
+void
+exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+
+void
+exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area);
+
+void
+exaMoveOutPixmap_classic (PixmapPtr pPixmap);
+
+void
+exaMoveInPixmap_classic (PixmapPtr pPixmap);
+
+void
+exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
+
+#endif /* EXAPRIV_H */