svn merge https://vcxsrv.svn.sourceforge.net/svnroot/vcxsrv/branches/released .

8 files changed, 1463 insertions, 1447 deletions

diff --git a/xorg-server/exa/exa.c b/xorg-server/exa/exa.c
index 483e3b4eb..e264d440c 100644
--- a/xorg-server/exa/exa.c
+++ b/xorg-server/exa/exa.c
@@ -286,11 +286,10 @@ exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp)
  * Returns TRUE if pixmap can be accessed offscreen.
  */
 Bool
-ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
+ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
 {
-    ScreenPtr pScreen = pDrawable->pScreen;
+    ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv (pScreen);
-    PixmapPtr pPixmap = exaGetDrawablePixmap (pDrawable);
     ExaPixmapPriv(pPixmap);
     Bool offscreen;
     int i;
@@ -324,7 +323,7 @@ ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
 
     offscreen = exaPixmapIsOffscreen(pPixmap);
 
-    if (offscreen)
+    if (offscreen && pExaPixmap->fb_ptr)
 	pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
     else
 	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
@@ -333,20 +332,10 @@ ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
     pExaScr->access[index].pixmap = pPixmap;
     pExaScr->access[index].count = 1;
 
-    if (!offscreen) {
-	/* Do we need to allocate our system buffer? */
-	if ((pExaScr->info->flags & EXA_HANDLES_PIXMAPS) && (pExaScr->info->flags & EXA_MIXED_PIXMAPS)) {
-	    if (!pExaPixmap->sys_ptr && !exaPixmapIsPinned(pPixmap)) {
-		pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch * pDrawable->height);
-		if (!pExaPixmap->sys_ptr)
-		    FatalError("EXA: malloc failed for size %d bytes\n", pExaPixmap->sys_pitch * pDrawable->height);
-		pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
-	    }
-	}
+    if (!offscreen)
 	return FALSE;
-    }
 
-    exaWaitSync (pDrawable->pScreen);
+    exaWaitSync (pScreen);
 
     if (pExaScr->info->PrepareAccess == NULL)
 	return TRUE;
@@ -360,7 +349,8 @@ ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
     }
 
     if (!(*pExaScr->info->PrepareAccess) (pPixmap, index)) {
-	if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED)
+	if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED &&
+	    !(pExaScr->info->flags & EXA_MIXED_PIXMAPS))
 	    FatalError("Driver failed PrepareAccess on a pinned pixmap.\n");
 	exaMoveOutPixmap (pPixmap);
 
@@ -370,31 +360,6 @@ ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
     return TRUE;
 }
 
-void
-exaPrepareAccessReg(DrawablePtr pDrawable, int index, RegionPtr pReg)
-{
-    PixmapPtr pPixmap = exaGetDrawablePixmap (pDrawable);
-    ExaScreenPriv(pPixmap->drawable.pScreen);
-
-    if (pExaScr->do_migration) {
-	ExaMigrationRec pixmaps[1];
-
-	if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
-	    pixmaps[0].as_dst = TRUE;
-	    pixmaps[0].as_src = FALSE;
-	} else {
-	    pixmaps[0].as_dst = FALSE;
-	    pixmaps[0].as_src = TRUE;
-	}
-	pixmaps[0].pPix = pPixmap;
-	pixmaps[0].pReg = pReg;
-
-	exaDoMigration(pixmaps, 1, FALSE);
-    }
-
-    ExaDoPrepareAccess(pDrawable, index);
-}
-
 /**
  * exaPrepareAccess() is EXA's wrapper for the driver's PrepareAccess() handler.
  *
@@ -404,7 +369,13 @@ exaPrepareAccessReg(DrawablePtr pDrawable, int index, RegionPtr pReg)
 void
 exaPrepareAccess(DrawablePtr pDrawable, int index)
 {
-    exaPrepareAccessReg(pDrawable, index, NULL);
+    PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+    ExaScreenPriv(pDrawable->pScreen);
+
+    if (pExaScr->prepare_access_reg)
+	pExaScr->prepare_access_reg(pPixmap, index, NULL);
+    else
+	(void)ExaDoPrepareAccess(pPixmap, index);
 }
 
 /**
@@ -432,7 +403,6 @@ exaFinishAccess(DrawablePtr pDrawable, int index)
 	if (pExaScr->access[i].pixmap == pPixmap) {
 	    if (--pExaScr->access[i].count > 0)
 		return;
-	    index = i;
 	    break;
 	}
     }
@@ -442,25 +412,25 @@ exaFinishAccess(DrawablePtr pDrawable, int index)
 	EXA_FatalErrorDebug(("EXA bug: FinishAccess called without PrepareAccess for pixmap 0x%p.\n",
 			     pPixmap));
 
-    pExaScr->access[index].pixmap = NULL;
+    pExaScr->access[i].pixmap = NULL;
 
     /* We always hide the devPrivate.ptr. */
     pPixmap->devPrivate.ptr = NULL;
 
-    if (pExaScr->info->FinishAccess == NULL)
-	return;
+    if (pExaScr->finish_access)
+	pExaScr->finish_access(pPixmap, index);
 
-    if (!exaPixmapIsOffscreen (pPixmap))
+    if (!pExaScr->info->FinishAccess || !exaPixmapIsOffscreen(pPixmap))
 	return;
 
-    if (index >= EXA_PREPARE_AUX_DEST &&
+    if (i >= EXA_PREPARE_AUX_DEST &&
 	!(pExaScr->info->flags & EXA_SUPPORTS_PREPARE_AUX)) {
 	ErrorF("EXA bug: Trying to call driver FinishAccess hook with "
 	       "unsupported index EXA_PREPARE_AUX*\n");
 	return;
     }
 
-    (*pExaScr->info->FinishAccess) (pPixmap, index);
+    (*pExaScr->info->FinishAccess) (pPixmap, i);
 }
 
 /**
@@ -537,7 +507,7 @@ exaCreatePixmapWithPrepare(ScreenPtr pScreen, int w, int h, int depth,
      * For EXA_HANDLES_PIXMAPS the driver will handle whatever is needed.
      * We want to signal that the pixmaps will be used as destination.
      */
-    ExaDoPrepareAccess(&pPixmap->drawable, EXA_PREPARE_AUX_DEST);
+    ExaDoPrepareAccess(pPixmap, EXA_PREPARE_AUX_DEST);
 
     return pPixmap;
 }
@@ -1071,6 +1041,8 @@ exaDriverInit (ScreenPtr		pScreen,
 		pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_mixed;
 		pExaScr->do_move_in_pixmap = exaMoveInPixmap_mixed;
 		pExaScr->do_move_out_pixmap = NULL;
+		pExaScr->prepare_access_reg = exaPrepareAccessReg_mixed;
+		pExaScr->finish_access = exaFinishAccess_mixed;
 	    } else {
 		wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmap_driver);
 		wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_driver);
@@ -1079,6 +1051,8 @@ exaDriverInit (ScreenPtr		pScreen,
 		pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_driver;
 		pExaScr->do_move_in_pixmap = NULL;
 		pExaScr->do_move_out_pixmap = NULL;
+		pExaScr->prepare_access_reg = NULL;
+		pExaScr->finish_access = NULL;
 	    }
 	} else {
 	    wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmap_classic);
