/**
* Does fake acceleration of UploadToScreen using memcpy.
*/
static Bool
ephyrUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h, char *src,
int src_pitch)
{
KdScreenPriv(pDst->drawable.pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
EphyrFakexaPriv *fakexa = scrpriv->fakexa;
unsigned char *dst;
int dst_pitch, cpp;
if (pDst->drawable.bitsPerPixel < 8)
return FALSE;
ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST);
cpp = pDst->drawable.bitsPerPixel / 8;
dst_pitch = exaGetPixmapPitch(pDst);
dst = fakexa->exa->memoryBase + exaGetPixmapOffset(pDst);
dst += y * dst_pitch + x * cpp;
for (; h > 0; h--) {
memcpy(dst, src, w * cpp);
dst += dst_pitch;
src += src_pitch;
}
exaMarkSync(pDst->drawable.pScreen);
ephyrFinishPipelinedAccess(pDst, EXA_PREPARE_DEST);
return TRUE;
}
/**
* 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 (PixmapPtr pPixmap)
{
ExaScreenPriv (pPixmap->drawable.pScreen);
ExaPixmapPriv (pPixmap);
RegionPtr pRegion = DamageRegion (pExaPixmap->pDamage);
CARD8 *save_ptr;
int save_pitch;
BoxPtr pBox = REGION_RECTS(pRegion);
int nbox = REGION_NUM_RECTS(pRegion);
Bool do_sync = FALSE;
save_ptr = pPixmap->devPrivate.ptr;
save_pitch = pPixmap->devKind;
pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
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 (pExaScr->info->UploadToScreen == NULL ||
!pExaScr->info->UploadToScreen (pPixmap,
pBox->x1, pBox->y1,
pBox->x2 - pBox->x1,
pBox->y2 - pBox->y1,
pExaPixmap->sys_ptr
+ pBox->y1 * pExaPixmap->sys_pitch
+ pBox->x1 * pPixmap->drawable.bitsPerPixel / 8,
pExaPixmap->sys_pitch))
{
exaPrepareAccess(&pPixmap->drawable, EXA_PREPARE_DEST);
exaMemcpyBox (pPixmap, pBox,
pExaPixmap->sys_ptr, pExaPixmap->sys_pitch,
pExaPixmap->fb_ptr, pExaPixmap->fb_pitch);
exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_DEST);
}
else
do_sync = TRUE;
pBox++;
}
if (do_sync)
exaMarkSync (pPixmap->drawable.pScreen);
pPixmap->devPrivate.ptr = save_ptr;
pPixmap->devKind = save_pitch;
/* The previously damaged bits are now no longer damaged but valid */
REGION_UNION(pPixmap->drawable.pScreen,
&pExaPixmap->validReg, &pExaPixmap->validReg, pRegion);
DamageEmpty (pExaPixmap->pDamage);
}
void
GLAMOExaDoneCopy(PixmapPtr pDst)
{
ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
GlamoPtr pGlamo = GlamoPTR(pScrn);
GLAMOFlushCMDQCache(pGlamo, 1);
exaMarkSync(pGlamo->pScreen);
}
static Bool
exaFillRegionSolid(DrawablePtr pDrawable, RegionPtr pRegion, Pixel pixel,
CARD32 planemask, CARD32 alu, Bool hasClientClip)
{
ExaScreenPriv(pDrawable->pScreen);
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
ExaPixmapPriv(pPixmap);
int xoff, yoff;
Bool ret = FALSE;
exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
RegionTranslate(pRegion, xoff, yoff);
if (pExaScr->fallback_counter || pExaPixmap->accel_blocked)
goto out;
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillSolid,
alu,
hasClientClip) ? NULL : pRegion;
exaDoMigration(pixmaps, 1, TRUE);
}
if (exaPixmapHasGpuCopy(pPixmap) &&
(*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel)) {
int nbox;
BoxPtr pBox;
nbox = RegionNumRects(pRegion);
pBox = RegionRects(pRegion);
while (nbox--) {
(*pExaScr->info->Solid) (pPixmap, pBox->x1, pBox->y1, pBox->x2,
pBox->y2);
pBox++;
}
(*pExaScr->info->DoneSolid) (pPixmap);
exaMarkSync(pDrawable->pScreen);
if (pExaPixmap->pDamage &&
pExaPixmap->sys_ptr && pDrawable->type == DRAWABLE_PIXMAP &&
pDrawable->width == 1 && pDrawable->height == 1 &&
pDrawable->bitsPerPixel != 24) {
RegionPtr pending_damage = DamagePendingRegion(pExaPixmap->pDamage);
switch (pDrawable->bitsPerPixel) {
case 32:
*(CARD32 *) pExaPixmap->sys_ptr = pixel;
break;
case 16:
*(CARD16 *) pExaPixmap->sys_ptr = pixel;
break;
case 8:
case 4:
case 1:
*(CARD8 *) pExaPixmap->sys_ptr = pixel;
}
RegionUnion(&pExaPixmap->validSys, &pExaPixmap->validSys, pRegion);
RegionUnion(&pExaPixmap->validFB, &pExaPixmap->validFB, pRegion);
RegionSubtract(pending_damage, pending_damage, pRegion);
}
ret = TRUE;
}
out:
RegionTranslate(pRegion, -xoff, -yoff);
return ret;
}
static void
exaPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrect, xRectangle *prect)
{
ExaScreenPriv(pDrawable->pScreen);
RegionPtr pClip = fbGetCompositeClip(pGC);
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
ExaPixmapPriv(pPixmap);
register BoxPtr pbox;
BoxPtr pextent;
int extentX1, extentX2, extentY1, extentY2;
int fullX1, fullX2, fullY1, fullY2;
int partX1, partX2, partY1, partY2;
int xoff, yoff;
int xorg, yorg;
int n;
RegionPtr pReg = RegionFromRects(nrect, prect, CT_UNSORTED);
/* Compute intersection of rects and clip region */
RegionTranslate(pReg, pDrawable->x, pDrawable->y);
RegionIntersect(pReg, pClip, pReg);
if (!RegionNumRects(pReg)) {
goto out;
}
exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
if (pExaScr->fallback_counter || pExaScr->swappedOut ||
pExaPixmap->accel_blocked) {
goto fallback;
}
/* For ROPs where overlaps don't matter, convert rectangles to region and
* call exaFillRegion{Solid,Tiled}.
*/
if ((pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled) &&
(nrect == 1 || pGC->alu == GXcopy || pGC->alu == GXclear ||
pGC->alu == GXnoop || pGC->alu == GXcopyInverted ||
pGC->alu == GXset)) {
if (((pGC->fillStyle == FillSolid || pGC->tileIsPixel) &&
exaFillRegionSolid(pDrawable, pReg, pGC->fillStyle == FillSolid ?
pGC->fgPixel : pGC->tile.pixel, pGC->planemask,
pGC->alu, pGC->clientClip != NULL)) ||
(pGC->fillStyle == FillTiled && !pGC->tileIsPixel &&
exaFillRegionTiled(pDrawable, pReg, pGC->tile.pixmap, &pGC->patOrg,
pGC->planemask, pGC->alu,
pGC->clientClip != NULL))) {
goto out;
}
}
if (pGC->fillStyle != FillSolid &&
!(pGC->tileIsPixel && pGC->fillStyle == FillTiled)) {
goto fallback;
}
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = NULL;
exaDoMigration(pixmaps, 1, TRUE);
}
if (!exaPixmapHasGpuCopy(pPixmap) ||
!(*pExaScr->info->PrepareSolid) (pPixmap,
pGC->alu,
pGC->planemask, pGC->fgPixel)) {
fallback:
ExaCheckPolyFillRect(pDrawable, pGC, nrect, prect);
goto out;
}
xorg = pDrawable->x;
yorg = pDrawable->y;
pextent = RegionExtents(pClip);
extentX1 = pextent->x1;
extentY1 = pextent->y1;
extentX2 = pextent->x2;
extentY2 = pextent->y2;
while (nrect--) {
fullX1 = prect->x + xorg;
fullY1 = prect->y + yorg;
fullX2 = fullX1 + (int) prect->width;
fullY2 = fullY1 + (int) prect->height;
prect++;
if (fullX1 < extentX1)
fullX1 = extentX1;
if (fullY1 < extentY1)
fullY1 = extentY1;
if (fullX2 > extentX2)
fullX2 = extentX2;
if (fullY2 > extentY2)
fullY2 = extentY2;
if ((fullX1 >= fullX2) || (fullY1 >= fullY2))
continue;
n = RegionNumRects(pClip);
if (n == 1) {
(*pExaScr->info->Solid) (pPixmap,
fullX1 + xoff, fullY1 + yoff,
fullX2 + xoff, fullY2 + yoff);
}
else {
pbox = RegionRects(pClip);
/*
* clip the rectangle to each box in the clip region
* this is logically equivalent to calling Intersect(),
* but rectangles may overlap each other here.
*/
while (n--) {
partX1 = pbox->x1;
if (partX1 < fullX1)
partX1 = fullX1;
partY1 = pbox->y1;
if (partY1 < fullY1)
partY1 = fullY1;
partX2 = pbox->x2;
if (partX2 > fullX2)
partX2 = fullX2;
partY2 = pbox->y2;
if (partY2 > fullY2)
partY2 = fullY2;
pbox++;
if (partX1 < partX2 && partY1 < partY2) {
(*pExaScr->info->Solid) (pPixmap,
partX1 + xoff, partY1 + yoff,
partX2 + xoff, partY2 + yoff);
}
}
}
}
(*pExaScr->info->DoneSolid) (pPixmap);
exaMarkSync(pDrawable->pScreen);
out:
RegionUninit(pReg);
RegionDestroy(pReg);
}
static void
exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n,
DDXPointPtr ppt, int *pwidth, int fSorted)
{
ScreenPtr pScreen = pDrawable->pScreen;
ExaScreenPriv(pScreen);
RegionPtr pClip = fbGetCompositeClip(pGC);
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
ExaPixmapPriv(pPixmap);
BoxPtr pextent, pbox;
int nbox;
int extentX1, extentX2, extentY1, extentY2;
int fullX1, fullX2, fullY1;
int partX1, partX2;
int off_x, off_y;
if (pExaScr->fallback_counter ||
pExaScr->swappedOut ||
pGC->fillStyle != FillSolid || pExaPixmap->accel_blocked) {
ExaCheckFillSpans(pDrawable, pGC, n, ppt, pwidth, fSorted);
return;
}
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = NULL;
exaDoMigration(pixmaps, 1, TRUE);
}
if (!(pPixmap = exaGetOffscreenPixmap(pDrawable, &off_x, &off_y)) ||
!(*pExaScr->info->PrepareSolid) (pPixmap,
pGC->alu,
pGC->planemask, pGC->fgPixel)) {
ExaCheckFillSpans(pDrawable, pGC, n, ppt, pwidth, fSorted);
return;
}
pextent = RegionExtents(pClip);
extentX1 = pextent->x1;
extentY1 = pextent->y1;
extentX2 = pextent->x2;
extentY2 = pextent->y2;
while (n--) {
fullX1 = ppt->x;
fullY1 = ppt->y;
fullX2 = fullX1 + (int) *pwidth;
ppt++;
pwidth++;
if (fullY1 < extentY1 || extentY2 <= fullY1)
continue;
if (fullX1 < extentX1)
fullX1 = extentX1;
if (fullX2 > extentX2)
fullX2 = extentX2;
if (fullX1 >= fullX2)
continue;
nbox = RegionNumRects(pClip);
if (nbox == 1) {
(*pExaScr->info->Solid) (pPixmap,
fullX1 + off_x, fullY1 + off_y,
fullX2 + off_x, fullY1 + 1 + off_y);
}
else {
pbox = RegionRects(pClip);
while (nbox--) {
if (pbox->y1 <= fullY1 && fullY1 < pbox->y2) {
partX1 = pbox->x1;
if (partX1 < fullX1)
partX1 = fullX1;
partX2 = pbox->x2;
if (partX2 > fullX2)
partX2 = fullX2;
if (partX2 > partX1) {
(*pExaScr->info->Solid) (pPixmap,
partX1 + off_x, fullY1 + off_y,
partX2 + off_x,
fullY1 + 1 + off_y);
}
}
pbox++;
}
}
}
(*pExaScr->info->DoneSolid) (pPixmap);
exaMarkSync(pScreen);
}
Bool
exaHWCopyNtoN(DrawablePtr pSrcDrawable,
DrawablePtr pDstDrawable,
GCPtr pGC,
BoxPtr pbox,
int nbox, int dx, int dy, Bool reverse, Bool upsidedown)
{
ExaScreenPriv(pDstDrawable->pScreen);
PixmapPtr pSrcPixmap, pDstPixmap;
ExaPixmapPrivPtr pSrcExaPixmap, pDstExaPixmap;
int src_off_x, src_off_y;
int dst_off_x, dst_off_y;
RegionPtr srcregion = NULL, dstregion = NULL;
xRectangle *rects;
Bool ret = TRUE;
/* avoid doing copy operations if no boxes */
if (nbox == 0)
return TRUE;
pSrcPixmap = exaGetDrawablePixmap(pSrcDrawable);
pDstPixmap = exaGetDrawablePixmap(pDstDrawable);
exaGetDrawableDeltas(pSrcDrawable, pSrcPixmap, &src_off_x, &src_off_y);
exaGetDrawableDeltas(pDstDrawable, pDstPixmap, &dst_off_x, &dst_off_y);
rects = malloc(nbox * sizeof(xRectangle));
if (rects) {
int i;
int ordering;
for (i = 0; i < nbox; i++) {
rects[i].x = pbox[i].x1 + dx + src_off_x;
rects[i].y = pbox[i].y1 + dy + src_off_y;
rects[i].width = pbox[i].x2 - pbox[i].x1;
rects[i].height = pbox[i].y2 - pbox[i].y1;
}
/* This must match the RegionCopy() logic for reversing rect order */
if (nbox == 1 || (dx > 0 && dy > 0) ||
(pDstDrawable != pSrcDrawable &&
(pDstDrawable->type != DRAWABLE_WINDOW ||
pSrcDrawable->type != DRAWABLE_WINDOW)))
ordering = CT_YXBANDED;
else
ordering = CT_UNSORTED;
srcregion = RegionFromRects(nbox, rects, ordering);
free(rects);
if (!pGC || !exaGCReadsDestination(pDstDrawable, pGC->planemask,
pGC->fillStyle, pGC->alu,
pGC->clientClip != NULL)) {
dstregion = RegionCreate(NullBox, 0);
RegionCopy(dstregion, srcregion);
RegionTranslate(dstregion, dst_off_x - dx - src_off_x,
dst_off_y - dy - src_off_y);
}
}
pSrcExaPixmap = ExaGetPixmapPriv(pSrcPixmap);
pDstExaPixmap = ExaGetPixmapPriv(pDstPixmap);
/* Check whether the accelerator can use this pixmap.
* If the pitch of the pixmaps is out of range, there's nothing
* we can do but fall back to software rendering.
*/
if (pSrcExaPixmap->accel_blocked & EXA_RANGE_PITCH ||
pDstExaPixmap->accel_blocked & EXA_RANGE_PITCH)
goto fallback;
/* If the width or the height of either of the pixmaps
* is out of range, check whether the boxes are actually out of the
* addressable range as well. If they aren't, we can still do
* the copying in hardware.
*/
if (pSrcExaPixmap->accel_blocked || pDstExaPixmap->accel_blocked) {
int i;
for (i = 0; i < nbox; i++) {
/* src */
if ((pbox[i].x2 + dx + src_off_x) >= pExaScr->info->maxX ||
(pbox[i].y2 + dy + src_off_y) >= pExaScr->info->maxY)
goto fallback;
/* dst */
if ((pbox[i].x2 + dst_off_x) >= pExaScr->info->maxX ||
(pbox[i].y2 + dst_off_y) >= pExaScr->info->maxY)
goto fallback;
}
}
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[2];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pDstPixmap;
pixmaps[0].pReg = dstregion;
pixmaps[1].as_dst = FALSE;
pixmaps[1].as_src = TRUE;
pixmaps[1].pPix = pSrcPixmap;
pixmaps[1].pReg = srcregion;
exaDoMigration(pixmaps, 2, TRUE);
}
/* Mixed directions must be handled specially if the card is lame */
if ((pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS) &&
reverse != upsidedown) {
if (exaCopyNtoNTwoDir(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,
dx, dy))
goto out;
goto fallback;
}
if (exaPixmapHasGpuCopy(pDstPixmap)) {
/* Normal blitting. */
if (exaPixmapHasGpuCopy(pSrcPixmap)) {
if (!(*pExaScr->info->PrepareCopy)
(pSrcPixmap, pDstPixmap, reverse ? -1 : 1, upsidedown ? -1 : 1,
pGC ? pGC->alu : GXcopy, pGC ? pGC->planemask : FB_ALLONES)) {
goto fallback;
}
while (nbox--) {
(*pExaScr->info->Copy) (pDstPixmap,
pbox->x1 + dx + src_off_x,
pbox->y1 + dy + src_off_y,
pbox->x1 + dst_off_x,
pbox->y1 + dst_off_y,
pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1);
pbox++;
}
(*pExaScr->info->DoneCopy) (pDstPixmap);
exaMarkSync(pDstDrawable->pScreen);
/* UTS: mainly for SHM PutImage's secondary path.
*
* Only taking this path for directly accessible pixmaps.
*/
}
else if (!pDstExaPixmap->pDamage && pSrcExaPixmap->sys_ptr) {
int bpp = pSrcDrawable->bitsPerPixel;
int src_stride = exaGetPixmapPitch(pSrcPixmap);
CARD8 *src = NULL;
if (!pExaScr->info->UploadToScreen)
goto fallback;
if (pSrcDrawable->bitsPerPixel != pDstDrawable->bitsPerPixel)
goto fallback;
if (pSrcDrawable->bitsPerPixel < 8)
goto fallback;
if (pGC &&
!(pGC->alu == GXcopy &&
EXA_PM_IS_SOLID(pSrcDrawable, pGC->planemask)))
goto fallback;
while (nbox--) {
src =
pSrcExaPixmap->sys_ptr + (pbox->y1 + dy +
src_off_y) * src_stride +
(pbox->x1 + dx + src_off_x) * (bpp / 8);
if (!pExaScr->info->
UploadToScreen(pDstPixmap, pbox->x1 + dst_off_x,
pbox->y1 + dst_off_y, pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1, (char *) src,
src_stride))
goto fallback;
pbox++;
}
}
else
goto fallback;
}
else
goto fallback;
goto out;
fallback:
ret = FALSE;
out:
if (dstregion) {
RegionUninit(dstregion);
RegionDestroy(dstregion);
}
if (srcregion) {
RegionUninit(srcregion);
RegionDestroy(srcregion);
}
return ret;
}
static Bool inline
exaCopyNtoNTwoDir(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
GCPtr pGC, BoxPtr pbox, int nbox, int dx, int dy)
{
ExaScreenPriv(pDstDrawable->pScreen);
PixmapPtr pSrcPixmap, pDstPixmap;
int src_off_x, src_off_y, dst_off_x, dst_off_y;
int dirsetup;
/* Need to get both pixmaps to call the driver routines */
pSrcPixmap = exaGetOffscreenPixmap(pSrcDrawable, &src_off_x, &src_off_y);
pDstPixmap = exaGetOffscreenPixmap(pDstDrawable, &dst_off_x, &dst_off_y);
if (!pSrcPixmap || !pDstPixmap)
return FALSE;
/*
* Now the case of a chip that only supports xdir = ydir = 1 or
* xdir = ydir = -1, but we have xdir != ydir.
*/
dirsetup = 0; /* No direction set up yet. */
for (; nbox; pbox++, nbox--) {
if (dx >= 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
/* Do a xdir = ydir = -1 blit instead. */
if (dirsetup != -1) {
if (dirsetup != 0)
pExaScr->info->DoneCopy(pDstPixmap);
dirsetup = -1;
if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
pDstPixmap,
-1, -1,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask :
FB_ALLONES))
return FALSE;
}
(*pExaScr->info->Copy) (pDstPixmap,
src_off_x + pbox->x1 + dx,
src_off_y + pbox->y1 + dy,
dst_off_x + pbox->x1,
dst_off_y + pbox->y1,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
}
else if (dx < 0 && (src_off_y + pbox->y1 + dy) != pbox->y1) {
/* Do a xdir = ydir = 1 blit instead. */
if (dirsetup != 1) {
if (dirsetup != 0)
pExaScr->info->DoneCopy(pDstPixmap);
dirsetup = 1;
if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
pDstPixmap,
1, 1,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask :
FB_ALLONES))
return FALSE;
}
(*pExaScr->info->Copy) (pDstPixmap,
src_off_x + pbox->x1 + dx,
src_off_y + pbox->y1 + dy,
dst_off_x + pbox->x1,
dst_off_y + pbox->y1,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
}
else if (dx >= 0) {
/*
* xdir = 1, ydir = -1.
* Perform line-by-line xdir = ydir = 1 blits, going up.
*/
int i;
if (dirsetup != 1) {
if (dirsetup != 0)
pExaScr->info->DoneCopy(pDstPixmap);
dirsetup = 1;
if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
pDstPixmap,
1, 1,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask :
FB_ALLONES))
return FALSE;
}
for (i = pbox->y2 - pbox->y1 - 1; i >= 0; i--)
(*pExaScr->info->Copy) (pDstPixmap,
src_off_x + pbox->x1 + dx,
src_off_y + pbox->y1 + dy + i,
dst_off_x + pbox->x1,
dst_off_y + pbox->y1 + i,
pbox->x2 - pbox->x1, 1);
}
else {
/*
* xdir = -1, ydir = 1.
* Perform line-by-line xdir = ydir = -1 blits, going down.
*/
int i;
if (dirsetup != -1) {
if (dirsetup != 0)
pExaScr->info->DoneCopy(pDstPixmap);
dirsetup = -1;
if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap,
pDstPixmap,
-1, -1,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask :
FB_ALLONES))
return FALSE;
}
for (i = 0; i < pbox->y2 - pbox->y1; i++)
(*pExaScr->info->Copy) (pDstPixmap,
src_off_x + pbox->x1 + dx,
src_off_y + pbox->y1 + dy + i,
dst_off_x + pbox->x1,
dst_off_y + pbox->y1 + i,
pbox->x2 - pbox->x1, 1);
}
}
if (dirsetup != 0)
pExaScr->info->DoneCopy(pDstPixmap);
exaMarkSync(pDstDrawable->pScreen);
return TRUE;
}
static Bool
exaDoPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
int w, int h, int format, char *bits, int src_stride)
{
ExaScreenPriv(pDrawable->pScreen);
PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);
ExaPixmapPriv(pPix);
RegionPtr pClip;
BoxPtr pbox;
int nbox;
int xoff, yoff;
int bpp = pDrawable->bitsPerPixel;
Bool ret = TRUE;
if (pExaScr->fallback_counter || pExaPixmap->accel_blocked ||
!pExaScr->info->UploadToScreen)
return FALSE;
/* If there's a system copy, we want to save the result there */
if (pExaPixmap->pDamage)
return FALSE;
/* Don't bother with under 8bpp, XYPixmaps. */
if (format != ZPixmap || bpp < 8)
return FALSE;
/* Only accelerate copies: no rop or planemask. */
if (!EXA_PM_IS_SOLID(pDrawable, pGC->planemask) || pGC->alu != GXcopy)
return FALSE;
if (pExaScr->swappedOut)
return FALSE;
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPix;
pixmaps[0].pReg = DamagePendingRegion(pExaPixmap->pDamage);
exaDoMigration(pixmaps, 1, TRUE);
}
pPix = exaGetOffscreenPixmap(pDrawable, &xoff, &yoff);
if (!pPix)
return FALSE;
x += pDrawable->x;
y += pDrawable->y;
pClip = fbGetCompositeClip(pGC);
for (nbox = RegionNumRects(pClip),
pbox = RegionRects(pClip); nbox--; pbox++) {
int x1 = x;
int y1 = y;
int x2 = x + w;
int y2 = y + h;
char *src;
Bool ok;
if (x1 < pbox->x1)
x1 = pbox->x1;
if (y1 < pbox->y1)
y1 = pbox->y1;
if (x2 > pbox->x2)
x2 = pbox->x2;
if (y2 > pbox->y2)
y2 = pbox->y2;
if (x1 >= x2 || y1 >= y2)
continue;
src = bits + (y1 - y) * src_stride + (x1 - x) * (bpp / 8);
ok = pExaScr->info->UploadToScreen(pPix, x1 + xoff, y1 + yoff,
x2 - x1, y2 - y1, src, src_stride);
/* We have to fall back completely, and ignore what has already been completed.
* Messing with the fb layer directly like we used to is completely unacceptable.
*/
if (!ok) {
ret = FALSE;
break;
}
}
if (ret)
exaMarkSync(pDrawable->pScreen);
return ret;
}
/* Try to do an accelerated tile of the pTile into pRegion of pDrawable.
* Based on fbFillRegionTiled(), fbTile().
*/
Bool
exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
Bool hasClientClip)
{
ExaScreenPriv(pDrawable->pScreen);
PixmapPtr pPixmap;
ExaPixmapPrivPtr pExaPixmap;
ExaPixmapPrivPtr pTileExaPixmap = ExaGetPixmapPriv(pTile);
int xoff, yoff;
int tileWidth, tileHeight;
int nbox = RegionNumRects(pRegion);
BoxPtr pBox = RegionRects(pRegion);
Bool ret = FALSE;
int i;
tileWidth = pTile->drawable.width;
tileHeight = pTile->drawable.height;
/* If we're filling with a solid color, grab it out and go to
* FillRegionSolid, saving numerous copies.
*/
if (tileWidth == 1 && tileHeight == 1)
return exaFillRegionSolid(pDrawable, pRegion,
exaGetPixmapFirstPixel(pTile), planemask,
alu, hasClientClip);
pPixmap = exaGetDrawablePixmap(pDrawable);
pExaPixmap = ExaGetPixmapPriv(pPixmap);
if (pExaScr->fallback_counter || pExaPixmap->accel_blocked ||
pTileExaPixmap->accel_blocked)
return FALSE;
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[2];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillTiled,
alu,
hasClientClip) ? NULL : pRegion;
pixmaps[1].as_dst = FALSE;
pixmaps[1].as_src = TRUE;
pixmaps[1].pPix = pTile;
pixmaps[1].pReg = NULL;
exaDoMigration(pixmaps, 2, TRUE);
}
pPixmap = exaGetOffscreenPixmap(pDrawable, &xoff, &yoff);
if (!pPixmap || !exaPixmapHasGpuCopy(pTile))
return FALSE;
if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask)) {
if (xoff || yoff)
RegionTranslate(pRegion, xoff, yoff);
for (i = 0; i < nbox; i++) {
int height = pBox[i].y2 - pBox[i].y1;
int dstY = pBox[i].y1;
int tileY;
if (alu == GXcopy)
height = min(height, tileHeight);
modulus(dstY - yoff - pDrawable->y - pPatOrg->y, tileHeight, tileY);
while (height > 0) {
int width = pBox[i].x2 - pBox[i].x1;
int dstX = pBox[i].x1;
int tileX;
int h = tileHeight - tileY;
if (alu == GXcopy)
width = min(width, tileWidth);
if (h > height)
h = height;
height -= h;
modulus(dstX - xoff - pDrawable->x - pPatOrg->x, tileWidth,
tileX);
while (width > 0) {
int w = tileWidth - tileX;
if (w > width)
w = width;
width -= w;
(*pExaScr->info->Copy) (pPixmap, tileX, tileY, dstX, dstY,
w, h);
dstX += w;
tileX = 0;
}
dstY += h;
tileY = 0;
}
}
(*pExaScr->info->DoneCopy) (pPixmap);
/* With GXcopy, we only need to do the basic algorithm up to the tile
* size; then, we can just keep doubling the destination in each
* direction until it fills the box. This way, the number of copy
* operations is O(log(rx)) + O(log(ry)) instead of O(rx * ry), where
* rx/ry is the ratio between box and tile width/height. This can make
* a big difference if each driver copy incurs a significant constant
* overhead.
*/
if (alu != GXcopy)
ret = TRUE;
else {
Bool more_copy = FALSE;
for (i = 0; i < nbox; i++) {
int dstX = pBox[i].x1 + tileWidth;
int dstY = pBox[i].y1 + tileHeight;
if ((dstX < pBox[i].x2) || (dstY < pBox[i].y2)) {
more_copy = TRUE;
break;
}
}
if (more_copy == FALSE)
ret = TRUE;
if (more_copy && (*pExaScr->info->PrepareCopy) (pPixmap, pPixmap,
1, 1, alu,
planemask)) {
for (i = 0; i < nbox; i++) {
int dstX = pBox[i].x1 + tileWidth;
int dstY = pBox[i].y1 + tileHeight;
int width = min(pBox[i].x2 - dstX, tileWidth);
int height = min(pBox[i].y2 - pBox[i].y1, tileHeight);
while (dstX < pBox[i].x2) {
(*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
dstX, pBox[i].y1, width,
height);
dstX += width;
width = min(pBox[i].x2 - dstX, width * 2);
}
width = pBox[i].x2 - pBox[i].x1;
height = min(pBox[i].y2 - dstY, tileHeight);
while (dstY < pBox[i].y2) {
(*pExaScr->info->Copy) (pPixmap, pBox[i].x1, pBox[i].y1,
pBox[i].x1, dstY, width,
height);
dstY += height;
height = min(pBox[i].y2 - dstY, height * 2);
}
}
(*pExaScr->info->DoneCopy) (pPixmap);
ret = TRUE;
}
}
exaMarkSync(pDrawable->pScreen);
if (xoff || yoff)
RegionTranslate(pRegion, -xoff, -yoff);
}
return ret;
}
static Bool
nouveau_exa_upload_to_screen(PixmapPtr pdpix, int x, int y, int w, int h,
char *src, int src_pitch)
{
ScrnInfoPtr pScrn = xf86Screens[pdpix->drawable.pScreen->myNum];
NVPtr pNv = NVPTR(pScrn);
struct nouveau_bo *bo;
int dst_pitch, cpp;
char *dst;
Bool ret;
dst_pitch = exaGetPixmapPitch(pdpix);
cpp = pdpix->drawable.bitsPerPixel >> 3;
/* try hostdata transfer */
if (w * h * cpp < 16*1024) /* heuristic */
{
if (pNv->Architecture < NV_ARCH_50) {
if (NV04EXAUploadIFC(pScrn, src, src_pitch, pdpix,
x, y, w, h, cpp)) {
exaMarkSync(pdpix->drawable.pScreen);
return TRUE;
}
} else
if (pNv->Architecture < NV_ARCH_C0) {
if (NV50EXAUploadSIFC(src, src_pitch, pdpix,
x, y, w, h, cpp)) {
exaMarkSync(pdpix->drawable.pScreen);
return TRUE;
}
} else {
if (NVC0EXAUploadSIFC(src, src_pitch, pdpix,
x, y, w, h, cpp)) {
exaMarkSync(pdpix->drawable.pScreen);
return TRUE;
}
}
}
/* try gart-based transfer */
if (pNv->GART) {
if (pNv->Architecture < NV_ARCH_C0) {
ret = NVAccelUploadM2MF(pdpix, x, y, w, h,
src, src_pitch);
} else {
ret = NVC0AccelUploadM2MF(pdpix, x, y, w, h,
src, src_pitch);
}
if (ret) {
exaMarkSync(pdpix->drawable.pScreen);
return TRUE;
}
}
/* fallback to memcpy-based transfer */
bo = nouveau_pixmap_bo(pdpix);
if (nouveau_bo_map(bo, NOUVEAU_BO_WR))
return FALSE;
dst = (char *)bo->map + (y * dst_pitch) + (x * cpp);
ret = NVAccelMemcpyRect(dst, src, h, dst_pitch, src_pitch, w*cpp);
nouveau_bo_unmap(bo);
return ret;
}
static Bool
exaFillRegionSolid (DrawablePtr pDrawable, RegionPtr pRegion, Pixel pixel,
CARD32 planemask, CARD32 alu, unsigned int clientClipType)
{
ExaScreenPriv(pDrawable->pScreen);
PixmapPtr pPixmap = exaGetDrawablePixmap (pDrawable);
ExaPixmapPriv (pPixmap);
int xoff, yoff;
Bool ret = FALSE;
exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
REGION_TRANSLATE(pScreen, pRegion, xoff, yoff);
if (pExaScr->fallback_counter || pExaPixmap->accel_blocked)
goto out;
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = exaGCReadsDestination(pDrawable, planemask, FillSolid,
alu, clientClipType) ? NULL : pRegion;
exaDoMigration (pixmaps, 1, TRUE);
}
if (exaPixmapIsOffscreen (pPixmap) &&
(*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel))
{
int nbox;
BoxPtr pBox;
nbox = REGION_NUM_RECTS (pRegion);
pBox = REGION_RECTS (pRegion);
while (nbox--)
{
(*pExaScr->info->Solid) (pPixmap, pBox->x1, pBox->y1, pBox->x2,
pBox->y2);
pBox++;
}
(*pExaScr->info->DoneSolid) (pPixmap);
exaMarkSync(pDrawable->pScreen);
if (pExaPixmap->pDamage &&
pExaPixmap->sys_ptr && pDrawable->type == DRAWABLE_PIXMAP &&
pDrawable->width == 1 && pDrawable->height == 1 &&
pDrawable->bitsPerPixel != 24) {
ExaPixmapPriv(pPixmap);
switch (pDrawable->bitsPerPixel) {
case 32:
*(CARD32*)pExaPixmap->sys_ptr = pixel;
break;
case 16:
*(CARD16*)pExaPixmap->sys_ptr = pixel;
break;
case 8:
*(CARD8*)pExaPixmap->sys_ptr = pixel;
}
REGION_UNION(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,
pRegion);
}
ret = TRUE;
}
out:
REGION_TRANSLATE(pScreen, pRegion, -xoff, -yoff);
return ret;
}
Bool RADEONDrawInit(ScreenPtr pScreen)
{
RINFO_FROM_SCREEN(pScreen);
if (info->accel_state->exa == NULL) {
xf86DrvMsg(pScreen->myNum, X_ERROR, "Memory map not set up\n");
return FALSE;
}
info->accel_state->exa->exa_major = EXA_VERSION_MAJOR;
info->accel_state->exa->exa_minor = EXA_VERSION_MINOR;
info->accel_state->exa->PrepareSolid = RADEONPrepareSolid;
info->accel_state->exa->Solid = RADEONSolid;
info->accel_state->exa->DoneSolid = RADEONDone2D;
info->accel_state->exa->PrepareCopy = RADEONPrepareCopy;
info->accel_state->exa->Copy = RADEONCopy;
info->accel_state->exa->DoneCopy = RADEONDone2D;
info->accel_state->exa->MarkSync = RADEONMarkSync;
info->accel_state->exa->WaitMarker = RADEONSync;
info->accel_state->exa->UploadToScreen = &RADEONUploadToScreenCS;
info->accel_state->exa->DownloadFromScreen = &RADEONDownloadFromScreenCS;
info->accel_state->exa->flags = EXA_OFFSCREEN_PIXMAPS | EXA_SUPPORTS_PREPARE_AUX |
EXA_SUPPORTS_OFFSCREEN_OVERLAPS | EXA_HANDLES_PIXMAPS | EXA_MIXED_PIXMAPS;
info->accel_state->exa->pixmapOffsetAlign = RADEON_GPU_PAGE_SIZE;
info->accel_state->exa->pixmapPitchAlign = 64;
#ifdef RENDER
if (info->RenderAccel) {
if (IS_R300_3D || IS_R500_3D) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Render acceleration "
"enabled for R300/R400/R500 type cards.\n");
info->accel_state->exa->CheckComposite = R300CheckComposite;
info->accel_state->exa->PrepareComposite =
R300PrepareComposite;
info->accel_state->exa->Composite = RadeonComposite;
info->accel_state->exa->DoneComposite = RadeonDoneComposite;
} else if (IS_R200_3D) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Render acceleration "
"enabled for R200 type cards.\n");
info->accel_state->exa->CheckComposite = R200CheckComposite;
info->accel_state->exa->PrepareComposite =
R200PrepareComposite;
info->accel_state->exa->Composite = RadeonComposite;
info->accel_state->exa->DoneComposite = RadeonDoneComposite;
} else {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Render acceleration "
"enabled for R100 type cards.\n");
info->accel_state->exa->CheckComposite = R100CheckComposite;
info->accel_state->exa->PrepareComposite =
R100PrepareComposite;
info->accel_state->exa->Composite = RadeonComposite;
info->accel_state->exa->DoneComposite = RadeonDoneComposite;
}
}
#endif
info->accel_state->exa->CreatePixmap = RADEONEXACreatePixmap;
info->accel_state->exa->DestroyPixmap = RADEONEXADestroyPixmap;
info->accel_state->exa->PixmapIsOffscreen = RADEONEXAPixmapIsOffscreen;
info->accel_state->exa->PrepareAccess = RADEONPrepareAccess_CS;
info->accel_state->exa->FinishAccess = RADEONFinishAccess_CS;
info->accel_state->exa->CreatePixmap2 = RADEONEXACreatePixmap2;
#if (EXA_VERSION_MAJOR == 2 && EXA_VERSION_MINOR >= 6)
info->accel_state->exa->SharePixmapBacking = RADEONEXASharePixmapBacking;
info->accel_state->exa->SetSharedPixmapBacking = RADEONEXASetSharedPixmapBacking;
#endif
info->accel_state->exa->maxPitchBytes = 16320;
info->accel_state->exa->maxX = 8191;
info->accel_state->exa->maxY = 8191;
if (xf86ReturnOptValBool(info->Options, OPTION_EXA_VSYNC, FALSE)) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO, "EXA VSync enabled\n");
info->accel_state->vsync = TRUE;
} else
info->accel_state->vsync = FALSE;
RADEONEngineInit(pScrn);
if (!exaDriverInit(pScreen, info->accel_state->exa)) {
free(info->accel_state->exa);
return FALSE;
}
exaMarkSync(pScreen);
return TRUE;
}
