Bool
fbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
{
PixmapPtr pPixmap;
if (mask & CWBackPixmap)
{
if (pWin->backgroundState == BackgroundPixmap)
{
pPixmap = pWin->background.pixmap;
#ifdef FB_24_32BIT
if (pPixmap->drawable.bitsPerPixel != pWin->drawable.bitsPerPixel)
{
pPixmap = fb24_32ReformatTile (pPixmap,
pWin->drawable.bitsPerPixel);
if (pPixmap)
{
(*pWin->drawable.pScreen->DestroyPixmap) (pWin->background.pixmap);
pWin->background.pixmap = pPixmap;
}
}
#endif
if (FbEvenTile (pPixmap->drawable.width *
pPixmap->drawable.bitsPerPixel))
fbPadPixmap (pPixmap);
}
}
if (mask & CWBorderPixmap)
{
if (pWin->borderIsPixel == FALSE)
{
pPixmap = pWin->border.pixmap;
#ifdef FB_24_32BIT
if (pPixmap->drawable.bitsPerPixel !=
pWin->drawable.bitsPerPixel)
{
pPixmap = fb24_32ReformatTile (pPixmap,
pWin->drawable.bitsPerPixel);
if (pPixmap)
{
(*pWin->drawable.pScreen->DestroyPixmap) (pWin->border.pixmap);
pWin->border.pixmap = pPixmap;
}
}
#endif
if (FbEvenTile (pPixmap->drawable.width *
pPixmap->drawable.bitsPerPixel))
fbPadPixmap (pPixmap);
}
}
return TRUE;
}
static void
fbFixupWindowPixmap(DrawablePtr pDrawable, PixmapPtr *ppPixmap)
{
PixmapPtr pPixmap = *ppPixmap;
if (pPixmap->drawable.bitsPerPixel != pDrawable->bitsPerPixel) {
pPixmap = fb24_32ReformatTile(pPixmap, pDrawable->bitsPerPixel);
if (!pPixmap)
return;
(*pDrawable->pScreen->DestroyPixmap) (*ppPixmap);
*ppPixmap = pPixmap;
}
if (FbEvenTile(pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel))
fbPadPixmap(pPixmap);
}
static void vivante_unaccel_fixup_tile(DrawablePtr pDraw, PixmapPtr *ppPix)
{
PixmapPtr pNew, pPixmap = *ppPix;
if (pPixmap->drawable.bitsPerPixel != pDraw->bitsPerPixel) {
vivante_prepare_drawable(&pPixmap->drawable, ACCESS_RO);
pNew = fb24_32ReformatTile(pPixmap, pDraw->bitsPerPixel);
vivante_finish_drawable(&pPixmap->drawable, ACCESS_RO);
pDraw->pScreen->DestroyPixmap(pPixmap);
*ppPix = pPixmap = pNew;
}
if (FbEvenTile(pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel)) {
vivante_prepare_drawable(&pPixmap->drawable, ACCESS_RW);
fbPadPixmap(pPixmap);
vivante_finish_drawable(&pPixmap->drawable, ACCESS_RW);
}
}
/**
* exaValidateGC() sets the ops to EXA's implementations, which may be
* accelerated or may sync the card and fall back to fb.
*/
static void
exaValidateGC (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
{
/* fbValidateGC will do direct access to pixmaps if the tiling has changed.
* Preempt fbValidateGC by doing its work and masking the change out, so
* that we can do the Prepare/FinishAccess.
*/
#ifdef FB_24_32BIT
if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) {
(*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC));
fbGetRotatedPixmap(pGC) = 0;
}
if (pGC->fillStyle == FillTiled) {
PixmapPtr pOldTile, pNewTile;
pOldTile = pGC->tile.pixmap;
if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel)
{
pNewTile = fbGetRotatedPixmap(pGC);
if (!pNewTile ||
pNewTile ->drawable.bitsPerPixel != pDrawable->bitsPerPixel)
{
if (pNewTile)
(*pGC->pScreen->DestroyPixmap) (pNewTile);
/* fb24_32ReformatTile will do direct access of a newly-
* allocated pixmap. This isn't a problem yet, since we don't
* put pixmaps in FB until at least one accelerated EXA op.
*/
exaPrepareAccess(&pOldTile->drawable, EXA_PREPARE_SRC);
pNewTile = fb24_32ReformatTile (pOldTile,
pDrawable->bitsPerPixel);
exaPixmapDirty(pNewTile, 0, 0, pNewTile->drawable.width, pNewTile->drawable.height);
exaFinishAccess(&pOldTile->drawable, EXA_PREPARE_SRC);
}
if (pNewTile)
{
fbGetRotatedPixmap(pGC) = pOldTile;
pGC->tile.pixmap = pNewTile;
changes |= GCTile;
}
}
}
#endif
if (changes & GCTile) {
if (!pGC->tileIsPixel && FbEvenTile (pGC->tile.pixmap->drawable.width *
pDrawable->bitsPerPixel))
{
/* XXX This fixes corruption with tiled pixmaps, but may just be a
* workaround for broken drivers
*/
exaMoveOutPixmap(pGC->tile.pixmap);
fbPadPixmap (pGC->tile.pixmap);
exaPixmapDirty(pGC->tile.pixmap, 0, 0,
pGC->tile.pixmap->drawable.width,
pGC->tile.pixmap->drawable.height);
}
/* Mask out the GCTile change notification, now that we've done FB's
* job for it.
*/
changes &= ~GCTile;
}
fbValidateGC (pGC, changes, pDrawable);
pGC->ops = (GCOps *) &exaOps;
}
/**
* uxa_validate_gc() sets the ops to UXA's implementations, which may be
* accelerated or may sync the card and fall back to fb.
*/
static void
uxa_validate_gc(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
{
/* fbValidateGC will do direct access to pixmaps if the tiling has
* changed.
* Preempt fbValidateGC by doing its work and masking the change out, so
* that we can do the Prepare/finish_access.
*/
#ifdef FB_24_32BIT
if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) {
(*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC));
fbGetRotatedPixmap(pGC) = 0;
}
if (pGC->fillStyle == FillTiled) {
PixmapPtr pOldTile, pNewTile;
pOldTile = pGC->tile.pixmap;
if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) {
pNewTile = fbGetRotatedPixmap(pGC);
if (!pNewTile ||
pNewTile->drawable.bitsPerPixel !=
pDrawable->bitsPerPixel) {
if (pNewTile)
(*pGC->pScreen->
DestroyPixmap) (pNewTile);
/* fb24_32ReformatTile will do direct access
* of a newly-allocated pixmap. This isn't a
* problem yet, since we don't put pixmaps in
* FB until at least one accelerated UXA op.
*/
if (uxa_prepare_access
(&pOldTile->drawable, NULL, UXA_ACCESS_RO)) {
pNewTile =
fb24_32ReformatTile(pOldTile,
pDrawable->
bitsPerPixel);
uxa_finish_access(&pOldTile->drawable);
}
}
if (pNewTile) {
fbGetRotatedPixmap(pGC) = pOldTile;
pGC->tile.pixmap = pNewTile;
changes |= GCTile;
}
}
}
#endif
if (changes & GCTile) {
if (!pGC->tileIsPixel
&& FbEvenTile(pGC->tile.pixmap->drawable.width *
pDrawable->bitsPerPixel)) {
if (uxa_prepare_access
(&pGC->tile.pixmap->drawable, NULL, UXA_ACCESS_RW)) {
fbPadPixmap(pGC->tile.pixmap);
uxa_finish_access(&pGC->tile.pixmap->drawable);
}
}
/* Mask out the GCTile change notification, now that we've
* done FB's job for it.
*/
changes &= ~GCTile;
}
if (changes & GCStipple && pGC->stipple) {
/* We can't inline stipple handling like we do for GCTile
* because it sets fbgc privates.
*/
if (uxa_prepare_access(&pGC->stipple->drawable, NULL, UXA_ACCESS_RW)) {
fbValidateGC(pGC, changes, pDrawable);
uxa_finish_access(&pGC->stipple->drawable);
}
} else {
fbValidateGC(pGC, changes, pDrawable);
}
pGC->ops = (GCOps *) & uxa_ops;
}
void
fbValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
{
FbGCPrivPtr pPriv = fbGetGCPrivate(pGC);
FbBits mask;
/*
* if the client clip is different or moved OR the subwindowMode has
* changed OR the window's clip has changed since the last validation
* we need to recompute the composite clip
*/
if ((changes &
(GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) ||
(pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
) {
miComputeCompositeClip(pGC, pDrawable);
}
if (pPriv->bpp != pDrawable->bitsPerPixel) {
changes |= GCStipple | GCForeground | GCBackground | GCPlaneMask;
pPriv->bpp = pDrawable->bitsPerPixel;
}
if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) {
(*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC));
fbGetRotatedPixmap(pGC) = 0;
}
if (pGC->fillStyle == FillTiled) {
PixmapPtr pOldTile, pNewTile;
pOldTile = pGC->tile.pixmap;
if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) {
pNewTile = fbGetRotatedPixmap(pGC);
if (!pNewTile ||
pNewTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) {
if (pNewTile)
(*pGC->pScreen->DestroyPixmap) (pNewTile);
pNewTile =
fb24_32ReformatTile(pOldTile, pDrawable->bitsPerPixel);
}
if (pNewTile) {
fbGetRotatedPixmap(pGC) = pOldTile;
pGC->tile.pixmap = pNewTile;
changes |= GCTile;
}
}
}
if (changes & GCTile) {
if (!pGC->tileIsPixel &&
FbEvenTile(pGC->tile.pixmap->drawable.width *
pDrawable->bitsPerPixel))
fbPadPixmap(pGC->tile.pixmap);
}
if (changes & GCStipple) {
pPriv->evenStipple = FALSE;
if (pGC->stipple) {
/* can we do an even stipple ?? */
if (FbEvenStip(pGC->stipple->drawable.width,
pDrawable->bitsPerPixel) &&
(fbCanEvenStipple(pGC->stipple, pDrawable->bitsPerPixel)))
pPriv->evenStipple = TRUE;
if (pGC->stipple->drawable.width * pDrawable->bitsPerPixel <
FB_UNIT)
fbPadPixmap(pGC->stipple);
}
}
/*
* Recompute reduced rop values
*/
if (changes & (GCForeground | GCBackground | GCPlaneMask | GCFunction)) {
int s;
FbBits depthMask;
mask = FbFullMask(pDrawable->bitsPerPixel);
depthMask = FbFullMask(pDrawable->depth);
pPriv->fg = pGC->fgPixel & mask;
pPriv->bg = pGC->bgPixel & mask;
if ((pGC->planemask & depthMask) == depthMask)
pPriv->pm = mask;
else
pPriv->pm = pGC->planemask & mask;
s = pDrawable->bitsPerPixel;
while (s < FB_UNIT) {
pPriv->fg |= pPriv->fg << s;
pPriv->bg |= pPriv->bg << s;
pPriv->pm |= pPriv->pm << s;
s <<= 1;
}
pPriv->and = fbAnd(pGC->alu, pPriv->fg, pPriv->pm);
pPriv->xor = fbXor(pGC->alu, pPriv->fg, pPriv->pm);
pPriv->bgand = fbAnd(pGC->alu, pPriv->bg, pPriv->pm);
pPriv->bgxor = fbXor(pGC->alu, pPriv->bg, pPriv->pm);
}
if (changes & GCDashList) {
unsigned short n = pGC->numInDashList;
unsigned char *dash = pGC->dash;
unsigned int dashLength = 0;
while (n--)
dashLength += (unsigned int) *dash++;
pPriv->dashLength = dashLength;
}
}
/**
* uxa_validate_gc() sets the ops to glamor's implementations, which may be
* accelerated or may sync the card and fall back to fb.
*/
void
glamor_validate_gc(GCPtr gc, unsigned long changes, DrawablePtr drawable)
{
/* fbValidateGC will do direct access to pixmaps if the tiling has changed.
* Preempt fbValidateGC by doing its work and masking the change out, so
* that we can do the Prepare/finish_access.
*/
#ifdef FB_24_32BIT
if ((changes & GCTile) && fbGetRotatedPixmap(gc)) {
gc->pScreen->DestroyPixmap(fbGetRotatedPixmap(gc));
fbGetRotatedPixmap(gc) = 0;
}
if (gc->fillStyle == FillTiled) {
PixmapPtr old_tile, new_tile;
old_tile = gc->tile.pixmap;
if (old_tile->drawable.bitsPerPixel != drawable->bitsPerPixel) {
new_tile = fbGetRotatedPixmap(gc);
if (!new_tile ||
new_tile->drawable.bitsPerPixel != drawable->bitsPerPixel) {
if (new_tile)
gc->pScreen->DestroyPixmap(new_tile);
/* fb24_32ReformatTile will do direct access of a newly-
* allocated pixmap.
*/
glamor_fallback
("GC %p tile FB_24_32 transformat %p.\n", gc, old_tile);
if (glamor_prepare_access
(&old_tile->drawable, GLAMOR_ACCESS_RO)) {
new_tile =
fb24_32ReformatTile(old_tile, drawable->bitsPerPixel);
glamor_finish_access(&old_tile->drawable, GLAMOR_ACCESS_RO);
}
}
if (new_tile) {
fbGetRotatedPixmap(gc) = old_tile;
gc->tile.pixmap = new_tile;
changes |= GCTile;
}
}
}
#endif
if (changes & GCTile) {
if (!gc->tileIsPixel) {
glamor_pixmap_private *pixmap_priv =
glamor_get_pixmap_private(gc->tile.pixmap);
if ((!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv))
&& FbEvenTile(gc->tile.pixmap->drawable.width *
drawable->bitsPerPixel)) {
glamor_fallback
("GC %p tile changed %p.\n", gc, gc->tile.pixmap);
if (glamor_prepare_access
(&gc->tile.pixmap->drawable, GLAMOR_ACCESS_RW)) {
fbPadPixmap(gc->tile.pixmap);
glamor_finish_access
(&gc->tile.pixmap->drawable, GLAMOR_ACCESS_RW);
}
}
}
/* Mask out the GCTile change notification, now that we've done FB's
* job for it.
*/
changes &= ~GCTile;
}
if (changes & GCStipple && gc->stipple) {
/* We can't inline stipple handling like we do for GCTile because
* it sets fbgc privates.
*/
if (glamor_prepare_access(&gc->stipple->drawable, GLAMOR_ACCESS_RW)) {
fbValidateGC(gc, changes, drawable);
glamor_finish_access(&gc->stipple->drawable, GLAMOR_ACCESS_RW);
}
}
else {
fbValidateGC(gc, changes, drawable);
}
gc->ops = &glamor_gc_ops;
}