@@ -1088,6 +1062,8 @@ exaDriverInit (ScreenPtr		pScreen,
 	    pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_classic;
 	    pExaScr->do_move_in_pixmap = exaMoveInPixmap_classic;
 	    pExaScr->do_move_out_pixmap = exaMoveOutPixmap_classic;
+	    pExaScr->prepare_access_reg = exaPrepareAccessReg_classic;
+	    pExaScr->finish_access = NULL;
 	}
 	if (!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS)) {
 	    LogMessage(X_INFO, "EXA(%d): Offscreen pixmap area of %lu bytes\n",
diff --git a/xorg-server/exa/exa_glyphs.c b/xorg-server/exa/exa_glyphs.c
index d621ccf76..bf097c32f 100644
--- a/xorg-server/exa/exa_glyphs.c
+++ b/xorg-server/exa/exa_glyphs.c
@@ -701,7 +701,6 @@ exaGlyphs (CARD8 	 op,
 	   GlyphListPtr	 list,
 	   GlyphPtr	*glyphs)
 {
-    PicturePtr	pPicture;
     PixmapPtr   pMaskPixmap = 0;
     PicturePtr  pMask = NULL;
     ScreenPtr   pScreen = pDst->pDrawable->pScreen;
@@ -803,7 +802,6 @@ exaGlyphs (CARD8 	 op,
 	while (n--)
 	{
 	    glyph = *glyphs++;
-	    pPicture = GlyphPicture (glyph)[pScreen->myNum];
 
 	    if (glyph->info.width > 0 && glyph->info.height > 0)
 	    {
diff --git a/xorg-server/exa/exa_migration_classic.c b/xorg-server/exa/exa_migration_classic.c
index e096c1eac..b6671f069 100644
--- a/xorg-server/exa/exa_migration_classic.c
+++ b/xorg-server/exa/exa_migration_classic.c
@@ -1,720 +1,742 @@
-/*
- * Copyright © 2006 Intel Corporation
- *
- * 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.
- *
- * Authors:
- *    Eric Anholt <eric@anholt.net>
- *    Michel Dänzer <michel@tungstengraphics.com>
- *
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <string.h>
-
-#include "exa_priv.h"
-#include "exa.h"
-
-#if DEBUG_MIGRATE
-#define DBG_MIGRATE(a) ErrorF a
-#else
-#define DBG_MIGRATE(a)
-#endif
-
-/**
- * The fallback path for UTS/DFS failing is to just memcpy.  exaCopyDirtyToSys
- * and exaCopyDirtyToFb both needed to do this loop.
- */
-static void
-exaMemcpyBox (PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,
-	      CARD8 *dst, int dst_pitch)
- {
-    int i, cpp = pPixmap->drawable.bitsPerPixel / 8;
-    int bytes = (pbox->x2 - pbox->x1) * cpp;
-
-    src += pbox->y1 * src_pitch + pbox->x1 * cpp;
-    dst += pbox->y1 * dst_pitch + pbox->x1 * cpp;
-
-    for (i = pbox->y2 - pbox->y1; i; i--) {
-	memcpy (dst, src, bytes);
-	src += src_pitch;
-	dst += dst_pitch;
-    }
-}
-
-/**
- * Returns TRUE if the pixmap is dirty (has been modified in its current
- * location compared to the other), or lacks a private for tracking
- * dirtiness.
- */
-static Bool
-exaPixmapIsDirty (PixmapPtr pPix)
-{
-    ExaPixmapPriv (pPix);
-
-    if (pExaPixmap == NULL)
-	EXA_FatalErrorDebugWithRet(("EXA bug: exaPixmapIsDirty was called on a non-exa pixmap.\n"), TRUE);
-
-    return REGION_NOTEMPTY (pScreen, DamageRegion(pExaPixmap->pDamage)) ||
-	!REGION_EQUAL(pScreen, &pExaPixmap->validSys, &pExaPixmap->validFB);
-}
-
-/**
- * Returns TRUE if the pixmap is either pinned in FB, or has a sufficient score
- * to be considered "should be in framebuffer".  That's just anything that has
- * had more acceleration than fallbacks, or has no score yet.
- *
- * Only valid if using a migration scheme that tracks score.
- */
-static Bool
-exaPixmapShouldBeInFB (PixmapPtr pPix)
-{
-    ExaPixmapPriv (pPix);
-
-    if (exaPixmapIsPinned (pPix))
-	return TRUE;
-
-    return pExaPixmap->score >= 0;
-}
-
-/**
- * If the pixmap is currently dirty, this copies at least the dirty area from
- * FB to system or vice versa.  Both areas must be allocated.
- */
-static void
-exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
-	     Bool (*transfer) (PixmapPtr pPix, int x, int y, int w, int h,
-			       char *sys, int sys_pitch), CARD8 *fallback_src,
-	     CARD8 *fallback_dst, int fallback_srcpitch, int fallback_dstpitch,
-	     int fallback_index, void (*sync) (ScreenPtr pScreen))
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
-    RegionPtr damage = DamageRegion (pExaPixmap->pDamage);
-    RegionRec CopyReg;
-    Bool save_offscreen;
-    int save_pitch;
-    BoxPtr pBox;
-    int nbox;
-    Bool access_prepared = FALSE;
-    Bool need_sync = FALSE;
-
-    /* Damaged bits are valid in current copy but invalid in other one */
-    if (exaPixmapIsOffscreen(pPixmap)) {
-	REGION_UNION(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,
-		     damage);
-	REGION_SUBTRACT(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,
-			damage);
-    } else {
-	REGION_UNION(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,
-		     damage);
-	REGION_SUBTRACT(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,
-			damage);
-    }
-
-    REGION_EMPTY(pScreen, damage);
-
-    /* Copy bits valid in source but not in destination */
-    REGION_NULL(pScreen, &CopyReg);
-    REGION_SUBTRACT(pScreen, &CopyReg, pValidSrc, pValidDst);
-
-    if (migrate->as_dst) {
-	ExaScreenPriv (pPixmap->drawable.pScreen);
-
-	/* XXX: The pending damage region will be marked as damaged after the
-	 * operation, so it should serve as an upper bound for the region that
-	 * needs to be synchronized for the operation. Unfortunately, this
-	 * causes corruption in some cases, e.g. when starting compiz. See
-	 * https://bugs.freedesktop.org/show_bug.cgi?id=12916 .
-	 */
-	if (pExaScr->optimize_migration) {
-	    RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
-
-#if DEBUG_MIGRATE
-	    if (REGION_NIL(pending_damage)) {
-		static Bool firsttime = TRUE;
-
-		if (firsttime) {
-		    ErrorF("%s: Pending damage region empty!\n", __func__);
-		    firsttime = FALSE;
-		}
-	    }
-#endif
-
-	    /* Try to prevent destination valid region from growing too many
-	     * rects by filling it up to the extents of the union of the
-	     * destination valid region and the pending damage region.
-	     */
-	    if (REGION_NUM_RECTS(pValidDst) > 10) {
-		BoxRec box;
-		BoxPtr pValidExt, pDamageExt;
-		RegionRec closure;
-
-		pValidExt = REGION_EXTENTS(pScreen, pValidDst);
-		pDamageExt = REGION_EXTENTS(pScreen, pending_damage);
-
-		box.x1 = min(pValidExt->x1, pDamageExt->x1);
-		box.y1 = min(pValidExt->y1, pDamageExt->y1);
-		box.x2 = max(pValidExt->x2, pDamageExt->x2);
-		box.y2 = max(pValidExt->y2, pDamageExt->y2);
-
-		REGION_INIT(pScreen, &closure, &box, 0);
-		REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, &closure);
-	    } else
-		REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, pending_damage);
-	}
-
-	/* The caller may provide a region to be subtracted from the calculated
-	 * dirty region. This is to avoid migration of bits that don't
-	 * contribute to the result of the operation.
-	 */
-	if (migrate->pReg)
-	    REGION_SUBTRACT(pScreen, &CopyReg, &CopyReg, migrate->pReg);
-    } else {
-	/* The caller may restrict the region to be migrated for source pixmaps
-	 * to what's relevant for the operation.
-	 */
-	if (migrate->pReg)
-	    REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, migrate->pReg);
-    }
-
-    pBox = REGION_RECTS(&CopyReg);
-    nbox = REGION_NUM_RECTS(&CopyReg);
-
-    save_offscreen = pExaPixmap->offscreen;
-    save_pitch = pPixmap->devKind;
-    pExaPixmap->offscreen = TRUE;
-    pPixmap->devKind = pExaPixmap->fb_pitch;
-
-    while (nbox--) {
-	pBox->x1 = max(pBox->x1, 0);
-	pBox->y1 = max(pBox->y1, 0);
-	pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
-	pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
-
-	if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
-	    continue;
-
-	if (!transfer || !transfer (pPixmap,
-				    pBox->x1, pBox->y1,
-				    pBox->x2 - pBox->x1,
-				    pBox->y2 - pBox->y1,
-				    (char *) (pExaPixmap->sys_ptr
-				    + pBox->y1 * pExaPixmap->sys_pitch
-				    + pBox->x1 * pPixmap->drawable.bitsPerPixel / 8),
-				    pExaPixmap->sys_pitch))
-	{
-	    if (!access_prepared) {
-		ExaDoPrepareAccess(&pPixmap->drawable, fallback_index);
-		access_prepared = TRUE;
-	    }
-	    exaMemcpyBox (pPixmap, pBox,
-			  fallback_src, fallback_srcpitch,
-			  fallback_dst, fallback_dstpitch);
-	} else
-	    need_sync = TRUE;
-
-	pBox++;
-    }
-
-    if (access_prepared)
-	exaFinishAccess(&pPixmap->drawable, fallback_index);
-    else if (need_sync && sync)
-	sync (pPixmap->drawable.pScreen);
-
-    pExaPixmap->offscreen = save_offscreen;
-    pPixmap->devKind = save_pitch;
-
-    /* Try to prevent source valid region from growing too many rects by
-     * removing parts of it which are also in the destination valid region.
-     * Removing anything beyond that would lead to data loss.
-     */
-    if (REGION_NUM_RECTS(pValidSrc) > 20)
-	REGION_SUBTRACT(pScreen, pValidSrc, pValidSrc, pValidDst);
-
-    /* The copied bits are now valid in destination */
-    REGION_UNION(pScreen, pValidDst, pValidDst, &CopyReg);
-
-    REGION_UNINIT(pScreen, &CopyReg);
-}
-
-/**
- * If the pixmap is currently dirty, this copies at least the dirty area from
- * the framebuffer  memory copy to the system memory copy.  Both areas must be
- * allocated.
- */
-static void
-exaCopyDirtyToSys (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaScreenPriv (pPixmap->drawable.pScreen);
-    ExaPixmapPriv (pPixmap);
-
-    exaCopyDirty(migrate, &pExaPixmap->validSys, &pExaPixmap->validFB,
-		 pExaScr->info->DownloadFromScreen, pExaPixmap->fb_ptr,
-		 pExaPixmap->sys_ptr, pExaPixmap->fb_pitch,
-		 pExaPixmap->sys_pitch, EXA_PREPARE_SRC, exaWaitSync);
-}
-
-/**
- * If the pixmap is currently dirty, this copies at least the dirty area from
- * the system memory copy to the framebuffer memory copy.  Both areas must be
- * allocated.
- */
-static void
-exaCopyDirtyToFb (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaScreenPriv (pPixmap->drawable.pScreen);
-    ExaPixmapPriv (pPixmap);
-
-    exaCopyDirty(migrate, &pExaPixmap->validFB, &pExaPixmap->validSys,
-		 pExaScr->info->UploadToScreen, pExaPixmap->sys_ptr,
-		 pExaPixmap->fb_ptr, pExaPixmap->sys_pitch,
-		 pExaPixmap->fb_pitch, EXA_PREPARE_DEST, NULL);
-}
-
-/**
- * Allocates a framebuffer copy of the pixmap if necessary, and then copies
- * any necessary pixmap data into the framebuffer copy and points the pixmap at
- * it.
- *
- * Note that when first allocated, a pixmap will have FALSE dirty flag.
- * This is intentional because pixmap data starts out undefined.  So if we move
- * it in due to the first operation against it being accelerated, it will have
- * undefined framebuffer contents that we didn't have to upload.  If we do
- * moveouts (and moveins) after the first movein, then we will only have to copy
- * back and forth if the pixmap was written to after the last synchronization of
- * the two copies.  Then, at exaPixmapSave (when the framebuffer copy goes away)
- * we mark the pixmap dirty, so that the next exaMoveInPixmap will actually move
- * all the data, since it's almost surely all valid now.
- */
-static void
-exaDoMoveInPixmap (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ScreenPtr pScreen = pPixmap->drawable.pScreen;
-    ExaScreenPriv (pScreen);
-    ExaPixmapPriv (pPixmap);
-
-    /* If we're VT-switched away, no touching card memory allowed. */
-    if (pExaScr->swappedOut)
-	return;
-
-    /* If we're not allowed to move, then fail. */
-    if (exaPixmapIsPinned(pPixmap))
-	return;
-
-    /* Don't migrate in pixmaps which are less than 8bpp.  This avoids a lot of
-     * fragility in EXA, and <8bpp is probably not used enough any more to care
-     * (at least, not in acceleratd paths).
-     */
-    if (pPixmap->drawable.bitsPerPixel < 8)
-	return;
-
-    if (pExaPixmap->accel_blocked)
-	return;
-
-    if (pExaPixmap->area == NULL) {
-	pExaPixmap->area =
-	    exaOffscreenAlloc (pScreen, pExaPixmap->fb_size,
-			       pExaScr->info->pixmapOffsetAlign, FALSE,
-                               exaPixmapSave, (pointer) pPixmap);
-	if (pExaPixmap->area == NULL)
-	    return;
-
-	pExaPixmap->fb_ptr = (CARD8 *) pExaScr->info->memoryBase +
-				       pExaPixmap->area->offset;
-    }
-
-    exaCopyDirtyToFb (migrate);
-
-    if (exaPixmapIsOffscreen(pPixmap))
-	return;
-
-    DBG_MIGRATE (("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,
-		  (ExaGetPixmapPriv(pPixmap)->area ?
-                   ExaGetPixmapPriv(pPixmap)->area->offset : 0),
-		  pPixmap->drawable.width,
-		  pPixmap->drawable.height,
-		  exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
-
-    pExaPixmap->offscreen = TRUE;
-
-    pPixmap->devKind = pExaPixmap->fb_pitch;
-    pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-}
-
-void
-exaMoveInPixmap_classic (PixmapPtr pPixmap)
-{
-    static ExaMigrationRec migrate = { FALSE, TRUE,
-				       NULL, NULL };
-
-    migrate.pPix = pPixmap;
-    exaDoMoveInPixmap (&migrate);
-}
-
-/**
- * Switches the current active location of the pixmap to system memory, copying
- * updated data out if necessary.
- */
-static void
-exaDoMoveOutPixmap (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
-
-    if (!pExaPixmap->area || exaPixmapIsPinned(pPixmap))
-	return;
-
-    exaCopyDirtyToSys (migrate);
-
-    if (exaPixmapIsOffscreen(pPixmap)) {
-
-	DBG_MIGRATE (("<- %p (%p) (%dx%d) (%c)\n", pPixmap,
-		      (void*)(ExaGetPixmapPriv(pPixmap)->area ?
-			      ExaGetPixmapPriv(pPixmap)->area->offset : 0),
-		      pPixmap->drawable.width,
-		      pPixmap->drawable.height,
-		      exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
-
-	pExaPixmap->offscreen = FALSE;
-
-	pPixmap->devKind = pExaPixmap->sys_pitch;
-	pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
-    }
-}
-
-void
-exaMoveOutPixmap_classic (PixmapPtr pPixmap)
-{
-    static ExaMigrationRec migrate = { FALSE, TRUE,
-				       NULL, NULL };
-
-    migrate.pPix = pPixmap;
-    exaDoMoveOutPixmap (&migrate);
-}
-
-
-/**
- * Copies out important pixmap data and removes references to framebuffer area.
- * Called when the memory manager decides it's time to kick the pixmap out of
- * framebuffer entirely.
- */
-void
-exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area)
-{
-    PixmapPtr pPixmap = area->privData;
-    ExaPixmapPriv(pPixmap);
-
-    exaMoveOutPixmap(pPixmap);
-
-    pExaPixmap->fb_ptr = NULL;
-    pExaPixmap->area = NULL;
-
-    /* Mark all FB bits as invalid, so all valid system bits get copied to FB
-     * next time */
-    REGION_EMPTY(pPixmap->drawable.pScreen, &pExaPixmap->validFB);
-}
-
-/**
- * For the "greedy" migration scheme, pushes the pixmap toward being located in
- * framebuffer memory.
- */
-static void
-exaMigrateTowardFb (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
-
-    if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) {
-	DBG_MIGRATE(("UseScreen: not migrating pinned pixmap %p\n",
-		     (pointer)pPixmap));
-	return;
-    }
-
-    DBG_MIGRATE(("UseScreen %p score %d\n",
-		 (pointer)pPixmap, pExaPixmap->score));
-
-    if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) {
-	exaDoMoveInPixmap(migrate);
-	pExaPixmap->score = 0;
-    }
-
-    if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX)
-	pExaPixmap->score++;
-
-    if (pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN &&
-	!exaPixmapIsOffscreen(pPixmap))
-    {
-	exaDoMoveInPixmap(migrate);
-    }
-
-    if (exaPixmapIsOffscreen(pPixmap)) {
-	exaCopyDirtyToFb (migrate);
-	ExaOffscreenMarkUsed (pPixmap);
-    } else
-	exaCopyDirtyToSys (migrate);
-}
-
-/**
- * For the "greedy" migration scheme, pushes the pixmap toward being located in
- * system memory.
- */
-static void
-exaMigrateTowardSys (ExaMigrationPtr migrate)
-{
-    PixmapPtr pPixmap = migrate->pPix;
-    ExaPixmapPriv (pPixmap);
-
-    DBG_MIGRATE(("UseMem: %p score %d\n", (pointer)pPixmap, pExaPixmap->score));
-
-    if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED)
-	return;
-
-    if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT)
-	pExaPixmap->score = 0;
-
-    if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN)
-	pExaPixmap->score--;
-
-    if (pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT && pExaPixmap->area)
-	exaDoMoveOutPixmap(migrate);
-
-    if (exaPixmapIsOffscreen(pPixmap)) {
-	exaCopyDirtyToFb (migrate);
-	ExaOffscreenMarkUsed (pPixmap);
-    } else
-	exaCopyDirtyToSys (migrate);
-}
-
-/**
- * If the pixmap has both a framebuffer and system memory copy, this function
- * asserts that both of them are the same.
- */
-static Bool
-exaAssertNotDirty (PixmapPtr pPixmap)
-{
-    ExaPixmapPriv (pPixmap);
-    CARD8 *dst, *src;
-    RegionRec ValidReg;
-    int dst_pitch, src_pitch, cpp, y, nbox, save_pitch;
-    BoxPtr pBox;
-    Bool ret = TRUE, save_offscreen;
-
-    if (exaPixmapIsPinned(pPixmap) || pExaPixmap->area == NULL)
-	return ret;
-
-    REGION_NULL(pScreen, &ValidReg);
-    REGION_INTERSECT(pScreen, &ValidReg, &pExaPixmap->validFB,
-		     &pExaPixmap->validSys);
-    nbox = REGION_NUM_RECTS(&ValidReg);
-
-    if (!nbox)
-	goto out;
-
-    pBox = REGION_RECTS(&ValidReg);
-
-    dst_pitch = pExaPixmap->sys_pitch;
-    src_pitch = pExaPixmap->fb_pitch;
-    cpp = pPixmap->drawable.bitsPerPixel / 8;
-
-    save_offscreen = pExaPixmap->offscreen;
-    save_pitch = pPixmap->devKind;
-    pExaPixmap->offscreen = TRUE;
-    pPixmap->devKind = pExaPixmap->fb_pitch;
-
-    if (!ExaDoPrepareAccess(&pPixmap->drawable, EXA_PREPARE_SRC))
-	goto skip;
-
-    while (nbox--) {
-	    int rowbytes;
-
-	    pBox->x1 = max(pBox->x1, 0);
-	    pBox->y1 = max(pBox->y1, 0);
-	    pBox->x2 = min(pBox->x2, pPixmap->drawable.width);
-	    pBox->y2 = min(pBox->y2, pPixmap->drawable.height);
-
-	    if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)
-		continue;
-
-	    rowbytes = (pBox->x2 - pBox->x1) * cpp;
-	    src = (CARD8 *) pPixmap->devPrivate.ptr + pBox->y1 * src_pitch + pBox->x1 * cpp;
-	    dst = pExaPixmap->sys_ptr + pBox->y1 * dst_pitch + pBox->x1 * cpp;
-
-	    for (y = pBox->y1; y < pBox->y2;
-		 y++, src += src_pitch, dst += dst_pitch) {
-		if (memcmp(dst, src, rowbytes) != 0) {
-		    ret = FALSE;
-		    exaPixmapDirty(pPixmap, pBox->x1, pBox->y1, pBox->x2,
-				   pBox->y2);
-		    break;
-		}
-	    }
-    }
-
-skip:
-    exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_SRC);
-
-    pExaPixmap->offscreen = save_offscreen;
-    pPixmap->devKind = save_pitch;
-
-out:
-    REGION_UNINIT(pScreen, &ValidReg);
-    return ret;
-}
-
-/**
- * Performs migration of the pixmaps according to the operation information
- * provided in pixmaps and can_accel and the migration scheme chosen in the
- * config file.
- */
-void
-exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
-{
-    ScreenPtr pScreen = pixmaps[0].pPix->drawable.pScreen;
-    ExaScreenPriv(pScreen);
-    int i, j;
-
-    /* If this debugging flag is set, check each pixmap for whether it is marked
-     * as clean, and if so, actually check if that's the case.  This should help
-     * catch issues with failing to mark a drawable as dirty.  While it will
-     * catch them late (after the operation happened), it at least explains what
-     * went wrong, and instrumenting the code to find what operation happened
-     * to the pixmap last shouldn't be hard.
-     */
-    if (pExaScr->checkDirtyCorrectness) {
-	for (i = 0; i < npixmaps; i++) {
-	    if (!exaPixmapIsDirty (pixmaps[i].pPix) &&
-		!exaAssertNotDirty (pixmaps[i].pPix))
-		ErrorF("%s: Pixmap %d dirty but not marked as such!\n", __FUNCTION__, i);
-	}
-    }
-    /* If anything is pinned in system memory, we won't be able to
-     * accelerate.
-     */
-    for (i = 0; i < npixmaps; i++) {
-	if (exaPixmapIsPinned (pixmaps[i].pPix) &&
-	    !exaPixmapIsOffscreen (pixmaps[i].pPix))
-	{
-	    EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,
-		      pixmaps[i].pPix->drawable.width,
-		      pixmaps[i].pPix->drawable.height));
-	    can_accel = FALSE;
-	    break;
-	}
-    }
-
-    if (pExaScr->migration == ExaMigrationSmart) {
-	/* If we've got something as a destination that we shouldn't cause to
-	 * become newly dirtied, take the unaccelerated route.
-	 */
-	for (i = 0; i < npixmaps; i++) {
-	    if (pixmaps[i].as_dst && !exaPixmapShouldBeInFB (pixmaps[i].pPix) &&
-		!exaPixmapIsDirty (pixmaps[i].pPix))
-	    {
-		for (i = 0; i < npixmaps; i++) {
-		    if (!exaPixmapIsDirty (pixmaps[i].pPix))
-			exaDoMoveOutPixmap (pixmaps + i);
-		}
-		return;
-	    }
-	}
-
-	/* If we aren't going to accelerate, then we migrate everybody toward
-	 * system memory, and kick out if it's free.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++) {
-		exaMigrateTowardSys (pixmaps + i);
-		if (!exaPixmapIsDirty (pixmaps[i].pPix))
-		    exaDoMoveOutPixmap (pixmaps + i);
-	    }
-	    return;
-	}
-
-	/* Finally, the acceleration path.  Move them all in. */
-	for (i = 0; i < npixmaps; i++) {
-	    exaMigrateTowardFb(pixmaps + i);
-	    exaDoMoveInPixmap(pixmaps + i);
-	}
-    } else if (pExaScr->migration == ExaMigrationGreedy) {
-	/* If we can't accelerate, either because the driver can't or because one of
-	 * the pixmaps is pinned in system memory, then we migrate everybody toward
-	 * system memory.
-	 *
-	 * We also migrate toward system if all pixmaps involved are currently in
-	 * system memory -- this can mitigate thrashing when there are significantly
-	 * more pixmaps active than would fit in memory.
-	 *
-	 * If not, then we migrate toward FB so that hopefully acceleration can
-	 * happen.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++)
-		exaMigrateTowardSys (pixmaps + i);
-	    return;
-	}
-
-	for (i = 0; i < npixmaps; i++) {
-	    if (exaPixmapIsOffscreen(pixmaps[i].pPix)) {
-		/* Found one in FB, so move all to FB. */
-		for (j = 0; j < npixmaps; j++)
-		    exaMigrateTowardFb(pixmaps + i);
-		return;
-	    }
-	}
-
-	/* Nobody's in FB, so move all away from FB. */
-	for (i = 0; i < npixmaps; i++)
-	    exaMigrateTowardSys(pixmaps + i);
-    } else if (pExaScr->migration == ExaMigrationAlways) {
-	/* Always move the pixmaps out if we can't accelerate.  If we can
-	 * accelerate, try to move them all in.  If that fails, then move them
-	 * back out.
-	 */
-	if (!can_accel) {
-	    for (i = 0; i < npixmaps; i++)
-		exaDoMoveOutPixmap(pixmaps + i);
-	    return;
-	}
-
-	/* Now, try to move them all into FB */
-	for (i = 0; i < npixmaps; i++) {
-	    exaDoMoveInPixmap(pixmaps + i);
-	}
-
-	/* If we couldn't fit everything in, abort */
-	for (i = 0; i < npixmaps; i++) {
-	    if (!exaPixmapIsOffscreen(pixmaps[i].pPix)) {
-		return;
-	    }
-	}
-
-	/* Yay, everything's offscreen, mark memory as used */
-	for (i = 0; i < npixmaps; i++) {
-	    ExaOffscreenMarkUsed (pixmaps[i].pPix);
-	}
-    }
-}
+/*

+ * Copyright © 2006 Intel Corporation

+ *

+ * 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.

+ *

+ * Authors:

+ *    Eric Anholt <eric@anholt.net>

+ *    Michel Dänzer <michel@tungstengraphics.com>

+ *

+ */

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include <string.h>

