frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
xserver/exa/exa.c

1146 lines
34 KiB
C
Raw Blame History

/*
* Copyright © 2001 Keith Packard
*
* Partly based on code that is Copyright © The XFree86 Project Inc.
*
* 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.
*/
/** @file
* This file covers the initialization and teardown of EXA, and has various
* functions not responsible for performing rendering, pixmap migration, or
* memory management.
*/
#include <dix-config.h>
#include <stdlib.h>
#include "exa_priv.h"
#include "exa.h"
DevPrivateKeyRec exaScreenPrivateKeyRec;
#ifdef MITSHM
static ShmFuncs exaShmFuncs = { NULL, NULL };
#endif
/**
* exaGetPixmapOffset() returns the offset (in bytes) within the framebuffer of
* the beginning of the given pixmap.
*
* Note that drivers are free to, and often do, munge this offset as necessary
* for handing to the hardware -- for example, translating it into a different
* aperture. This function may need to be extended in the future if we grow
* support for having multiple card-accessible offscreen, such as an AGP memory
* pool alongside the framebuffer pool.
*/
unsigned long
exaGetPixmapOffset(PixmapPtr pPix)
{
ExaScreenPriv(pPix->drawable.pScreen);
ExaPixmapPriv(pPix);
return (CARD8 *) pExaPixmap->fb_ptr - pExaScr->info->memoryBase;
}
void *
exaGetPixmapDriverPrivate(PixmapPtr pPix)
{
ExaPixmapPriv(pPix);
return pExaPixmap->driverPriv;
}
/**
* exaGetPixmapPitch() returns the pitch (in bytes) of the given pixmap.
*
* This is a helper to make driver code more obvious, due to the rather obscure
* naming of the pitch field in the pixmap.
*/
unsigned long
exaGetPixmapPitch(PixmapPtr pPix)
{
return pPix->devKind;
}
/**
* exaGetPixmapSize() returns the size in bytes of the given pixmap in video
* memory. Only valid when the pixmap is currently in framebuffer.
*/
unsigned long
exaGetPixmapSize(PixmapPtr pPix)
{
ExaPixmapPrivPtr pExaPixmap;
pExaPixmap = ExaGetPixmapPriv(pPix);
if (pExaPixmap != NULL)
return pExaPixmap->fb_size;
return 0;
}
/**
* exaGetDrawablePixmap() returns a backing pixmap for a given drawable.
*
* @param pDrawable the drawable being requested.
*
* This function returns the backing pixmap for a drawable, whether it is a
* redirected window, unredirected window, or already a pixmap. Note that
* coordinate translation is needed when drawing to the backing pixmap of a
* redirected window, and the translation coordinates are provided by calling
* exaGetOffscreenPixmap() on the drawable.
*/
PixmapPtr
exaGetDrawablePixmap(DrawablePtr pDrawable)
{
if (pDrawable->type == DRAWABLE_WINDOW)
return pDrawable->pScreen->GetWindowPixmap((WindowPtr) pDrawable);
else
return (PixmapPtr) pDrawable;
}
/**
* Sets the offsets to add to coordinates to make them address the same bits in
* the backing drawable. These coordinates are nonzero only for redirected
* windows.
*/
void
exaGetDrawableDeltas(DrawablePtr pDrawable, PixmapPtr pPixmap, int *xp, int *yp)
{
#if defined(COMPOSITE) || defined(ROOTLESS)
if (pDrawable->type == DRAWABLE_WINDOW) {
*xp = -pPixmap->screen_x;
*yp = -pPixmap->screen_y;
return;
}
#endif
*xp = 0;
*yp = 0;
}
/**
* exaPixmapDirty() marks a pixmap as dirty, allowing for
* optimizations in pixmap migration when no changes have occurred.
*/
void
exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2)
{
BoxRec box;
RegionRec region;
box.x1 = max(x1, 0);
box.y1 = max(y1, 0);
box.x2 = min(x2, pPix->drawable.width);
box.y2 = min(y2, pPix->drawable.height);
if (box.x1 >= box.x2 || box.y1 >= box.y2)
return;
RegionInit(&region, &box, 1);
DamageDamageRegion(&pPix->drawable, &region);
RegionUninit(&region);
}
static int
exaLog2(int val)
{
int bits;
if (val <= 0)
return 0;
for (bits = 0; val != 0; bits++)
val >>= 1;
return bits - 1;
}
void
exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
int w, int h, int bpp)
{
pExaPixmap->accel_blocked = 0;
if (pExaScr->info->maxPitchPixels) {
int max_pitch = pExaScr->info->maxPitchPixels * bits_to_bytes(bpp);
if (pExaPixmap->fb_pitch > max_pitch)
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
}
if (pExaScr->info->maxPitchBytes &&
pExaPixmap->fb_pitch > pExaScr->info->maxPitchBytes)
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
if (w > pExaScr->info->maxX)
pExaPixmap->accel_blocked |= EXA_RANGE_WIDTH;
if (h > pExaScr->info->maxY)
pExaPixmap->accel_blocked |= EXA_RANGE_HEIGHT;
}
void
exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
int w, int h, int bpp)
{
if (pExaScr->info->flags & EXA_OFFSCREEN_ALIGN_POT && w != 1)
pExaPixmap->fb_pitch = bits_to_bytes((1 << (exaLog2(w - 1) + 1)) * bpp);
else
pExaPixmap->fb_pitch = bits_to_bytes(w * bpp);
pExaPixmap->fb_pitch = EXA_ALIGN(pExaPixmap->fb_pitch,
pExaScr->info->pixmapPitchAlign);
}
/**
* Returns TRUE if the pixmap is not movable. This is the case where it's a
* pixmap which has no private (almost always bad) or it's a scratch pixmap created by
* some X Server internal component (the score says it's pinned).
*/
Bool
exaPixmapIsPinned(PixmapPtr pPix)
{
ExaPixmapPriv(pPix);
if (pExaPixmap == NULL)
EXA_FatalErrorDebugWithRet(("EXA bug: exaPixmapIsPinned was called on a non-exa pixmap.\n"), TRUE);
return pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED;
}
/**
* exaPixmapHasGpuCopy() is used to determine if a pixmap is in offscreen
* memory, meaning that acceleration could probably be done to it, and that it
* will need to be wrapped by PrepareAccess()/FinishAccess() when accessing it
* with the CPU.
*
* Note that except for UploadToScreen()/DownloadFromScreen() (which explicitly
* deal with moving pixmaps in and out of system memory), EXA will give drivers
* pixmaps as arguments for which exaPixmapHasGpuCopy() is TRUE.
*
* @return TRUE if the given drawable is in framebuffer memory.
*/
Bool
exaPixmapHasGpuCopy(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return FALSE;
return (*pExaScr->pixmap_has_gpu_copy) (pPixmap);
}
/**
* exaDrawableIsOffscreen() is a convenience wrapper for exaPixmapHasGpuCopy().
*/
Bool
exaDrawableIsOffscreen(DrawablePtr pDrawable)
{
return exaPixmapHasGpuCopy(exaGetDrawablePixmap(pDrawable));
}
/**
* Returns the pixmap which backs a drawable, and the offsets to add to
* coordinates to make them address the same bits in the backing drawable.
*/
PixmapPtr
exaGetOffscreenPixmap(DrawablePtr pDrawable, int *xp, int *yp)
{
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
exaGetDrawableDeltas(pDrawable, pPixmap, xp, yp);
if (exaPixmapHasGpuCopy(pPixmap))
return pPixmap;
else
return NULL;
}
/**
* Returns TRUE if the pixmap GPU copy is being accessed.
*/
Bool
ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
ExaPixmapPriv(pPixmap);
Bool has_gpu_copy, ret;
int i;
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return FALSE;
if (pExaPixmap == NULL)
EXA_FatalErrorDebugWithRet(("EXA bug: ExaDoPrepareAccess was called on a non-exa pixmap.\n"), FALSE);
/* Handle repeated / nested calls. */
for (i = 0; i < EXA_NUM_PREPARE_INDICES; i++) {
if (pExaScr->access[i].pixmap == pPixmap) {
pExaScr->access[i].count++;
return pExaScr->access[i].retval;
}
}
/* If slot for this index is taken, find an empty slot */
if (pExaScr->access[index].pixmap) {
for (index = EXA_NUM_PREPARE_INDICES - 1; index >= 0; index--)
if (!pExaScr->access[index].pixmap)
break;
}
/* Access to this pixmap hasn't been prepared yet, so data pointer should be NULL. */
if (pPixmap->devPrivate.ptr != NULL) {
EXA_FatalErrorDebug(("EXA bug: pPixmap->devPrivate.ptr was %p, but should have been NULL.\n", pPixmap->devPrivate.ptr));
}
has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
if (has_gpu_copy && pExaPixmap->fb_ptr) {
pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
ret = TRUE;
}
else {
pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
ret = FALSE;
}
/* Store so we can handle repeated / nested calls. */
pExaScr->access[index].pixmap = pPixmap;
pExaScr->access[index].count = 1;
if (!has_gpu_copy)
goto out;
exaWaitSync(pScreen);
if (pExaScr->info->PrepareAccess == NULL)
goto out;
if (index >= EXA_PREPARE_AUX_DEST &&
!(pExaScr->info->flags & EXA_SUPPORTS_PREPARE_AUX)) {
if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED)
FatalError("Unsupported AUX indices used on a pinned pixmap.\n");
exaMoveOutPixmap(pPixmap);
ret = FALSE;
goto out;
}
if (!(*pExaScr->info->PrepareAccess) (pPixmap, index)) {
if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED &&
!(pExaScr->info->flags & EXA_MIXED_PIXMAPS))
FatalError("Driver failed PrepareAccess on a pinned pixmap.\n");
exaMoveOutPixmap(pPixmap);
ret = FALSE;
goto out;
}
ret = TRUE;
out:
pExaScr->access[index].retval = ret;
return ret;
}
/**
* exaPrepareAccess() is EXA's wrapper for the driver's PrepareAccess() handler.
*
* It deals with waiting for synchronization with the card, determining if
* PrepareAccess() is necessary, and working around PrepareAccess() failure.
*/
void
exaPrepareAccess(DrawablePtr pDrawable, int index)
{
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
ExaScreenPriv(pDrawable->pScreen);
if (pExaScr->prepare_access_reg)
pExaScr->prepare_access_reg(pPixmap, index, NULL);
else
(void) ExaDoPrepareAccess(pPixmap, index);
}
/**
* exaFinishAccess() is EXA's wrapper for the driver's FinishAccess() handler.
*
* It deals with calling the driver's FinishAccess() only if necessary.
*/
void
exaFinishAccess(DrawablePtr pDrawable, int index)
{
ScreenPtr pScreen = pDrawable->pScreen;
ExaScreenPriv(pScreen);
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
ExaPixmapPriv(pPixmap);
int i;
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return;
if (pExaPixmap == NULL)
EXA_FatalErrorDebugWithRet(("EXA bug: exaFinishAccesss was called on a non-exa pixmap.\n"),);
/* Handle repeated / nested calls. */
for (i = 0; i < EXA_NUM_PREPARE_INDICES; i++) {
if (pExaScr->access[i].pixmap == pPixmap) {
if (--pExaScr->access[i].count > 0)
return;
break;
}
}
/* Catch unbalanced Prepare/FinishAccess calls. */
if (i == EXA_NUM_PREPARE_INDICES)
EXA_FatalErrorDebugWithRet(("EXA bug: FinishAccess called without PrepareAccess for pixmap 0x%p.\n", pPixmap),);
pExaScr->access[i].pixmap = NULL;
/* We always hide the devPrivate.ptr. */
pPixmap->devPrivate.ptr = NULL;
/* Only call FinishAccess if PrepareAccess was called and succeeded. */
if (!pExaScr->info->FinishAccess || !pExaScr->access[i].retval)
return;
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, i);
}
/**
* Helper for things common to all schemes when a pixmap is destroyed
*/
void
exaDestroyPixmap(PixmapPtr pPixmap)
{
ExaScreenPriv(pPixmap->drawable.pScreen);
int i;
/* Finish access if it was prepared (e.g. pixmap created during
* software fallback)
*/
for (i = 0; i < EXA_NUM_PREPARE_INDICES; i++) {
if (pExaScr->access[i].pixmap == pPixmap) {
exaFinishAccess(&pPixmap->drawable, i);
pExaScr->access[i].pixmap = NULL;
break;
}
}
}
/**
* Here begins EXA's GC code.
* Do not ever access the fb/mi layer directly.
*/
static void
exaValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable);
static void
exaDestroyGC(GCPtr pGC);
static void
exaChangeGC(GCPtr pGC, unsigned long mask);
static void
exaCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
static void
exaChangeClip(GCPtr pGC, int type, void *pvalue, int nrects);
static void
exaCopyClip(GCPtr pGCDst, GCPtr pGCSrc);
static void
exaDestroyClip(GCPtr pGC);
const GCFuncs exaGCFuncs = {
exaValidateGC,
exaChangeGC,
exaCopyGC,
exaDestroyGC,
exaChangeClip,
exaDestroyClip,
exaCopyClip
};
static void
exaValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
{
/* fbValidateGC will do direct access to pixmaps if the tiling has changed.
* Do a few smart things so fbValidateGC can do its work.
*/
ScreenPtr pScreen = pDrawable->pScreen;
ExaScreenPriv(pScreen);
ExaGCPriv(pGC);
PixmapPtr pTile = NULL;
/* Either of these conditions is enough to trigger access to a tile pixmap.
* With pGC->tileIsPixel == 1, you run the risk of dereferencing an invalid
* tile pixmap pointer.
*/
if (pGC->fillStyle == FillTiled ||
((changes & GCTile) && !pGC->tileIsPixel)) {
pTile = pGC->tile.pixmap;
}
if (pGC->stipple)
exaPrepareAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
if (pTile)
exaPrepareAccess(&pTile->drawable, EXA_PREPARE_SRC);
/* Calls to Create/DestroyPixmap have to be identified as special. */
pExaScr->fallback_counter++;
swap(pExaGC, pGC, funcs);
(*pGC->funcs->ValidateGC) (pGC, changes, pDrawable);
swap(pExaGC, pGC, funcs);
pExaScr->fallback_counter--;
if (pTile)
exaFinishAccess(&pTile->drawable, EXA_PREPARE_SRC);
if (pGC->stipple)
exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
}
/* Is exaPrepareAccessGC() needed? */
static void
exaDestroyGC(GCPtr pGC)
{
ExaGCPriv(pGC);
swap(pExaGC, pGC, funcs);
(*pGC->funcs->DestroyGC) (pGC);
swap(pExaGC, pGC, funcs);
}
static void
exaChangeGC(GCPtr pGC, unsigned long mask)
{
ExaGCPriv(pGC);
swap(pExaGC, pGC, funcs);
(*pGC->funcs->ChangeGC) (pGC, mask);
swap(pExaGC, pGC, funcs);
}
static void
exaCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
{
ExaGCPriv(pGCDst);
swap(pExaGC, pGCDst, funcs);
(*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
swap(pExaGC, pGCDst, funcs);
}
static void
exaChangeClip(GCPtr pGC, int type, void *pvalue, int nrects)
{
ExaGCPriv(pGC);
swap(pExaGC, pGC, funcs);
(*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
swap(pExaGC, pGC, funcs);
}
static void
exaCopyClip(GCPtr pGCDst, GCPtr pGCSrc)
{
ExaGCPriv(pGCDst);
swap(pExaGC, pGCDst, funcs);
(*pGCDst->funcs->CopyClip) (pGCDst, pGCSrc);
swap(pExaGC, pGCDst, funcs);
}
static void
exaDestroyClip(GCPtr pGC)
{
ExaGCPriv(pGC);
swap(pExaGC, pGC, funcs);
(*pGC->funcs->DestroyClip) (pGC);
swap(pExaGC, pGC, funcs);
}
/**
* exaCreateGC makes a new GC and hooks up its funcs handler, so that
* exaValidateGC() will get called.
*/
static int
exaCreateGC(GCPtr pGC)
{
ScreenPtr pScreen = pGC->pScreen;
ExaScreenPriv(pScreen);
ExaGCPriv(pGC);
Bool ret;
swap(pExaScr, pScreen, CreateGC);
if ((ret = (*pScreen->CreateGC) (pGC))) {
wrap(pExaGC, pGC, funcs, &exaGCFuncs);
wrap(pExaGC, pGC, ops, &exaOps);
}
swap(pExaScr, pScreen, CreateGC);
return ret;
}
static Bool
exaChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
{
Bool ret;
ScreenPtr pScreen = pWin->drawable.pScreen;
ExaScreenPriv(pScreen);
if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap)
exaPrepareAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);
if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)
exaPrepareAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);
pExaScr->fallback_counter++;
swap(pExaScr, pScreen, ChangeWindowAttributes);
ret = pScreen->ChangeWindowAttributes(pWin, mask);
swap(pExaScr, pScreen, ChangeWindowAttributes);
pExaScr->fallback_counter--;
if ((mask & CWBackPixmap) && pWin->backgroundState == BackgroundPixmap)
exaFinishAccess(&pWin->background.pixmap->drawable, EXA_PREPARE_SRC);
if ((mask & CWBorderPixmap) && pWin->borderIsPixel == FALSE)
exaFinishAccess(&pWin->border.pixmap->drawable, EXA_PREPARE_MASK);
return ret;
}
static RegionPtr
exaBitmapToRegion(PixmapPtr pPix)
{
RegionPtr ret;
ScreenPtr pScreen = pPix->drawable.pScreen;
ExaScreenPriv(pScreen);
exaPrepareAccess(&pPix->drawable, EXA_PREPARE_SRC);
swap(pExaScr, pScreen, BitmapToRegion);
ret = (*pScreen->BitmapToRegion) (pPix);
swap(pExaScr, pScreen, BitmapToRegion);
exaFinishAccess(&pPix->drawable, EXA_PREPARE_SRC);
return ret;
}
static Bool
exaCreateScreenResources(ScreenPtr pScreen)
{
ExaScreenPriv(pScreen);
PixmapPtr pScreenPixmap;
Bool b;
swap(pExaScr, pScreen, CreateScreenResources);
b = pScreen->CreateScreenResources(pScreen);
swap(pExaScr, pScreen, CreateScreenResources);
if (!b)
return FALSE;
pScreenPixmap = pScreen->GetScreenPixmap(pScreen);
if (pScreenPixmap) {
ExaPixmapPriv(pScreenPixmap);
exaSetAccelBlock(pExaScr, pExaPixmap,
pScreenPixmap->drawable.width,
pScreenPixmap->drawable.height,
pScreenPixmap->drawable.bitsPerPixel);
}
return TRUE;
}
static void
ExaBlockHandler(ScreenPtr pScreen, void *pTimeout)
{
ExaScreenPriv(pScreen);
/* Move any deferred results from a software fallback to the driver pixmap */
if (pExaScr->deferred_mixed_pixmap)
exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
unwrap(pExaScr, pScreen, BlockHandler);
(*pScreen->BlockHandler) (pScreen, pTimeout);
wrap(pExaScr, pScreen, BlockHandler, ExaBlockHandler);
/* The rest only applies to classic EXA */
if (pExaScr->info->flags & EXA_HANDLES_PIXMAPS)
return;
/* Try and keep the offscreen memory area tidy every now and then (at most
* once per second) when the server has been idle for at least 100ms.
*/
if (pExaScr->numOffscreenAvailable > 1) {
CARD32 now = GetTimeInMillis();
pExaScr->nextDefragment = now +
max(100, (INT32) (pExaScr->lastDefragment + 1000 - now));
AdjustWaitForDelay(pTimeout, pExaScr->nextDefragment - now);
}
}
static void
ExaWakeupHandler(ScreenPtr pScreen, int result)
{
ExaScreenPriv(pScreen);
unwrap(pExaScr, pScreen, WakeupHandler);
(*pScreen->WakeupHandler) (pScreen, result);
wrap(pExaScr, pScreen, WakeupHandler, ExaWakeupHandler);
if (result == 0 && pExaScr->numOffscreenAvailable > 1) {
CARD32 now = GetTimeInMillis();
if ((int) (now - pExaScr->nextDefragment) > 0) {
ExaOffscreenDefragment(pScreen);
pExaScr->lastDefragment = now;
}
}
}
/**
* exaCloseScreen() unwraps its wrapped screen functions and tears down EXA's
* screen private, before calling down to the next CloseSccreen.
*/
static Bool
exaCloseScreen(ScreenPtr pScreen)
{
ExaScreenPriv(pScreen);
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
if (ps && ps->Glyphs == exaGlyphs)
exaGlyphsFini(pScreen);
if (pScreen->BlockHandler == ExaBlockHandler)
unwrap(pExaScr, pScreen, BlockHandler);
if (pScreen->WakeupHandler == ExaWakeupHandler)
unwrap(pExaScr, pScreen, WakeupHandler);
unwrap(pExaScr, pScreen, CreateGC);
unwrap(pExaScr, pScreen, CloseScreen);
unwrap(pExaScr, pScreen, GetImage);
unwrap(pExaScr, pScreen, GetSpans);
if (pExaScr->SavedCreatePixmap)
unwrap(pExaScr, pScreen, CreatePixmap);
if (pExaScr->SavedDestroyPixmap)
unwrap(pExaScr, pScreen, DestroyPixmap);
if (pExaScr->SavedModifyPixmapHeader)
unwrap(pExaScr, pScreen, ModifyPixmapHeader);
unwrap(pExaScr, pScreen, CopyWindow);
unwrap(pExaScr, pScreen, ChangeWindowAttributes);
unwrap(pExaScr, pScreen, BitmapToRegion);
unwrap(pExaScr, pScreen, CreateScreenResources);
if (pExaScr->SavedSharePixmapBacking)
unwrap(pExaScr, pScreen, SharePixmapBacking);
if (pExaScr->SavedSetSharedPixmapBacking)
unwrap(pExaScr, pScreen, SetSharedPixmapBacking);
if (ps) {
unwrap(pExaScr, ps, Composite);
if (pExaScr->SavedGlyphs)
unwrap(pExaScr, ps, Glyphs);
unwrap(pExaScr, ps, Trapezoids);
unwrap(pExaScr, ps, Triangles);
unwrap(pExaScr, ps, AddTraps);
}
free(pExaScr);
return (*pScreen->CloseScreen) (pScreen);
}
/**
* This function allocates a driver structure for EXA drivers to fill in. By
* having EXA allocate the structure, the driver structure can be extended
* without breaking ABI between EXA and the drivers. The driver's
* responsibility is to check beforehand that the EXA module has a matching
* major number and sufficient minor. Drivers are responsible for freeing the
* driver structure using free().
*
* @return a newly allocated, zero-filled driver structure
*/
ExaDriverPtr
exaDriverAlloc(void)
{
return calloc(1, sizeof(ExaDriverRec));
}
/**
* @param pScreen screen being initialized
* @param pScreenInfo EXA driver record
*
* exaDriverInit sets up EXA given a driver record filled in by the driver.
* pScreenInfo should have been allocated by exaDriverAlloc(). See the
* comments in _ExaDriver for what must be filled in and what is optional.
*
* @return TRUE if EXA was successfully initialized.
*/
Bool
exaDriverInit(ScreenPtr pScreen, ExaDriverPtr pScreenInfo)
{
ExaScreenPrivPtr pExaScr;
PictureScreenPtr ps;
if (!pScreenInfo)
return FALSE;
if (pScreenInfo->exa_major != EXA_VERSION_MAJOR ||
pScreenInfo->exa_minor > EXA_VERSION_MINOR) {
LogMessage(X_ERROR, "EXA(%d): driver's EXA version requirements "
"(%d.%d) are incompatible with EXA version (%d.%d)\n",
pScreen->myNum,
pScreenInfo->exa_major, pScreenInfo->exa_minor,
EXA_VERSION_MAJOR, EXA_VERSION_MINOR);
return FALSE;
}
if (!pScreenInfo->CreatePixmap && !pScreenInfo->CreatePixmap2) {
if (!pScreenInfo->memoryBase) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memoryBase "
"must be non-zero\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->memorySize) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::memorySize must be "
"non-zero\n", pScreen->myNum);
return FALSE;
}
if (pScreenInfo->offScreenBase > pScreenInfo->memorySize) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::offScreenBase must "
"be <= ExaDriverRec::memorySize\n", pScreen->myNum);
return FALSE;
}
}
if (!pScreenInfo->PrepareSolid) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareSolid must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->PrepareCopy) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::PrepareCopy must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
if (!pScreenInfo->WaitMarker) {
LogMessage(X_ERROR, "EXA(%d): ExaDriverRec::WaitMarker must be "
"non-NULL\n", pScreen->myNum);
return FALSE;
}
/* If the driver doesn't set any max pitch values, we'll just assume
* that there's a limitation by pixels, and that it's the same as
* maxX.
*
* We want maxPitchPixels or maxPitchBytes to be set so we can check
* pixmaps against the max pitch in exaCreatePixmap() -- it matters
* whether a pixmap is rejected because of its pitch or
* because of its width.
*/
if (!pScreenInfo->maxPitchPixels && !pScreenInfo->maxPitchBytes) {
pScreenInfo->maxPitchPixels = pScreenInfo->maxX;
}
ps = GetPictureScreenIfSet(pScreen);
if (!dixRegisterPrivateKey(&exaScreenPrivateKeyRec, PRIVATE_SCREEN, 0)) {
LogMessage(X_WARNING, "EXA(%d): Failed to register screen private\n",
pScreen->myNum);
return FALSE;
}
pExaScr = calloc(1, sizeof(ExaScreenPrivRec));
if (!pExaScr) {
LogMessage(X_WARNING, "EXA(%d): Failed to allocate screen private\n",
pScreen->myNum);
return FALSE;
}
pExaScr->info = pScreenInfo;
dixSetPrivate(&pScreen->devPrivates, exaScreenPrivateKey, pExaScr);
pExaScr->migration = ExaMigrationAlways;
exaDDXDriverInit(pScreen);
if (!dixRegisterScreenSpecificPrivateKey
(pScreen, &pExaScr->gcPrivateKeyRec, PRIVATE_GC, sizeof(ExaGCPrivRec))) {
LogMessage(X_WARNING, "EXA(%d): Failed to allocate GC private\n",
pScreen->myNum);
return FALSE;
}
/*
* Replace various fb screen functions
*/
if ((pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS) &&
(!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS) ||
(pExaScr->info->flags & EXA_MIXED_PIXMAPS)))
wrap(pExaScr, pScreen, BlockHandler, ExaBlockHandler);
if ((pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS) &&
!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS))
wrap(pExaScr, pScreen, WakeupHandler, ExaWakeupHandler);
wrap(pExaScr, pScreen, CreateGC, exaCreateGC);
wrap(pExaScr, pScreen, CloseScreen, exaCloseScreen);
wrap(pExaScr, pScreen, GetImage, exaGetImage);
wrap(pExaScr, pScreen, GetSpans, ExaCheckGetSpans);
wrap(pExaScr, pScreen, CopyWindow, exaCopyWindow);
wrap(pExaScr, pScreen, ChangeWindowAttributes, exaChangeWindowAttributes);
wrap(pExaScr, pScreen, BitmapToRegion, exaBitmapToRegion);
wrap(pExaScr, pScreen, CreateScreenResources, exaCreateScreenResources);
if (ps) {
wrap(pExaScr, ps, Composite, exaComposite);
if (pScreenInfo->PrepareComposite) {
wrap(pExaScr, ps, Glyphs, exaGlyphs);
}
else {
wrap(pExaScr, ps, Glyphs, ExaCheckGlyphs);
}
wrap(pExaScr, ps, Trapezoids, exaTrapezoids);
wrap(pExaScr, ps, Triangles, exaTriangles);
wrap(pExaScr, ps, AddTraps, ExaCheckAddTraps);
}
#ifdef MITSHM
/*
* Don't allow shared pixmaps.
*/
ShmRegisterFuncs(pScreen, &exaShmFuncs);
#endif
/*
* Hookup offscreen pixmaps
*/
if (pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS) {
if (!dixRegisterScreenSpecificPrivateKey
(pScreen, &pExaScr->pixmapPrivateKeyRec, PRIVATE_PIXMAP,
sizeof(ExaPixmapPrivRec))) {
LogMessage(X_WARNING,
"EXA(%d): Failed to allocate pixmap private\n",
pScreen->myNum);
return FALSE;
}
if (pExaScr->info->flags & EXA_HANDLES_PIXMAPS) {
if (pExaScr->info->flags & EXA_MIXED_PIXMAPS) {
wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmap_mixed);
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_mixed);
wrap(pExaScr, pScreen, ModifyPixmapHeader,
exaModifyPixmapHeader_mixed);
wrap(pExaScr, pScreen, SharePixmapBacking, exaSharePixmapBacking_mixed);
wrap(pExaScr, pScreen, SetSharedPixmapBacking, exaSetSharedPixmapBacking_mixed);
pExaScr->do_migration = exaDoMigration_mixed;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_mixed;
pExaScr->do_move_in_pixmap = exaMoveInPixmap_mixed;
pExaScr->do_move_out_pixmap = NULL;
pExaScr->prepare_access_reg = exaPrepareAccessReg_mixed;
}
else {
wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmap_driver);
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_driver);
wrap(pExaScr, pScreen, ModifyPixmapHeader,
exaModifyPixmapHeader_driver);
pExaScr->do_migration = NULL;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_driver;
pExaScr->do_move_in_pixmap = NULL;
pExaScr->do_move_out_pixmap = NULL;
pExaScr->prepare_access_reg = NULL;
}
}
else {
wrap(pExaScr, pScreen, CreatePixmap, exaCreatePixmap_classic);
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_classic);
wrap(pExaScr, pScreen, ModifyPixmapHeader,
exaModifyPixmapHeader_classic);
pExaScr->do_migration = exaDoMigration_classic;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_classic;
pExaScr->do_move_in_pixmap = exaMoveInPixmap_classic;
pExaScr->do_move_out_pixmap = exaMoveOutPixmap_classic;
pExaScr->prepare_access_reg = exaPrepareAccessReg_classic;
}
if (!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS)) {
LogMessage(X_INFO, "EXA(%d): Offscreen pixmap area of %lu bytes\n",
pScreen->myNum,
pExaScr->info->memorySize -
pExaScr->info->offScreenBase);
}
else {
LogMessage(X_INFO, "EXA(%d): Driver allocated offscreen pixmaps\n",
pScreen->myNum);
}
}
else
LogMessage(X_INFO, "EXA(%d): No offscreen pixmaps\n", pScreen->myNum);
if (!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS)) {
DBG_PIXMAP(("============== %ld < %ld\n", pExaScr->info->offScreenBase,
pExaScr->info->memorySize));
if (pExaScr->info->offScreenBase < pExaScr->info->memorySize) {
if (!exaOffscreenInit(pScreen)) {
LogMessage(X_WARNING,
"EXA(%d): Offscreen pixmap setup failed\n",
pScreen->myNum);
return FALSE;
}
}
}
if (ps && ps->Glyphs == exaGlyphs)
exaGlyphsInit(pScreen);
LogMessage(X_INFO, "EXA(%d): Driver registered support for the following"
" operations:\n", pScreen->myNum);
assert(pScreenInfo->PrepareSolid != NULL);
LogMessage(X_INFO, " Solid\n");
assert(pScreenInfo->PrepareCopy != NULL);
LogMessage(X_INFO, " Copy\n");
if (pScreenInfo->PrepareComposite != NULL) {
LogMessage(X_INFO, " Composite (RENDER acceleration)\n");
}
if (pScreenInfo->UploadToScreen != NULL) {
LogMessage(X_INFO, " UploadToScreen\n");
}
if (pScreenInfo->DownloadFromScreen != NULL) {
LogMessage(X_INFO, " DownloadFromScreen\n");
}
return TRUE;
}
/**
* exaDriverFini tears down EXA on a given screen.
*
* @param pScreen screen being torn down.
*/
void
exaDriverFini(ScreenPtr pScreen)
{
/*right now does nothing */
}
/**
* exaMarkSync() should be called after any asynchronous drawing by the hardware.
*
* @param pScreen screen which drawing occurred on
*
* exaMarkSync() sets a flag to indicate that some asynchronous drawing has
* happened and a WaitSync() will be necessary before relying on the contents of
* offscreen memory from the CPU's perspective. It also calls an optional
* driver MarkSync() callback, the return value of which may be used to do partial
* synchronization with the hardware in the future.
*/
void
exaMarkSync(ScreenPtr pScreen)
{
ExaScreenPriv(pScreen);
pExaScr->info->needsSync = TRUE;
if (pExaScr->info->MarkSync != NULL) {
pExaScr->info->lastMarker = (*pExaScr->info->MarkSync) (pScreen);
}
}
/**
* exaWaitSync() ensures that all drawing has been completed.
*
* @param pScreen screen being synchronized.
*
* Calls down into the driver to ensure that all previous drawing has completed.
* It should always be called before relying on the framebuffer contents
* reflecting previous drawing, from a CPU perspective.
*/
void
exaWaitSync(ScreenPtr pScreen)
{
ExaScreenPriv(pScreen);
if (pExaScr->info->needsSync && !pExaScr->swappedOut) {
(*pExaScr->info->WaitMarker) (pScreen, pExaScr->info->lastMarker);
pExaScr->info->needsSync = FALSE;
}
}
/**
* 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(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
{
ScreenPtr pScreen = pixmaps[0].pPix->drawable.pScreen;
ExaScreenPriv(pScreen);
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return;
if (pExaScr->do_migration)
(*pExaScr->do_migration) (pixmaps, npixmaps, can_accel);
}
void
exaMoveInPixmap(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return;
if (pExaScr->do_move_in_pixmap)
(*pExaScr->do_move_in_pixmap) (pPixmap);
}
void
exaMoveOutPixmap(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return;
if (pExaScr->do_move_out_pixmap)
(*pExaScr->do_move_out_pixmap) (pPixmap);
}
Reference in New Issue View Git Blame Copy Permalink