+

+#include "exa_priv.h"

+#include "exa.h"

+

+#if DEBUG_MIGRATE

+#define DBG_MIGRATE(a) ErrorF a

+#else

+#define DBG_MIGRATE(a)

+#endif

+

+/**

+ * The fallback path for UTS/DFS failing is to just memcpy.  exaCopyDirtyToSys

+ * and exaCopyDirtyToFb both needed to do this loop.

+ */

+static void

+exaMemcpyBox (PixmapPtr pPixmap, BoxPtr pbox, CARD8 *src, int src_pitch,

+	      CARD8 *dst, int dst_pitch)

+ {

+    int i, cpp = pPixmap->drawable.bitsPerPixel / 8;

+    int bytes = (pbox->x2 - pbox->x1) * cpp;

+

+    src += pbox->y1 * src_pitch + pbox->x1 * cpp;

+    dst += pbox->y1 * dst_pitch + pbox->x1 * cpp;

+

+    for (i = pbox->y2 - pbox->y1; i; i--) {

+	memcpy (dst, src, bytes);

+	src += src_pitch;

+	dst += dst_pitch;

+    }

+}

+

+/**

+ * Returns TRUE if the pixmap is dirty (has been modified in its current

+ * location compared to the other), or lacks a private for tracking

+ * dirtiness.

+ */

+static Bool

+exaPixmapIsDirty (PixmapPtr pPix)

+{

+    ExaPixmapPriv (pPix);

+

+    if (pExaPixmap == NULL)

+	EXA_FatalErrorDebugWithRet(("EXA bug: exaPixmapIsDirty was called on a non-exa pixmap.\n"), TRUE);

+

+    return REGION_NOTEMPTY (pScreen, DamageRegion(pExaPixmap->pDamage)) ||

+	!REGION_EQUAL(pScreen, &pExaPixmap->validSys, &pExaPixmap->validFB);

+}

+

+/**

+ * Returns TRUE if the pixmap is either pinned in FB, or has a sufficient score

+ * to be considered "should be in framebuffer".  That's just anything that has

+ * had more acceleration than fallbacks, or has no score yet.

+ *

+ * Only valid if using a migration scheme that tracks score.

+ */

+static Bool

+exaPixmapShouldBeInFB (PixmapPtr pPix)

+{

+    ExaPixmapPriv (pPix);

+

+    if (exaPixmapIsPinned (pPix))

+	return TRUE;

+

+    return pExaPixmap->score >= 0;

+}

+

+/**

+ * If the pixmap is currently dirty, this copies at least the dirty area from

+ * FB to system or vice versa.  Both areas must be allocated.

+ */

+static void

+exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,

+	     Bool (*transfer) (PixmapPtr pPix, int x, int y, int w, int h,

+			       char *sys, int sys_pitch), int fallback_index,

+	     void (*sync) (ScreenPtr pScreen))

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaPixmapPriv (pPixmap);

+    RegionPtr damage = DamageRegion (pExaPixmap->pDamage);

+    RegionRec CopyReg;

+    Bool save_offscreen;

+    int save_pitch;

+    BoxPtr pBox;

+    int nbox;

+    Bool access_prepared = FALSE;

+    Bool need_sync = FALSE;

+

+    /* Damaged bits are valid in current copy but invalid in other one */

+    if (pExaPixmap->offscreen) {

+	REGION_UNION(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,

+		     damage);

+	REGION_SUBTRACT(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,

+			damage);

+    } else {

+	REGION_UNION(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,

+		     damage);

+	REGION_SUBTRACT(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,

+			damage);

+    }

+

+    REGION_EMPTY(pScreen, damage);

+

+    /* Copy bits valid in source but not in destination */

+    REGION_NULL(pScreen, &CopyReg);

+    REGION_SUBTRACT(pScreen, &CopyReg, pValidSrc, pValidDst);

+

+    if (migrate->as_dst) {

+	ExaScreenPriv (pPixmap->drawable.pScreen);

+

+	/* XXX: The pending damage region will be marked as damaged after the

+	 * operation, so it should serve as an upper bound for the region that

+	 * needs to be synchronized for the operation. Unfortunately, this

+	 * causes corruption in some cases, e.g. when starting compiz. See

+	 * https://bugs.freedesktop.org/show_bug.cgi?id=12916 .

+	 */

+	if (pExaScr->optimize_migration) {

+	    RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);

+

+#if DEBUG_MIGRATE

+	    if (REGION_NIL(pending_damage)) {

+		static Bool firsttime = TRUE;

+

+		if (firsttime) {

+		    ErrorF("%s: Pending damage region empty!\n", __func__);

+		    firsttime = FALSE;

+		}

+	    }

+#endif

+

+	    /* Try to prevent destination valid region from growing too many

+	     * rects by filling it up to the extents of the union of the

+	     * destination valid region and the pending damage region.

+	     */

+	    if (REGION_NUM_RECTS(pValidDst) > 10) {

+		BoxRec box;

+		BoxPtr pValidExt, pDamageExt;

+		RegionRec closure;

+

+		pValidExt = REGION_EXTENTS(pScreen, pValidDst);

+		pDamageExt = REGION_EXTENTS(pScreen, pending_damage);

+

+		box.x1 = min(pValidExt->x1, pDamageExt->x1);

+		box.y1 = min(pValidExt->y1, pDamageExt->y1);

+		box.x2 = max(pValidExt->x2, pDamageExt->x2);

+		box.y2 = max(pValidExt->y2, pDamageExt->y2);

+

+		REGION_INIT(pScreen, &closure, &box, 0);

+		REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, &closure);

+	    } else

+		REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, pending_damage);

+	}

+

+	/* The caller may provide a region to be subtracted from the calculated

+	 * dirty region. This is to avoid migration of bits that don't

+	 * contribute to the result of the operation.

+	 */

+	if (migrate->pReg)

+	    REGION_SUBTRACT(pScreen, &CopyReg, &CopyReg, migrate->pReg);

+    } else {

+	/* The caller may restrict the region to be migrated for source pixmaps

+	 * to what's relevant for the operation.

+	 */

+	if (migrate->pReg)

+	    REGION_INTERSECT(pScreen, &CopyReg, &CopyReg, migrate->pReg);

+    }

+

+    pBox = REGION_RECTS(&CopyReg);

+    nbox = REGION_NUM_RECTS(&CopyReg);

+

+    save_offscreen = pExaPixmap->offscreen;

+    save_pitch = pPixmap->devKind;

+    pExaPixmap->offscreen = TRUE;

+    pPixmap->devKind = pExaPixmap->fb_pitch;

+

+    while (nbox--) {

+	pBox->x1 = max(pBox->x1, 0);

+	pBox->y1 = max(pBox->y1, 0);

+	pBox->x2 = min(pBox->x2, pPixmap->drawable.width);

+	pBox->y2 = min(pBox->y2, pPixmap->drawable.height);

+

+	if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)

+	    continue;

+

+	if (!transfer || !transfer (pPixmap,

+				    pBox->x1, pBox->y1,

+				    pBox->x2 - pBox->x1,

+				    pBox->y2 - pBox->y1,

+				    (char *) (pExaPixmap->sys_ptr

+				    + pBox->y1 * pExaPixmap->sys_pitch

+				    + pBox->x1 * pPixmap->drawable.bitsPerPixel / 8),

+				    pExaPixmap->sys_pitch))

+	{

+	    if (!access_prepared) {

+		ExaDoPrepareAccess(pPixmap, fallback_index);

+		access_prepared = TRUE;

+	    }

+	    if (fallback_index == EXA_PREPARE_DEST) {

+		exaMemcpyBox (pPixmap, pBox,

+			      pExaPixmap->sys_ptr, pExaPixmap->sys_pitch,

+			      pPixmap->devPrivate.ptr, pPixmap->devKind);

+	    } else {

+		exaMemcpyBox (pPixmap, pBox,

+			      pPixmap->devPrivate.ptr, pPixmap->devKind,

+			      pExaPixmap->sys_ptr, pExaPixmap->sys_pitch);

+	    }

+	} else

+	    need_sync = TRUE;

+

+	pBox++;

+    }

+

+    pExaPixmap->offscreen = save_offscreen;

+    pPixmap->devKind = save_pitch;

+

+    /* Try to prevent source valid region from growing too many rects by

+     * removing parts of it which are also in the destination valid region.

+     * Removing anything beyond that would lead to data loss.

+     */

+    if (REGION_NUM_RECTS(pValidSrc) > 20)

+	REGION_SUBTRACT(pScreen, pValidSrc, pValidSrc, pValidDst);

+

+    /* The copied bits are now valid in destination */

+    REGION_UNION(pScreen, pValidDst, pValidDst, &CopyReg);

+

+    REGION_UNINIT(pScreen, &CopyReg);

+

+    if (access_prepared)

+	exaFinishAccess(&pPixmap->drawable, fallback_index);

+    else if (need_sync && sync)

+	sync (pPixmap->drawable.pScreen);

+}

+

+/**

+ * If the pixmap is currently dirty, this copies at least the dirty area from

+ * the framebuffer  memory copy to the system memory copy.  Both areas must be

+ * allocated.

+ */

+void

+exaCopyDirtyToSys (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaScreenPriv (pPixmap->drawable.pScreen);

+    ExaPixmapPriv (pPixmap);

+

+    exaCopyDirty(migrate, &pExaPixmap->validSys, &pExaPixmap->validFB,

+		 pExaScr->info->DownloadFromScreen, EXA_PREPARE_SRC,

+		 exaWaitSync);

+}

+

+/**

+ * If the pixmap is currently dirty, this copies at least the dirty area from

+ * the system memory copy to the framebuffer memory copy.  Both areas must be

+ * allocated.

+ */

+void

+exaCopyDirtyToFb (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaScreenPriv (pPixmap->drawable.pScreen);

+    ExaPixmapPriv (pPixmap);

+

+    exaCopyDirty(migrate, &pExaPixmap->validFB, &pExaPixmap->validSys,

+		 pExaScr->info->UploadToScreen, EXA_PREPARE_DEST, NULL);

+}

+

+/**

+ * Allocates a framebuffer copy of the pixmap if necessary, and then copies

+ * any necessary pixmap data into the framebuffer copy and points the pixmap at

+ * it.

+ *

+ * Note that when first allocated, a pixmap will have FALSE dirty flag.

+ * This is intentional because pixmap data starts out undefined.  So if we move

+ * it in due to the first operation against it being accelerated, it will have

+ * undefined framebuffer contents that we didn't have to upload.  If we do

+ * moveouts (and moveins) after the first movein, then we will only have to copy

+ * back and forth if the pixmap was written to after the last synchronization of

+ * the two copies.  Then, at exaPixmapSave (when the framebuffer copy goes away)

+ * we mark the pixmap dirty, so that the next exaMoveInPixmap will actually move

+ * all the data, since it's almost surely all valid now.

+ */

+static void

+exaDoMoveInPixmap (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ScreenPtr pScreen = pPixmap->drawable.pScreen;

+    ExaScreenPriv (pScreen);

+    ExaPixmapPriv (pPixmap);

+

+    /* If we're VT-switched away, no touching card memory allowed. */

+    if (pExaScr->swappedOut)

+	return;

+

+    /* If we're not allowed to move, then fail. */

+    if (exaPixmapIsPinned(pPixmap))

+	return;

+

+    /* Don't migrate in pixmaps which are less than 8bpp.  This avoids a lot of

+     * fragility in EXA, and <8bpp is probably not used enough any more to care

+     * (at least, not in acceleratd paths).

+     */

+    if (pPixmap->drawable.bitsPerPixel < 8)

+	return;

+

+    if (pExaPixmap->accel_blocked)

+	return;

+

+    if (pExaPixmap->area == NULL) {

+	pExaPixmap->area =

+	    exaOffscreenAlloc (pScreen, pExaPixmap->fb_size,

+			       pExaScr->info->pixmapOffsetAlign, FALSE,

+                               exaPixmapSave, (pointer) pPixmap);

+	if (pExaPixmap->area == NULL)

+	    return;

+

+	pExaPixmap->fb_ptr = (CARD8 *) pExaScr->info->memoryBase +

+				       pExaPixmap->area->offset;

+    }

+

+    exaCopyDirtyToFb (migrate);

+

+    if (exaPixmapIsOffscreen(pPixmap))

+	return;

+

+    DBG_MIGRATE (("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,

+		  (ExaGetPixmapPriv(pPixmap)->area ?

+                   ExaGetPixmapPriv(pPixmap)->area->offset : 0),

+		  pPixmap->drawable.width,

+		  pPixmap->drawable.height,

+		  exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));

+

+    pExaPixmap->offscreen = TRUE;

+

+    pPixmap->devKind = pExaPixmap->fb_pitch;

+    pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

+}

+

+void

+exaMoveInPixmap_classic (PixmapPtr pPixmap)

+{

+    static ExaMigrationRec migrate = { FALSE, TRUE,

+				       NULL, NULL };

+

+    migrate.pPix = pPixmap;

+    exaDoMoveInPixmap (&migrate);

+}

+

+/**

+ * Switches the current active location of the pixmap to system memory, copying

+ * updated data out if necessary.

+ */

+static void

+exaDoMoveOutPixmap (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaPixmapPriv (pPixmap);

+

+    if (!pExaPixmap->area || exaPixmapIsPinned(pPixmap))

+	return;

+

+    exaCopyDirtyToSys (migrate);

+

+    if (exaPixmapIsOffscreen(pPixmap)) {

+

+	DBG_MIGRATE (("<- %p (%p) (%dx%d) (%c)\n", pPixmap,

+		      (void*)(ExaGetPixmapPriv(pPixmap)->area ?

+			      ExaGetPixmapPriv(pPixmap)->area->offset : 0),

+		      pPixmap->drawable.width,

+		      pPixmap->drawable.height,

+		      exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));

+

+	pExaPixmap->offscreen = FALSE;

+

+	pPixmap->devKind = pExaPixmap->sys_pitch;

+	pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

+    }

+}

+

+void

+exaMoveOutPixmap_classic (PixmapPtr pPixmap)

+{

+    static ExaMigrationRec migrate = { FALSE, TRUE,

+				       NULL, NULL };

+

+    migrate.pPix = pPixmap;

+    exaDoMoveOutPixmap (&migrate);

+}

+

+

+/**

+ * Copies out important pixmap data and removes references to framebuffer area.

+ * Called when the memory manager decides it's time to kick the pixmap out of

+ * framebuffer entirely.

+ */

+void

+exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area)

+{

+    PixmapPtr pPixmap = area->privData;

+    ExaPixmapPriv(pPixmap);

+

+    exaMoveOutPixmap(pPixmap);

+

+    pExaPixmap->fb_ptr = NULL;

+    pExaPixmap->area = NULL;

+

+    /* Mark all FB bits as invalid, so all valid system bits get copied to FB

+     * next time */

+    REGION_EMPTY(pPixmap->drawable.pScreen, &pExaPixmap->validFB);

+}

+

+/**

+ * For the "greedy" migration scheme, pushes the pixmap toward being located in

+ * framebuffer memory.

+ */

+static void

+exaMigrateTowardFb (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaPixmapPriv (pPixmap);

+

+    if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) {

+	DBG_MIGRATE(("UseScreen: not migrating pinned pixmap %p\n",

+		     (pointer)pPixmap));

+	return;

+    }

+

+    DBG_MIGRATE(("UseScreen %p score %d\n",

+		 (pointer)pPixmap, pExaPixmap->score));

+

+    if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) {

+	exaDoMoveInPixmap(migrate);

+	pExaPixmap->score = 0;

+    }

+

+    if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX)

+	pExaPixmap->score++;

+

+    if (pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN &&

+	!exaPixmapIsOffscreen(pPixmap))

+    {

+	exaDoMoveInPixmap(migrate);

+    }

+

+    if (exaPixmapIsOffscreen(pPixmap)) {

+	exaCopyDirtyToFb (migrate);

+	ExaOffscreenMarkUsed (pPixmap);

+    } else

+	exaCopyDirtyToSys (migrate);

+}

+

+/**

+ * For the "greedy" migration scheme, pushes the pixmap toward being located in

+ * system memory.

+ */

+static void

+exaMigrateTowardSys (ExaMigrationPtr migrate)

+{

+    PixmapPtr pPixmap = migrate->pPix;

+    ExaPixmapPriv (pPixmap);

+

+    DBG_MIGRATE(("UseMem: %p score %d\n", (pointer)pPixmap, pExaPixmap->score));

+

+    if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED)

+	return;

+

+    if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT)

+	pExaPixmap->score = 0;

+

+    if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN)

+	pExaPixmap->score--;

+

+    if (pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT && pExaPixmap->area)

+	exaDoMoveOutPixmap(migrate);

+

+    if (exaPixmapIsOffscreen(pPixmap)) {

+	exaCopyDirtyToFb (migrate);

+	ExaOffscreenMarkUsed (pPixmap);

+    } else

+	exaCopyDirtyToSys (migrate);

+}

+

+/**

+ * If the pixmap has both a framebuffer and system memory copy, this function

+ * asserts that both of them are the same.

+ */

+static Bool

+exaAssertNotDirty (PixmapPtr pPixmap)

+{

+    ExaPixmapPriv (pPixmap);

+    CARD8 *dst, *src;

+    RegionRec ValidReg;

+    int dst_pitch, src_pitch, cpp, y, nbox, save_pitch;

+    BoxPtr pBox;

+    Bool ret = TRUE, save_offscreen;

+

+    if (exaPixmapIsPinned(pPixmap) || pExaPixmap->area == NULL)

+	return ret;

+

+    REGION_NULL(pScreen, &ValidReg);

+    REGION_INTERSECT(pScreen, &ValidReg, &pExaPixmap->validFB,

+		     &pExaPixmap->validSys);

+    nbox = REGION_NUM_RECTS(&ValidReg);

+

+    if (!nbox)

+	goto out;

+

+    pBox = REGION_RECTS(&ValidReg);

+

+    dst_pitch = pExaPixmap->sys_pitch;

+    src_pitch = pExaPixmap->fb_pitch;

+    cpp = pPixmap->drawable.bitsPerPixel / 8;

+

+    save_offscreen = pExaPixmap->offscreen;

+    save_pitch = pPixmap->devKind;

+    pExaPixmap->offscreen = TRUE;

+    pPixmap->devKind = pExaPixmap->fb_pitch;

+

+    if (!ExaDoPrepareAccess(pPixmap, EXA_PREPARE_SRC))

+	goto skip;

+

+    while (nbox--) {

+	    int rowbytes;

+

+	    pBox->x1 = max(pBox->x1, 0);

+	    pBox->y1 = max(pBox->y1, 0);

+	    pBox->x2 = min(pBox->x2, pPixmap->drawable.width);

+	    pBox->y2 = min(pBox->y2, pPixmap->drawable.height);

+

+	    if (pBox->x1 >= pBox->x2 || pBox->y1 >= pBox->y2)

+		continue;

+

+	    rowbytes = (pBox->x2 - pBox->x1) * cpp;

+	    src = (CARD8 *) pPixmap->devPrivate.ptr + pBox->y1 * src_pitch + pBox->x1 * cpp;

+	    dst = pExaPixmap->sys_ptr + pBox->y1 * dst_pitch + pBox->x1 * cpp;

+

+	    for (y = pBox->y1; y < pBox->y2;

+		 y++, src += src_pitch, dst += dst_pitch) {

+		if (memcmp(dst, src, rowbytes) != 0) {

+		    ret = FALSE;

+		    exaPixmapDirty(pPixmap, pBox->x1, pBox->y1, pBox->x2,

+				   pBox->y2);

+		    break;

+		}

+	    }

+    }

+

+skip:

+    exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_SRC);

+

+    pExaPixmap->offscreen = save_offscreen;

+    pPixmap->devKind = save_pitch;

+

+out:

+    REGION_UNINIT(pScreen, &ValidReg);

+    return ret;

+}

+

+/**

+ * Performs migration of the pixmaps according to the operation information

+ * provided in pixmaps and can_accel and the migration scheme chosen in the

+ * config file.

+ */

+void

+exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)

+{

+    ScreenPtr pScreen = pixmaps[0].pPix->drawable.pScreen;

+    ExaScreenPriv(pScreen);

+    int i, j;

+

+    /* If this debugging flag is set, check each pixmap for whether it is marked

+     * as clean, and if so, actually check if that's the case.  This should help

+     * catch issues with failing to mark a drawable as dirty.  While it will

+     * catch them late (after the operation happened), it at least explains what

+     * went wrong, and instrumenting the code to find what operation happened

+     * to the pixmap last shouldn't be hard.

+     */

+    if (pExaScr->checkDirtyCorrectness) {

+	for (i = 0; i < npixmaps; i++) {

+	    if (!exaPixmapIsDirty (pixmaps[i].pPix) &&

+		!exaAssertNotDirty (pixmaps[i].pPix))

+		ErrorF("%s: Pixmap %d dirty but not marked as such!\n", __FUNCTION__, i);

+	}

+    }

+    /* If anything is pinned in system memory, we won't be able to

+     * accelerate.

+     */

+    for (i = 0; i < npixmaps; i++) {

+	if (exaPixmapIsPinned (pixmaps[i].pPix) &&

+	    !exaPixmapIsOffscreen (pixmaps[i].pPix))

+	{

+	    EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,

+		      pixmaps[i].pPix->drawable.width,

+		      pixmaps[i].pPix->drawable.height));

+	    can_accel = FALSE;

+	    break;

+	}

+    }

+

+    if (pExaScr->migration == ExaMigrationSmart) {

+	/* If we've got something as a destination that we shouldn't cause to

+	 * become newly dirtied, take the unaccelerated route.

+	 */

+	for (i = 0; i < npixmaps; i++) {

+	    if (pixmaps[i].as_dst && !exaPixmapShouldBeInFB (pixmaps[i].pPix) &&

+		!exaPixmapIsDirty (pixmaps[i].pPix))

+	    {

+		for (i = 0; i < npixmaps; i++) {

+		    if (!exaPixmapIsDirty (pixmaps[i].pPix))

+			exaDoMoveOutPixmap (pixmaps + i);

+		}

+		return;

+	    }

+	}

+

+	/* If we aren't going to accelerate, then we migrate everybody toward

+	 * system memory, and kick out if it's free.

+	 */

+	if (!can_accel) {

+	    for (i = 0; i < npixmaps; i++) {

+		exaMigrateTowardSys (pixmaps + i);

+		if (!exaPixmapIsDirty (pixmaps[i].pPix))

+		    exaDoMoveOutPixmap (pixmaps + i);

+	    }

+	    return;

+	}

+

+	/* Finally, the acceleration path.  Move them all in. */

+	for (i = 0; i < npixmaps; i++) {

+	    exaMigrateTowardFb(pixmaps + i);

+	    exaDoMoveInPixmap(pixmaps + i);

+	}

+    } else if (pExaScr->migration == ExaMigrationGreedy) {

+	/* If we can't accelerate, either because the driver can't or because one of

+	 * the pixmaps is pinned in system memory, then we migrate everybody toward

+	 * system memory.

+	 *

+	 * We also migrate toward system if all pixmaps involved are currently in

+	 * system memory -- this can mitigate thrashing when there are significantly

+	 * more pixmaps active than would fit in memory.

+	 *

+	 * If not, then we migrate toward FB so that hopefully acceleration can

+	 * happen.

+	 */

+	if (!can_accel) {

+	    for (i = 0; i < npixmaps; i++)

+		exaMigrateTowardSys (pixmaps + i);

+	    return;

+	}

+

+	for (i = 0; i < npixmaps; i++) {

+	    if (exaPixmapIsOffscreen(pixmaps[i].pPix)) {

+		/* Found one in FB, so move all to FB. */

+		for (j = 0; j < npixmaps; j++)

+		    exaMigrateTowardFb(pixmaps + i);

+		return;

+	    }

+	}

+

+	/* Nobody's in FB, so move all away from FB. */

+	for (i = 0; i < npixmaps; i++)

+	    exaMigrateTowardSys(pixmaps + i);

+    } else if (pExaScr->migration == ExaMigrationAlways) {

+	/* Always move the pixmaps out if we can't accelerate.  If we can

+	 * accelerate, try to move them all in.  If that fails, then move them

+	 * back out.

+	 */

+	if (!can_accel) {

+	    for (i = 0; i < npixmaps; i++)

+		exaDoMoveOutPixmap(pixmaps + i);

+	    return;

+	}

+

+	/* Now, try to move them all into FB */

+	for (i = 0; i < npixmaps; i++) {

+	    exaDoMoveInPixmap(pixmaps + i);

+	}

+

+	/* If we couldn't fit everything in, abort */

+	for (i = 0; i < npixmaps; i++) {

+	    if (!exaPixmapIsOffscreen(pixmaps[i].pPix)) {

+		return;

+	    }

+	}

+

+	/* Yay, everything's offscreen, mark memory as used */

+	for (i = 0; i < npixmaps; i++) {

+	    ExaOffscreenMarkUsed (pixmaps[i].pPix);

+	}

+    }

+}

+

+void

+exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg)

+{

+    ExaMigrationRec pixmaps[1];

+

+    if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {

+	pixmaps[0].as_dst = TRUE;

+	pixmaps[0].as_src = FALSE;

+    } else {

+	pixmaps[0].as_dst = FALSE;

+	pixmaps[0].as_src = TRUE;

+    }

+    pixmaps[0].pPix = pPixmap;

+    pixmaps[0].pReg = pReg;

+

+    exaDoMigration(pixmaps, 1, FALSE);

+

+    (void)ExaDoPrepareAccess(pPixmap, index);

+}

diff --git a/xorg-server/exa/exa_migration_mixed.c b/xorg-server/exa/exa_migration_mixed.c
index d1ee9871b..f42c9c233 100644
--- a/xorg-server/exa/exa_migration_mixed.c
+++ b/xorg-server/exa/exa_migration_mixed.c
@@ -31,55 +31,16 @@
 #include "exa_priv.h"
 #include "exa.h"
 
-static void
-exaUploadFallback(PixmapPtr pPixmap, CARD8 *src, int src_pitch)
-{
-    ExaPixmapPriv(pPixmap);
-    RegionPtr damage = DamageRegion (pExaPixmap->pDamage);
-    GCPtr pGC = GetScratchGC (pPixmap->drawable.depth,
-		pPixmap->drawable.pScreen);
-    int nbox, cpp = pPixmap->drawable.bitsPerPixel / 8;
-    DamagePtr backup = pExaPixmap->pDamage;
-    BoxPtr pbox;
-    CARD8 *src2;
-
-    /* We don't want damage optimisations. */
-    pExaPixmap->pDamage = NULL;
-    ValidateGC (&pPixmap->drawable, pGC);
-
-    pbox = REGION_RECTS(damage);
-    nbox = REGION_NUM_RECTS(damage);
-
-    while (nbox--) {
-	src2 = src + pbox->y1 * src_pitch + pbox->x1 * cpp;
-
-	ExaCheckPutImage(&pPixmap->drawable, pGC,
-	    pPixmap->drawable.depth, pbox->x1, pbox->y1,
-	    pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, 0,
-	    ZPixmap, (char*) src2);
-
-	pbox++;
-    }
-
-    FreeScratchGC (pGC);
-    pExaPixmap->pDamage = backup;
-}
-
 void
 exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
 {
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPriv(pScreen);
     ExaPixmapPriv(pPixmap);
-    RegionPtr damage = DamageRegion (pExaPixmap->pDamage);
-    void *sys_buffer = pExaPixmap->sys_ptr;
     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 sys_pitch = pExaPixmap->sys_pitch;
-    int paddedWidth = sys_pitch;
-    int nbox;
-    BoxPtr pbox;
+    int paddedWidth = pExaPixmap->sys_pitch;
 
     /* Already done. */
     if (pExaPixmap->driverPriv)
@@ -105,50 +66,8 @@ exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
     if (!pExaPixmap->driverPriv)
 	return;
 
-    pExaPixmap->offscreen = TRUE;
-    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr = NULL;
-    pExaPixmap->sys_pitch = pPixmap->devKind = 0;
-
-    pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
     (*pScreen->ModifyPixmapHeader)(pPixmap, w, h, 0, 0,
 				paddedWidth, NULL);
-
-    /* scratch pixmaps */
-    if (!w || !h)
-	goto finish;
-
-    /* we do not malloc memory by default. */
-    if (!sys_buffer)
-	goto finish;
-
-    if (!pExaScr->info->UploadToScreen)
-	goto fallback;
-
-    pbox = REGION_RECTS(damage);
-    nbox = REGION_NUM_RECTS(damage);
-
-    while (nbox--) {
-	if (!pExaScr->info->UploadToScreen(pPixmap, pbox->x1, pbox->y1, pbox->x2 - pbox->x1,
-		pbox->y2 - pbox->y1, (char *) (sys_buffer) + pbox->y1 * sys_pitch + pbox->x1 * (bpp / 8), sys_pitch))
-	    goto fallback;
-
-	pbox++;
-    }
-
-    goto finish;
-
-fallback:
-    exaUploadFallback(pPixmap, sys_buffer, sys_pitch);
-
-finish:
-    free(sys_buffer);
-
-    /* We no longer need this. */
-    if (pExaPixmap->pDamage) {
-	DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
-	DamageDestroy(pExaPixmap->pDamage);
-	pExaPixmap->pDamage = NULL;
-    }
 }
 
 void
@@ -175,8 +94,16 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
     for (i = 0; i < npixmaps; i++) {
 	PixmapPtr pPixmap = pixmaps[i].pPix;
 	ExaPixmapPriv(pPixmap);
+
 	if (!pExaPixmap->driverPriv)
 	    exaCreateDriverPixmap_mixed(pPixmap);
+
+	if (pExaPixmap->pDamage && exaPixmapIsOffscreen(pPixmap)) {
+	    pPixmap->devKind = pExaPixmap->fb_pitch;
+	    exaCopyDirtyToFb(pixmaps + i);
+	}
+
+	pExaPixmap->offscreen = exaPixmapIsOffscreen(pPixmap);
     }
 }
 
@@ -192,3 +119,91 @@ exaMoveInPixmap_mixed(PixmapPtr pPixmap)
 
     exaDoMigration(pixmaps, 1, TRUE);
 }
+
+/* With mixed pixmaps, if we fail to get direct access to the driver pixmap, we
+ * use the DownloadFromScreen hook to retrieve contents to a copy in system
+ * memory, perform software rendering on that and move back the results with the
+ * UploadToScreen hook (see exaFinishAccess_mixed).
+ */
+void
+exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
+{
+    if (!ExaDoPrepareAccess(pPixmap, index)) {
+	ExaPixmapPriv(pPixmap);
+	Bool is_offscreen = exaPixmapIsOffscreen(pPixmap);
+	ExaMigrationRec pixmaps[1];
+
+	/* Do we need to allocate our system buffer? */
+	if (!pExaPixmap->sys_ptr) {
+	    pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch *
+					 pPixmap->drawable.height);
+	    if (!pExaPixmap->sys_ptr)
+		FatalError("EXA: malloc failed for size %d bytes\n",
+			   pExaPixmap->sys_pitch * pPixmap->drawable.height);
+	}
+
+	if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
+	    pixmaps[0].as_dst = TRUE;
+	    pixmaps[0].as_src = FALSE;
+	} else {
+	    pixmaps[0].as_dst = FALSE;
+	    pixmaps[0].as_src = TRUE;
+	}
+	pixmaps[0].pPix = pPixmap;
+	pixmaps[0].pReg = pReg;
+
+	if (!pExaPixmap->pDamage && (is_offscreen || !exaPixmapIsPinned(pPixmap))) {
+	    Bool as_dst = pixmaps[0].as_dst;
+
+	    /* Set up damage tracking */
+	    pExaPixmap->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
+					       TRUE, pPixmap->drawable.pScreen,
+					       pPixmap);
+
+	    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);
+
+	    if (is_offscreen) {
+		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
+			       pPixmap->drawable.height);
+
+		/* We don't know which region of the destination will be damaged,
+		 * have to assume all of it
+		 */
+		if (as_dst) {
+		    pixmaps[0].as_dst = FALSE;
+		    pixmaps[0].as_src = TRUE;
+		    pixmaps[0].pReg = NULL;
+		}
+		pPixmap->devKind = pExaPixmap->fb_pitch;
+		exaCopyDirtyToSys(pixmaps);
+	    }
+
+	    if (as_dst)
+		exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
+			       pPixmap->drawable.height);
+	} else if (is_offscreen) {
+	    pPixmap->devKind = pExaPixmap->fb_pitch;
+	    exaCopyDirtyToSys(pixmaps);
+	}
+
+	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
+	pPixmap->devKind = pExaPixmap->sys_pitch;
+	pExaPixmap->offscreen = FALSE;
+    }
+}
+
+/* Move back results of software rendering on system memory copy of mixed driver
+ * pixmap (see exaPrepareAccessReg_mixed).
+ */
+void exaFinishAccess_mixed(PixmapPtr pPixmap, int index)
+{
+    ExaPixmapPriv(pPixmap);
+
+    if (pExaPixmap->pDamage && exaPixmapIsOffscreen(pPixmap)) {
+	DamageRegionProcessPending(&pPixmap->drawable);
+	exaMoveInPixmap_mixed(pPixmap);
+    }
+}
diff --git a/xorg-server/exa/exa_mixed.c b/xorg-server/exa/exa_mixed.c
index 01f87ba87..167ffa9d5 100644
--- a/xorg-server/exa/exa_mixed.c
+++ b/xorg-server/exa/exa_mixed.c
@@ -32,8 +32,6 @@
 #include "exa.h"
 
 /* This file holds the driver allocated pixmaps + better initial placement code.
- * A pinned pixmap implies one that is either driver based already or otherwise altered.
- * Proper care is taken to free the initially allocated buffer.
  */
 
 static _X_INLINE void*
@@ -46,9 +44,6 @@ ExaGetPixmapAddress(PixmapPtr p)
 
 /**
  * exaCreatePixmap() creates a new pixmap.
- *
- * Pixmaps are always marked as pinned, unless the pixmap can still be transfered to a
- * driver pixmaps.
  */
 PixmapPtr
 exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
@@ -57,7 +52,7 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
     PixmapPtr pPixmap;
     ExaPixmapPrivPtr	pExaPixmap;
     int bpp;
-    size_t paddedWidth, datasize;
+    size_t paddedWidth;
     ExaScreenPriv(pScreen);
 
     if (w > 32767 || h > 32767)
@@ -79,15 +74,12 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
     if (paddedWidth / 4 > 32767 || h > 32767)
         return NullPixmap;
 
-    datasize = h * paddedWidth;
-
     /* We will allocate the system pixmap later if needed. */
     pPixmap->devPrivate.ptr = NULL;
     pExaPixmap->sys_ptr = NULL;
     pExaPixmap->sys_pitch = paddedWidth;
 
     pExaPixmap->area = NULL;
-    pExaPixmap->offscreen = FALSE;
     pExaPixmap->fb_ptr = NULL;
     pExaPixmap->pDamage = NULL;
 
@@ -95,36 +87,15 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
     exaSetAccelBlock(pExaScr, pExaPixmap,
 	w, h, bpp);
 
-    /* Avoid freeing sys_ptr. */
-    pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
-
     (*pScreen->ModifyPixmapHeader)(pPixmap, w, h, 0, 0,
 				    paddedWidth, NULL);
 
-    /* We want to be able to transfer the pixmap to driver memory later on. */
-    pExaPixmap->score = EXA_PIXMAP_SCORE_INIT;
-
     /* A scratch pixmap will become a driver pixmap right away. */
     if (!w || !h) {
 	exaCreateDriverPixmap_mixed(pPixmap);
-    } else {
-	/* 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->offscreen = exaPixmapIsOffscreen(pPixmap);
+    } else
+	pExaPixmap->offscreen = FALSE;
 
     return pPixmap;
 }
@@ -136,7 +107,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     ScreenPtr pScreen = pPixmap->drawable.pScreen;
     ExaScreenPrivPtr pExaScr;
     ExaPixmapPrivPtr pExaPixmap;
-    Bool ret;
+    Bool ret, is_offscreen;
 
     if (!pPixmap)
         return FALSE;
@@ -144,26 +115,23 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     pExaScr = ExaGetScreenPriv(pScreen);
     pExaPixmap = ExaGetPixmapPriv(pPixmap);
 
-    if (pExaPixmap) {
-	if (!exaPixmapIsPinned(pPixmap)) {
-	    free(pExaPixmap->sys_ptr);
-	    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr = NULL;
-	    pExaPixmap->sys_pitch = pPixmap->devKind = 0;
-
-	    /* We no longer need this. */
+    if (pPixData) {
+	if (pExaPixmap->driverPriv) {
 	    if (pExaPixmap->pDamage) {
 		DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
 		DamageDestroy(pExaPixmap->pDamage);
 		pExaPixmap->pDamage = NULL;
 	    }
-	}
 
-        if (pPixData)
-            pExaPixmap->sys_ptr = pPixData;
+	    pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
+	    pExaPixmap->driverPriv = NULL;
+	}
 
-        if (devKind > 0)
-            pExaPixmap->sys_pitch = devKind;
+	pExaPixmap->offscreen = FALSE;
+	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
+    }
 
+    if (pExaPixmap->driverPriv) {
         if (width > 0 && height > 0 && bitsPerPixel > 0) {
             exaSetFbPitch(pExaScr, pExaPixmap,
                           width, height, bitsPerPixel);
@@ -171,9 +139,15 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
             exaSetAccelBlock(pExaScr, pExaPixmap,
                              width, height, bitsPerPixel);
         }
+    }
 
-	/* Anything can happen, don't try to predict it all. */
-	pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
+    is_offscreen = exaPixmapIsOffscreen(pPixmap);
+    if (is_offscreen) {
+	pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
+	pPixmap->devKind = pExaPixmap->fb_pitch;
+    } else {
+	pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
+	pPixmap->devKind = pExaPixmap->sys_pitch;
     }
 
     /* Only pass driver pixmaps to the driver. */
@@ -184,10 +158,6 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
 	 * If pPixmap->devPrivate.ptr is non-NULL, then we've got a non-offscreen pixmap.
 	 * We need to store the pointer, because PrepareAccess won't be called.
 	 */
-	if (!pPixData && pPixmap->devPrivate.ptr && pPixmap->devKind) {
-	    pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
-	    pExaPixmap->sys_pitch = pPixmap->devKind;
-	}
 	if (ret == TRUE)
 	    goto out;
     }
@@ -198,6 +168,13 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
     swap(pExaScr, pScreen, ModifyPixmapHeader);
 
 out:
+    if (is_offscreen) {
+	pExaPixmap->fb_ptr = pPixmap->devPrivate.ptr;
+	pExaPixmap->fb_pitch = pPixmap->devKind;
+    } else {
+	pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
+	pExaPixmap->sys_pitch = pPixmap->devKind;
+    }
     /* Always NULL this, we don't want lingering pointers. */
     pPixmap->devPrivate.ptr = NULL;
 
@@ -217,10 +194,14 @@ exaDestroyPixmap_mixed(PixmapPtr pPixmap)
 
 	if (pExaPixmap->driverPriv)
 	    pExaScr->info->DestroyPixmap(pScreen, pExaPixmap->driverPriv);
-	else if (pExaPixmap->sys_ptr && !exaPixmapIsPinned(pPixmap))
-	    free(pExaPixmap->sys_ptr);
 	pExaPixmap->driverPriv = NULL;
-	pExaPixmap->sys_ptr = NULL;
+
+	if (pExaPixmap->pDamage) {
+	    if (pExaPixmap->sys_ptr)
+		free(pExaPixmap->sys_ptr);
+	    pExaPixmap->sys_ptr = NULL;
+	    pExaPixmap->pDamage = NULL;
+	}
     }
 
     swap(pExaScr, pScreen, DestroyPixmap);
diff --git a/xorg-server/exa/exa_priv.h b/xorg-server/exa/exa_priv.h
index 869cf1772..1aec8e966 100644
--- a/xorg-server/exa/exa_priv.h
+++ b/xorg-server/exa/exa_priv.h
@@ -176,6 +176,8 @@ typedef struct {
     Bool (*pixmap_is_offscreen) (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);
+    void (*finish_access)(PixmapPtr pPixmap, int index);
 
     Bool			 swappedOut;
     enum ExaMigrationHeuristic	 migration;
@@ -511,10 +513,7 @@ ExaOffscreenFini (ScreenPtr pScreen);
 
 /* exa.c */
 Bool
-ExaDoPrepareAccess(DrawablePtr pDrawable, int index);
-
-void
-exaPrepareAccessReg(DrawablePtr pDrawable, int index, RegionPtr pReg);
+ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
 
 void
 exaPrepareAccess(DrawablePtr pDrawable, int index);
@@ -609,6 +608,12 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
 void
 exaMoveInPixmap_mixed(PixmapPtr pPixmap);
 
+void
+exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
+
+void
+exaFinishAccess_mixed(PixmapPtr pPixmap, int index);
+
 /* exa_render.c */
 Bool
 exaOpReadsDestination (CARD8 op);
@@ -665,6 +670,12 @@ exaGlyphs (CARD8	op,
 
 /* exa_migration_classic.c */
 void
+exaCopyDirtyToSys (ExaMigrationPtr migrate);
+
+void
+exaCopyDirtyToFb (ExaMigrationPtr migrate);
+
+void
 exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
 
 void
@@ -676,4 +687,7 @@ exaMoveOutPixmap_classic (PixmapPtr pPixmap);
 void
 exaMoveInPixmap_classic (PixmapPtr pPixmap);
 
+void
+exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
+
 #endif /* EXAPRIV_H */
diff --git a/xorg-server/exa/exa_render.c b/xorg-server/exa/exa_render.c
index d46930130..1c1856610 100644
--- a/xorg-server/exa/exa_render.c
+++ b/xorg-server/exa/exa_render.c
@@ -266,6 +266,10 @@ exaTryDriverSolidFill(PicturePtr	pSrc,
 
     xDst += pDst->pDrawable->x;
     yDst += pDst->pDrawable->y;
+    if (pSrc->pDrawable) {
+	xSrc += pSrc->pDrawable->x;
+	ySrc += pSrc->pDrawable->y;
+    }
 
     if (!miComputeCompositeRegion (&region, pSrc, NULL, pDst,
 				   xSrc, ySrc, 0, 0, xDst, yDst,
@@ -277,9 +281,6 @@ exaTryDriverSolidFill(PicturePtr	pSrc,
     REGION_TRANSLATE(pScreen, &region, dst_off_x, dst_off_y);
 
     if (pSrc->pDrawable) {
-	xSrc += pSrc->pDrawable->x;
-	ySrc += pSrc->pDrawable->y;
-
 	pSrcPix = exaGetDrawablePixmap (pSrc->pDrawable);
 	pixel = exaGetPixmapFirstPixel (pSrcPix);
     } else
@@ -340,7 +341,8 @@ exaTryDriverCompositeRects(CARD8	       op,
 			   ExaCompositeRectPtr rects)
 {
     ExaScreenPriv (pDst->pDrawable->pScreen);
-    int src_off_x, src_off_y, mask_off_x, mask_off_y, dst_off_x, dst_off_y;
+    int src_off_x = 0, src_off_y = 0, mask_off_x = 0, mask_off_y = 0;
+    int dst_off_x, dst_off_y;
     PixmapPtr pSrcPix = NULL, pMaskPix = NULL, pDstPix;
     ExaPixmapPrivPtr pSrcExaPix = NULL, pMaskExaPix = NULL, pDstExaPix;
 
@@ -656,7 +658,7 @@ exaTryDriverComposite(CARD8		op,
      */
     if (pDstExaPix->accel_blocked ||
 	(pSrcExaPix && pSrcExaPix->accel_blocked) ||
-	(pMask && (pMaskExaPix->accel_blocked)))
+	(pMaskExaPix && (pMaskExaPix->accel_blocked)))
     {
 	return -1;
     }
diff --git a/xorg-server/exa/exa_unaccel.c b/xorg-server/exa/exa_unaccel.c
index 7e26feb83..d7958066b 100644
--- a/xorg-server/exa/exa_unaccel.c
+++ b/xorg-server/exa/exa_unaccel.c
@@ -1,528 +1,536 @@
-/*
- *
- * Copyright © 1999 Keith Packard
- *
- * 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.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD 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.
- */
-
-#include "exa_priv.h"
-
-#ifdef RENDER
-#include "mipict.h"
-#endif
-
-/*
- * These functions wrap the low-level fb rendering functions and
- * synchronize framebuffer/accelerated drawing by stalling until
- * the accelerator is idle
- */
-
-/**
- * Calls exaPrepareAccess with EXA_PREPARE_SRC for the tile, if that is the
- * current fill style.
- *
- * Solid doesn't use an extra pixmap source, and Stippled/OpaqueStippled are
- * 1bpp and never in fb, so we don't worry about them.
- * We should worry about them for completeness sake and going forward.
- */
-void
-exaPrepareAccessGC(GCPtr pGC)
-{
-    if (pGC->stipple)
-        exaPrepareAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
-    if (pGC->fillStyle == FillTiled)
-	exaPrepareAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
-}
-
-/**
- * Finishes access to the tile in the GC, if used.
- */
-void
-exaFinishAccessGC(GCPtr pGC)
-{
-    if (pGC->fillStyle == FillTiled)
-	exaFinishAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
-    if (pGC->stipple)
-        exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
-}
-
-#if DEBUG_TRACE_FALL
-char
-exaDrawableLocation(DrawablePtr pDrawable)
-{
-    return exaDrawableIsOffscreen(pDrawable) ? 's' : 'm';
-}
-#endif /* DEBUG_TRACE_FALL */
-
-void
-ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans,
-		   DDXPointPtr ppt, int *pwidth, int fSorted)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->FillSpans (pDrawable, pGC, nspans, ppt, pwidth, fSorted);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,
-		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    pGC->ops->SetSpans (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
-		 int x, int y, int w, int h, int leftPad, int format,
-		 char *bits)
-{
-    ExaPixmapPriv(exaGetDrawablePixmap(pDrawable));
-
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    if (exaGCReadsDestination(pDrawable, pGC->planemask, pGC->fillStyle,
-			      pGC->alu, pGC->clientClipType))
-	exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    else
-	exaPrepareAccessReg (pDrawable, EXA_PREPARE_DEST, pExaPixmap->pDamage ?
-			     DamagePendingRegion(pExaPixmap->pDamage) : NULL);
-    pGC->ops->PutImage (pDrawable, pGC, depth, x, y, w, h, leftPad, format, bits);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
-	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 
-	     Bool upsidedown, Pixel bitplane, void *closure)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);
-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);
-    /* This will eventually call fbCopyNtoN, with some calculation overhead. */
-    while (nbox--) {
-	pGC->ops->CopyArea (pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx, pbox->y1 - pSrc->y + dy, 
-			pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, pbox->x1 - pDst->x, pbox->y1 - pDst->y);
-	pbox++;
-    }
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-RegionPtr
-ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		 int srcx, int srcy, int w, int h, int dstx, int dsty)
-{
-    RegionPtr ret;
-
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);
-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);
-    ret = pGC->ops->CopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-
-    return ret;
-}
-
-RegionPtr
-ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		  int srcx, int srcy, int w, int h, int dstx, int dsty,
-		  unsigned long bitPlane)
-{
-    RegionPtr ret;
-
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
-    exaPrepareAccess (pDst, EXA_PREPARE_DEST);
-    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);
-    ret = pGC->ops->CopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty,
-		       bitPlane);
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-
-    return ret;
-}
-
-void
-ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
-		  DDXPointPtr pptInit)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    pGC->ops->PolyPoint (pDrawable, pGC, mode, npt, pptInit);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr ppt)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c), width %d, mode %d, count %d\n",
-		  pDrawable, exaDrawableLocation(pDrawable),
-		  pGC->lineWidth, mode, npt));
-
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->Polylines (pDrawable, pGC, mode, npt, ppt);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
-		    int nsegInit, xSegment *pSegInit)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c) width %d, count %d\n", pDrawable,
-		  exaDrawableLocation(pDrawable), pGC->lineWidth, nsegInit));
-
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolySegment (pDrawable, pGC, nsegInit, pSegInit);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
-		int narcs, xArc *pArcs)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyArc (pDrawable, pGC, narcs, pArcs);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
-		     int nrect, xRectangle *prect)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyFillRect (pDrawable, pGC, nrect, prect);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		      int x, int y, unsigned int nglyph,
-		      CharInfoPtr *ppci, pointer pglyphBase)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable,
-		  exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->ImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		     int x, int y, unsigned int nglyph,
-		     CharInfoPtr *ppci, pointer pglyphBase)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("to %p (%c), style %d alu %d\n", pDrawable,
-		  exaDrawableLocation(pDrawable), pGC->fillStyle, pGC->alu));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
-		   DrawablePtr pDrawable,
-		   int w, int h, int x, int y)
-{
-    EXA_GC_PROLOGUE(pGC);
-    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pBitmap, pDrawable,
-		  exaDrawableLocation(&pBitmap->drawable),
-		  exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccess (&pBitmap->drawable, EXA_PREPARE_SRC);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PushPixels (pGC, pBitmap, pDrawable, w, h, x, y);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (&pBitmap->drawable, EXA_PREPARE_SRC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
-    EXA_GC_EPILOGUE(pGC);
-}
-
-void
-ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
-    DrawablePtr pDrawable = &pWin->drawable;
-    ScreenPtr pScreen = pDrawable->pScreen;
-    ExaScreenPriv(pScreen);
-    EXA_FALLBACK(("from %p\n", pWin));
-
-    /* being both src and dest, src is safest. */
-    exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);
-    swap(pExaScr, pScreen, CopyWindow);
-    pScreen->CopyWindow (pWin, ptOldOrg, prgnSrc);
-    swap(pExaScr, pScreen, CopyWindow);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
-}
-
-void
-ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
-		unsigned int format, unsigned long planeMask, char *d)
-{
-    BoxRec Box;
-    RegionRec Reg;
-    int xoff, yoff;
-    ScreenPtr pScreen = pDrawable->pScreen;
-    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);
-    ExaScreenPriv(pScreen);
-
-    EXA_FALLBACK(("from %p (%c)\n", pDrawable,
-		  exaDrawableLocation(pDrawable)));
-
-    exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);
-
-    Box.x1 = pDrawable->y + x + xoff;
-    Box.y1 = pDrawable->y + y + yoff;
-    Box.x2 = Box.x1 + w;
-    Box.y2 = Box.y1 + h;
-
-    REGION_INIT(pScreen, &Reg, &Box, 1);
-
-    exaPrepareAccessReg (pDrawable, EXA_PREPARE_SRC, &Reg);
-    swap(pExaScr, pScreen, GetImage);
-    pScreen->GetImage (pDrawable, x, y, w, h, format, planeMask, d);
-    swap(pExaScr, pScreen, GetImage);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
-}
-
-void
-ExaCheckGetSpans (DrawablePtr pDrawable,
-		 int wMax,
-		 DDXPointPtr ppt,
-		 int *pwidth,
-		 int nspans,
-		 char *pdstStart)
-{
-    ScreenPtr pScreen = pDrawable->pScreen;
-    ExaScreenPriv(pScreen);
-
-    EXA_FALLBACK(("from %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_SRC);
-    swap(pExaScr, pScreen, GetSpans);
-    pScreen->GetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
-    swap(pExaScr, pScreen, GetSpans);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
-}
-
-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)
-{
-    ScreenPtr pScreen = pDst->pDrawable->pScreen;
-#ifdef RENDER
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
-#endif /* RENDER */
-    ExaScreenPriv(pScreen);
-    RegionRec region;
-    int xoff, yoff;
-
-    REGION_NULL(pScreen, &region);
-
-    /* We need to prepare access to any separate alpha maps first, in case the
-     * driver doesn't support EXA_PREPARE_AUX*, in which case EXA_PREPARE_SRC
-     * may be used for moving them out.
-     */
-    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
-	exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
-    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
-	exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
-
-    if (!exaOpReadsDestination(op)) {
-	if (!miComputeCompositeRegion (&region, pSrc, pMask, pDst,
-				       xSrc, ySrc, xMask, yMask, xDst, yDst,
-				       width, height))
-	    goto skip;
-
-	exaGetDrawableDeltas (pDst->pDrawable,
-			      exaGetDrawablePixmap(pDst->pDrawable),
-			      &xoff, &yoff);
-
-	REGION_TRANSLATE(pScreen, &region, xoff, yoff);
-
-	if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	    exaPrepareAccessReg(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST,
-				&region);
-
-	exaPrepareAccessReg (pDst->pDrawable, EXA_PREPARE_DEST, &region);
-    } else {
-	if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	    exaPrepareAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
-
-	exaPrepareAccess (pDst->pDrawable, EXA_PREPARE_DEST);
-    }
-
-    EXA_FALLBACK(("from picts %p/%p to pict %p\n",
-		 pSrc, pMask, pDst));
-
-    if (pSrc->pDrawable != NULL)
-	exaPrepareAccess (pSrc->pDrawable, EXA_PREPARE_SRC);
-    if (pMask && pMask->pDrawable != NULL)
-	exaPrepareAccess (pMask->pDrawable, EXA_PREPARE_MASK);
-#ifdef RENDER
-    swap(pExaScr, ps, Composite);
-    ps->Composite (op,
-                 pSrc,
-                 pMask,
-                 pDst,
-                 xSrc,
-                 ySrc,
-                 xMask,
-                 yMask,
-                 xDst,
-                 yDst,
-                 width,
-                 height);
-    swap(pExaScr, ps, Composite);
-#endif /* RENDER */
-    if (pMask && pMask->pDrawable != NULL)
-	exaFinishAccess (pMask->pDrawable, EXA_PREPARE_MASK);
-    if (pSrc->pDrawable != NULL)
-	exaFinishAccess (pSrc->pDrawable, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst->pDrawable, EXA_PREPARE_DEST);
-    if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	exaFinishAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
-
-skip:
-    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
-	exaFinishAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
-    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
-	exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
-
-    REGION_UNINIT(pScreen, &region);
-}
-
-void
-ExaCheckAddTraps (PicturePtr	pPicture,
-		  INT16		x_off,
-		  INT16		y_off,
-		  int		ntrap,
-		  xTrap		*traps)
-{
-    ScreenPtr pScreen = pPicture->pDrawable->pScreen;
-#ifdef RENDER
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
-#endif /* RENDER */
-    ExaScreenPriv(pScreen);
-
-    EXA_FALLBACK(("to pict %p (%c)\n",
-		  exaDrawableLocation(pPicture->pDrawable)));
-    exaPrepareAccess(pPicture->pDrawable, EXA_PREPARE_DEST);
-#ifdef RENDER
-    swap(pExaScr, ps, AddTraps);
-    ps->AddTraps (pPicture, x_off, y_off, ntrap, traps);
-    swap(pExaScr, ps, AddTraps);
-#endif /* RENDER */
-    exaFinishAccess(pPicture->pDrawable, EXA_PREPARE_DEST);
-}
-
-/**
- * Gets the 0,0 pixel of a pixmap.  Used for doing solid fills of tiled pixmaps
- * that happen to be 1x1.  Pixmap must be at least 8bpp.
- */
-CARD32
-exaGetPixmapFirstPixel (PixmapPtr pPixmap)
-{
-    switch (pPixmap->drawable.bitsPerPixel) {
-    case 32:
-	{
-	    CARD32 pixel;
-
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
-    case 16:
-	{
-	    CARD16 pixel;
-
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
-    case 8:
-	{
-	    CARD8 pixel;
-
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
-    default:
-	FatalError("%s called for invalid bpp %d\n", __FUNCTION__,
-		   pPixmap->drawable.bitsPerPixel);
-    }
-}
+/*

+ *

+ * Copyright © 1999 Keith Packard

+ *

+ * 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.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD 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.

+ */

+

+#include "exa_priv.h"

+

+#ifdef RENDER

+#include "mipict.h"

+#endif

+

+/*

+ * These functions wrap the low-level fb rendering functions and

+ * synchronize framebuffer/accelerated drawing by stalling until

+ * the accelerator is idle

+ */

+

+/**

+ * Calls exaPrepareAccess with EXA_PREPARE_SRC for the tile, if that is the

+ * current fill style.

+ *

+ * Solid doesn't use an extra pixmap source, and Stippled/OpaqueStippled are

+ * 1bpp and never in fb, so we don't worry about them.

+ * We should worry about them for completeness sake and going forward.

+ */

+void

+exaPrepareAccessGC(GCPtr pGC)

+{

+    if (pGC->stipple)

+        exaPrepareAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);

+    if (pGC->fillStyle == FillTiled)

+	exaPrepareAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);

+}

+

+/**

+ * Finishes access to the tile in the GC, if used.

+ */

+void

+exaFinishAccessGC(GCPtr pGC)

+{

+    if (pGC->fillStyle == FillTiled)

+	exaFinishAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);

+    if (pGC->stipple)

+        exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);

+}

+

+#if DEBUG_TRACE_FALL

+char

+exaDrawableLocation(DrawablePtr pDrawable)

+{

+    return exaDrawableIsOffscreen(pDrawable) ? 's' : 'm';

+}

+#endif /* DEBUG_TRACE_FALL */

+

+void

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

+		   DDXPointPtr ppt, int *pwidth, int fSorted)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->FillSpans (pDrawable, pGC, nspans, ppt, pwidth, fSorted);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

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

+		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    pGC->ops->SetSpans (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

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

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

+		 char *bits)

+{

+    PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);

+    ExaPixmapPriv(pPixmap);

+    ExaScreenPriv(pDrawable->pScreen);

+

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    if (!pExaScr->prepare_access_reg || !pExaPixmap->pDamage ||

+	exaGCReadsDestination(pDrawable, pGC->planemask, pGC->fillStyle,

+			      pGC->alu, pGC->clientClipType))

+	exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    else

+	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST,

+				    DamagePendingRegion(pExaPixmap->pDamage));

+    pGC->ops->PutImage (pDrawable, pGC, depth, x, y, w, h, leftPad, format, bits);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

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

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

+	     Bool upsidedown, Pixel bitplane, void *closure)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

+		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

+    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

+    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+    /* This will eventually call fbCopyNtoN, with some calculation overhead. */

+    while (nbox--) {

+	pGC->ops->CopyArea (pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx, pbox->y1 - pSrc->y + dy, 

+			pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, pbox->x1 - pDst->x, pbox->y1 - pDst->y);

+	pbox++;

+    }

+    exaFinishAccess (pSrc, EXA_PREPARE_SRC);

+    exaFinishAccess (pDst, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+RegionPtr

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

+		 int srcx, int srcy, int w, int h, int dstx, int dsty)

+{

+    RegionPtr ret;

+

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

+		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

+    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

+    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+    ret = pGC->ops->CopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);

+    exaFinishAccess (pSrc, EXA_PREPARE_SRC);

+    exaFinishAccess (pDst, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+

+    return ret;

+}

+

+RegionPtr

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

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

+		  unsigned long bitPlane)

+{

+    RegionPtr ret;

+

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,

+		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));

+    exaPrepareAccess (pDst, EXA_PREPARE_DEST);

+    exaPrepareAccess (pSrc, EXA_PREPARE_SRC);

+    ret = pGC->ops->CopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty,

+		       bitPlane);

+    exaFinishAccess (pSrc, EXA_PREPARE_SRC);

+    exaFinishAccess (pDst, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+

+    return ret;

+}

+

+void

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

+		  DDXPointPtr pptInit)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    pGC->ops->PolyPoint (pDrawable, pGC, mode, npt, pptInit);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,

+		  int mode, int npt, DDXPointPtr ppt)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c), width %d, mode %d, count %d\n",

+		  pDrawable, exaDrawableLocation(pDrawable),

+		  pGC->lineWidth, mode, npt));

+

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->Polylines (pDrawable, pGC, mode, npt, ppt);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,

+		    int nsegInit, xSegment *pSegInit)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c) width %d, count %d\n", pDrawable,

+		  exaDrawableLocation(pDrawable), pGC->lineWidth, nsegInit));

+

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->PolySegment (pDrawable, pGC, nsegInit, pSegInit);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,

+		int narcs, xArc *pArcs)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->PolyArc (pDrawable, pGC, narcs, pArcs);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,

+		     int nrect, xRectangle *prect)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->PolyFillRect (pDrawable, pGC, nrect, prect);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,

+		      int x, int y, unsigned int nglyph,

+		      CharInfoPtr *ppci, pointer pglyphBase)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c)\n", pDrawable,

+		  exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->ImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,

+		     int x, int y, unsigned int nglyph,

+		     CharInfoPtr *ppci, pointer pglyphBase)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("to %p (%c), style %d alu %d\n", pDrawable,

+		  exaDrawableLocation(pDrawable), pGC->fillStyle, pGC->alu));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->PolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,

+		   DrawablePtr pDrawable,

+		   int w, int h, int x, int y)

+{

+    EXA_GC_PROLOGUE(pGC);

+    EXA_FALLBACK(("from %p to %p (%c,%c)\n", pBitmap, pDrawable,

+		  exaDrawableLocation(&pBitmap->drawable),

+		  exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);

+    exaPrepareAccess (&pBitmap->drawable, EXA_PREPARE_SRC);

+    exaPrepareAccessGC (pGC);

+    pGC->ops->PushPixels (pGC, pBitmap, pDrawable, w, h, x, y);

+    exaFinishAccessGC (pGC);

+    exaFinishAccess (&pBitmap->drawable, EXA_PREPARE_SRC);

+    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);

+    EXA_GC_EPILOGUE(pGC);

+}

+

+void

+ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)

+{

+    DrawablePtr pDrawable = &pWin->drawable;

+    ScreenPtr pScreen = pDrawable->pScreen;

+    ExaScreenPriv(pScreen);

+    EXA_FALLBACK(("from %p\n", pWin));

+

+    /* being both src and dest, src is safest. */

+    exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);

+    swap(pExaScr, pScreen, CopyWindow);

+    pScreen->CopyWindow (pWin, ptOldOrg, prgnSrc);

+    swap(pExaScr, pScreen, CopyWindow);

+    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+}

+

+void

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

+		unsigned int format, unsigned long planeMask, char *d)

+{

+    ScreenPtr pScreen = pDrawable->pScreen;

+    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);

+    ExaScreenPriv(pScreen);

+

+    EXA_FALLBACK(("from %p (%c)\n", pDrawable,

+		  exaDrawableLocation(pDrawable)));

+

+    if (pExaScr->prepare_access_reg) {

+	int xoff, yoff;

+	BoxRec Box;

+	RegionRec Reg;

+

+	exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);

+

+	Box.x1 = pDrawable->y + x + xoff;

+	Box.y1 = pDrawable->y + y + yoff;

+	Box.x2 = Box.x1 + w;

+	Box.y2 = Box.y1 + h;

+

+	REGION_INIT(pScreen, &Reg, &Box, 1);

+

+	pExaScr->prepare_access_reg(pPix, EXA_PREPARE_SRC, &Reg);

+    } else

+	exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);

+

+    swap(pExaScr, pScreen, GetImage);

+    pScreen->GetImage (pDrawable, x, y, w, h, format, planeMask, d);

+    swap(pExaScr, pScreen, GetImage);

+    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+}

+

+void

+ExaCheckGetSpans (DrawablePtr pDrawable,

+		 int wMax,

+		 DDXPointPtr ppt,

+		 int *pwidth,

+		 int nspans,

+		 char *pdstStart)

+{

+    ScreenPtr pScreen = pDrawable->pScreen;

+    ExaScreenPriv(pScreen);

+

+    EXA_FALLBACK(("from %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));

+    exaPrepareAccess (pDrawable, EXA_PREPARE_SRC);

+    swap(pExaScr, pScreen, GetSpans);

+    pScreen->GetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);

+    swap(pExaScr, pScreen, GetSpans);

+    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);

+}

+

+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)

+{

+    ScreenPtr pScreen = pDst->pDrawable->pScreen;

+#ifdef RENDER

+    PictureScreenPtr	ps = GetPictureScreen(pScreen);

+#endif /* RENDER */

+    ExaScreenPriv(pScreen);

+    RegionRec region;

+    int xoff, yoff;

+

+    REGION_NULL(pScreen, &region);

+

+    /* We need to prepare access to any separate alpha maps first, in case the

+     * driver doesn't support EXA_PREPARE_AUX*, in which case EXA_PREPARE_SRC

+     * may be used for moving them out.

+     */

+    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

+	exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);

+    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

+	exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

+

+    if (!exaOpReadsDestination(op) && pExaScr->prepare_access_reg) {

+	PixmapPtr pDstPix;

+

+	if (!miComputeCompositeRegion (&region, pSrc, pMask, pDst,

+				       xSrc, ySrc, xMask, yMask, xDst, yDst,

+				       width, height))

+	    goto skip;

+

+	pDstPix = exaGetDrawablePixmap(pDst->pDrawable);

+	exaGetDrawableDeltas (pDst->pDrawable, pDstPix, &xoff, &yoff);

+	REGION_TRANSLATE(pScreen, &region, xoff, yoff);

+

+	if (pDst->alphaMap && pDst->alphaMap->pDrawable)

+	    pExaScr->prepare_access_reg(exaGetDrawablePixmap(pDst->alphaMap->pDrawable),

+					EXA_PREPARE_AUX_DEST, &region);

+

+	pExaScr->prepare_access_reg(pDstPix, EXA_PREPARE_DEST, &region);

+    } else {

+	if (pDst->alphaMap && pDst->alphaMap->pDrawable)

+	    exaPrepareAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);

+

+	exaPrepareAccess (pDst->pDrawable, EXA_PREPARE_DEST);

+    }

+

+    EXA_FALLBACK(("from picts %p/%p to pict %p\n",

+		 pSrc, pMask, pDst));

+

+    if (pSrc->pDrawable != NULL)

+	exaPrepareAccess (pSrc->pDrawable, EXA_PREPARE_SRC);

+    if (pMask && pMask->pDrawable != NULL)

+	exaPrepareAccess (pMask->pDrawable, EXA_PREPARE_MASK);

+#ifdef RENDER

+    swap(pExaScr, ps, Composite);

+    ps->Composite (op,

+                 pSrc,

+                 pMask,

+                 pDst,

+                 xSrc,

+                 ySrc,

+                 xMask,

+                 yMask,

+                 xDst,

+                 yDst,

+                 width,

+                 height);

+    swap(pExaScr, ps, Composite);

+#endif /* RENDER */

+    if (pMask && pMask->pDrawable != NULL)

+	exaFinishAccess (pMask->pDrawable, EXA_PREPARE_MASK);

+    if (pSrc->pDrawable != NULL)

+	exaFinishAccess (pSrc->pDrawable, EXA_PREPARE_SRC);

+    exaFinishAccess (pDst->pDrawable, EXA_PREPARE_DEST);

+    if (pDst->alphaMap && pDst->alphaMap->pDrawable)

+	exaFinishAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);

+

+skip:

+    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)

+	exaFinishAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);

+    if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)

+	exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);

+

+    REGION_UNINIT(pScreen, &region);

+}

+

+void

+ExaCheckAddTraps (PicturePtr	pPicture,

+		  INT16		x_off,

+		  INT16		y_off,

+		  int		ntrap,

+		  xTrap		*traps)

+{

+    ScreenPtr pScreen = pPicture->pDrawable->pScreen;

+#ifdef RENDER

+    PictureScreenPtr	ps = GetPictureScreen(pScreen);

+#endif /* RENDER */

+    ExaScreenPriv(pScreen);

+

+    EXA_FALLBACK(("to pict %p (%c)\n",

+		  exaDrawableLocation(pPicture->pDrawable)));

+    exaPrepareAccess(pPicture->pDrawable, EXA_PREPARE_DEST);

+#ifdef RENDER

+    swap(pExaScr, ps, AddTraps);

+    ps->AddTraps (pPicture, x_off, y_off, ntrap, traps);

+    swap(pExaScr, ps, AddTraps);

+#endif /* RENDER */

+    exaFinishAccess(pPicture->pDrawable, EXA_PREPARE_DEST);

+}

+

+/**

+ * Gets the 0,0 pixel of a pixmap.  Used for doing solid fills of tiled pixmaps

+ * that happen to be 1x1.  Pixmap must be at least 8bpp.

+ */

+CARD32

+exaGetPixmapFirstPixel (PixmapPtr pPixmap)

+{

+    switch (pPixmap->drawable.bitsPerPixel) {

+    case 32:

+	{

+	    CARD32 pixel;

+

+	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,

+						ZPixmap, ~0, (char*)&pixel);

+	    return pixel;

+	}

+    case 16:

+	{

+	    CARD16 pixel;

+

+	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,

+						ZPixmap, ~0, (char*)&pixel);

+	    return pixel;

+	}

+    case 8:

+	{

+	    CARD8 pixel;

+

+	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,

+						ZPixmap, ~0, (char*)&pixel);

+	    return pixel;

+	}

+    default:

+	FatalError("%s called for invalid bpp %d\n", __FUNCTION__,

+		   pPixmap->drawable.bitsPerPixel);

+    }

+}