static Bool
VGAarbiterCreateGC(GCPtr pGC)
{
ScreenPtr pScreen = pGC->pScreen;
VGAarbiterGCPtr pGCPriv = (VGAarbiterGCPtr)dixLookupPrivate(&pGC->devPrivates, VGAarbiterGCKey);
Bool ret;
SCREEN_PROLOG(CreateGC);
ret = (*pScreen->CreateGC)(pGC);
GC_WRAP(pGC);
SCREEN_EPILOG(CreateGC,VGAarbiterCreateGC);
return ret;
}
ClientPolicyPtr
ClientGetPolicyRec(ClientPtr client)
{
ClientPolicyPtr rec;
if (!client)
rec = NULL;
else {
rec = (ClientPolicyPtr)dixLookupPrivate(&client->devPrivates,
ClientPrivateKey);
}
return rec;
}
static Bool
VGAarbiterSwitchMode(int index, DisplayModePtr mode, int flags)
{
Bool val;
ScreenPtr pScreen = screenInfo.screens[index];
VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
&pScreen->devPrivates, VGAarbiterScreenKey);
DPRINT_S("VGAarbiterSwitchMode",index);
VGAGet();
val = (*pScreenPriv->SwitchMode)(index, mode, flags);
VGAPut();
return val;
}
static Bool
VGAarbiterEnterVT(int index, int flags)
{
Bool val;
ScreenPtr pScreen = screenInfo.screens[index];
VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
&pScreen->devPrivates, VGAarbiterScreenKey);
DPRINT_S("VGAarbiterEnterVT",index);
VGAGet();
val = (*pScreenPriv->EnterVT)(index, flags);
VGAPut();
return val;
}
static Bool
VGAarbiterSwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
{
Bool val;
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
VGAarbiterScreenPtr pScreenPriv =
(VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
VGAarbiterScreenKey);
VGAGet(pScreen);
val = (*pScreenPriv->SwitchMode) (pScrn, mode);
VGAPut();
return val;
}
_X_EXPORT void
glamor_egl_exchange_buffers(PixmapPtr front, PixmapPtr back)
{
ScrnInfoPtr scrn = xf86ScreenToScrn(front->drawable.pScreen);
struct glamor_egl_screen_private *glamor_egl =
glamor_egl_get_screen_private(scrn);
EGLImageKHR old_front_image;
EGLImageKHR new_front_image;
glamor_pixmap_exchange_fbos(front, back);
new_front_image =
dixLookupPrivate(&back->devPrivates, glamor_egl_pixmap_private_key);
old_front_image =
dixLookupPrivate(&front->devPrivates, glamor_egl_pixmap_private_key);
dixSetPrivate(&front->devPrivates, glamor_egl_pixmap_private_key,
new_front_image);
dixSetPrivate(&back->devPrivates, glamor_egl_pixmap_private_key,
old_front_image);
glamor_set_pixmap_type(front, GLAMOR_TEXTURE_DRM);
glamor_set_pixmap_type(back, GLAMOR_TEXTURE_DRM);
glamor_egl->front_image = new_front_image;
}
void
xf86_reload_cursors(ScreenPtr screen)
{
ScrnInfoPtr scrn;
xf86CrtcConfigPtr xf86_config;
xf86CursorInfoPtr cursor_info;
CursorPtr cursor;
int x, y;
xf86CursorScreenPtr cursor_screen_priv;
/* initial mode setting will not have set a screen yet.
May be called before the devices are initialised.
*/
if (!screen || !inputInfo.pointer)
return;
cursor_screen_priv = dixLookupPrivate(&screen->devPrivates,
xf86CursorScreenKey);
/* return if HW cursor is inactive, to avoid displaying two cursors */
if (!cursor_screen_priv || !cursor_screen_priv->isUp)
return;
scrn = xf86ScreenToScrn(screen);
xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
/* make sure the cursor code has been initialized */
cursor_info = xf86_config->cursor_info;
if (!cursor_info)
return;
cursor = xf86_config->cursor;
GetSpritePosition(inputInfo.pointer, &x, &y);
if (!(cursor_info->Flags & HARDWARE_CURSOR_UPDATE_UNHIDDEN))
(*cursor_info->HideCursor) (scrn);
if (cursor) {
void *src =
dixLookupScreenPrivate(&cursor->devPrivates, CursorScreenKey,
screen);
#ifdef ARGB_CURSOR
if (cursor->bits->argb && cursor_info->LoadCursorARGB)
(*cursor_info->LoadCursorARGB) (scrn, cursor);
else if (src)
#endif
(*cursor_info->LoadCursorImage) (scrn, src);
x += scrn->frameX0 + cursor_screen_priv->HotX;
y += scrn->frameY0 + cursor_screen_priv->HotY;
(*cursor_info->SetCursorPosition) (scrn, x, y);
}
}
static Bool
XvDestroyPixmap(PixmapPtr pPix)
{
Bool status;
ScreenPtr pScreen;
XvScreenPtr pxvs;
XvAdaptorPtr pa;
int na;
XvPortPtr pp;
int np;
pScreen = pPix->drawable.pScreen;
SCREEN_PROLOGUE(pScreen, DestroyPixmap);
pxvs = (XvScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XvScreenKey);
/* CHECK TO SEE IF THIS PORT IS IN USE */
pa = pxvs->pAdaptors;
na = pxvs->nAdaptors;
while (na--)
{
np = pa->nPorts;
pp = pa->pPorts;
while (np--)
{
if (pp->pDraw == (DrawablePtr)pPix)
{
XvdiSendVideoNotify(pp, pp->pDraw, XvPreempted);
(void)(* pp->pAdaptor->ddStopVideo)(NULL, pp, pp->pDraw);
pp->pDraw = NULL;
pp->client = NULL;
pp->time = currentTime;
}
pp++;
}
pa++;
}
status = (* pScreen->DestroyPixmap)(pPix);
SCREEN_EPILOGUE(pScreen, DestroyPixmap, XvDestroyPixmap);
return status;
}
static void
SecurityClientState(CallbackListPtr *pcbl, pointer unused, pointer calldata)
{
NewClientInfoRec *pci = calldata;
SecurityStateRec *state;
SecurityAuthorizationPtr pAuth;
int rc;
state = dixLookupPrivate(&pci->client->devPrivates, stateKey);
switch (pci->client->clientState) {
case ClientStateInitial:
state->trustLevel = XSecurityClientTrusted;
state->authId = None;
state->haveState = TRUE;
break;
case ClientStateRunning:
state->authId = AuthorizationIDOfClient(pci->client);
rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,
SecurityAuthorizationResType, serverClient,
DixGetAttrAccess);
if (rc == Success) {
/* it is a generated authorization */
pAuth->refcnt++;
if (pAuth->refcnt == 1 && pAuth->timer)
TimerCancel(pAuth->timer);
state->trustLevel = pAuth->trustLevel;
}
break;
case ClientStateGone:
case ClientStateRetained:
rc = dixLookupResourceByType((pointer *)&pAuth, state->authId,
SecurityAuthorizationResType, serverClient,
DixGetAttrAccess);
if (rc == Success) {
/* it is a generated authorization */
pAuth->refcnt--;
if (pAuth->refcnt == 0)
SecurityStartAuthorizationTimer(pAuth);
}
break;
default:
break;
}
}
static void
VGAarbiterLeaveVT(int index, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[index];
ScreenPtr pScreen = screenInfo.screens[index];
VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
&pScreen->devPrivates, VGAarbiterScreenKey);
VGAGet(pScreen);
pScrn->LeaveVT = pScreenPriv->LeaveVT;
(*pScreenPriv->LeaveVT)(index, flags);
pScreenPriv->LeaveVT = pScrn->LeaveVT;
pScrn->LeaveVT = VGAarbiterLeaveVT;
VGAPut();
}
static void
VGAarbiterLeaveVT(ScrnInfoPtr pScrn)
{
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
VGAarbiterScreenPtr pScreenPriv =
(VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
VGAarbiterScreenKey);
VGAGet(pScreen);
pScrn->LeaveVT = pScreenPriv->LeaveVT;
(*pScreenPriv->LeaveVT) (pScrn);
pScreenPriv->LeaveVT = pScrn->LeaveVT;
pScrn->LeaveVT = VGAarbiterLeaveVT;
VGAPut();
}
static Bool
XAAEnterVT(int index, int flags)
{
ScrnInfoPtr pScrn = xf86Screens[index];
Bool ret;
ScreenPtr pScreen = screenInfo.screens[index];
XAAScreenPtr pScreenPriv =
(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
pScrn->EnterVT = pScreenPriv->EnterVT;
ret = ((*pScreenPriv->EnterVT)(index, flags));
pScreenPriv->EnterVT = pScrn->EnterVT;
pScrn->EnterVT = XAAEnterVT;
return ret;
}
static void
miDCPutBits(DrawablePtr pDrawable,
GCPtr sourceGC,
GCPtr maskGC,
int x_org,
int y_org,
unsigned w, unsigned h, unsigned long source, unsigned long mask)
{
miDCScreenPtr pScreenPriv = dixLookupPrivate(&pDrawable->pScreen->devPrivates, miDCScreenKey);
ChangeGCVal gcval;
int x, y;
if (sourceGC->fgPixel != source) {
gcval.val = source;
ChangeGC(NullClient, sourceGC, GCForeground, &gcval);
}
if (sourceGC->serialNumber != pDrawable->serialNumber)
ValidateGC(pDrawable, sourceGC);
if (sourceGC->miTranslate) {
x = pDrawable->x + x_org;
y = pDrawable->y + y_org;
}
else {
x = x_org;
y = y_org;
}
(*sourceGC->ops->PushPixels) (sourceGC, pScreenPriv->sourceBits, pDrawable, w, h,
x, y);
if (maskGC->fgPixel != mask) {
gcval.val = mask;
ChangeGC(NullClient, maskGC, GCForeground, &gcval);
}
if (maskGC->serialNumber != pDrawable->serialNumber)
ValidateGC(pDrawable, maskGC);
if (maskGC->miTranslate) {
x = pDrawable->x + x_org;
y = pDrawable->y + y_org;
}
else {
x = x_org;
y = y_org;
}
(*maskGC->ops->PushPixels) (maskGC, pScreenPriv->maskBits, pDrawable, w, h, x, y);
}
Bool
xf86RegisterFreeBoxCallback(ScreenPtr pScreen,
FreeBoxCallbackProcPtr FreeBoxCallback,
void *devPriv)
{
FBManagerFuncsPtr funcs;
if (xf86FBManagerKey == NULL)
return FALSE;
if (!(funcs = (FBManagerFuncsPtr) dixLookupPrivate(&pScreen->devPrivates,
xf86FBManagerKey)))
return FALSE;
return (*funcs->RegisterFreeBoxCallback) (pScreen, FreeBoxCallback,
devPriv);
}
static Bool
exaXorgCloseScreen (int i, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen);
ExaXorgScreenPrivPtr pScreenPriv = (ExaXorgScreenPrivPtr)
dixLookupPrivate(&pScreen->devPrivates, exaXorgScreenPrivateKey);
pScreen->CloseScreen = pScreenPriv->SavedCloseScreen;
pScrn->EnableDisableFBAccess = pScreenPriv->SavedEnableDisableFBAccess;
xfree (pScreenPriv->options);
xfree (pScreenPriv);
return pScreen->CloseScreen (i, pScreen);
}
static Bool
DtloginCloseScreen (ScreenPtr pScreen)
{
struct dmScreenPriv *pScreenPriv;
DtloginCloseDown();
/* Unwrap CloseScreen and call down to further levels */
pScreenPriv = (struct dmScreenPriv *)
dixLookupPrivate(&pScreen->devPrivates, dmScreenKey);
pScreen->CloseScreen = pScreenPriv->CloseScreen;
free (pScreenPriv);
return (*pScreen->CloseScreen) (pScreen);
}
static void
exaXorgEnableDisableFBAccess (int index, Bool enable)
{
ScreenPtr pScreen = screenInfo.screens[index];
ExaXorgScreenPrivPtr pScreenPriv = (ExaXorgScreenPrivPtr)
dixLookupPrivate(&pScreen->devPrivates, exaXorgScreenPrivateKey);
if (!enable)
exaEnableDisableFBAccess (index, enable);
if (pScreenPriv->SavedEnableDisableFBAccess)
pScreenPriv->SavedEnableDisableFBAccess (index, enable);
if (enable)
exaEnableDisableFBAccess (index, enable);
}
static Bool
exaXorgCloseScreen(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
ExaXorgScreenPrivPtr pScreenPriv = (ExaXorgScreenPrivPtr)
dixLookupPrivate(&pScreen->devPrivates, exaXorgScreenPrivateKey);
pScreen->CloseScreen = pScreenPriv->SavedCloseScreen;
pScrn->EnableDisableFBAccess = pScreenPriv->SavedEnableDisableFBAccess;
free(pScreenPriv->options);
free(pScreenPriv);
return pScreen->CloseScreen(pScreen);
}
static void
exaXorgEnableDisableFBAccess(ScrnInfoPtr pScrn, Bool enable)
{
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
ExaXorgScreenPrivPtr pScreenPriv = (ExaXorgScreenPrivPtr)
dixLookupPrivate(&pScreen->devPrivates, exaXorgScreenPrivateKey);
if (!enable)
exaEnableDisableFBAccess(pScreen, enable);
if (pScreenPriv->SavedEnableDisableFBAccess)
pScreenPriv->SavedEnableDisableFBAccess(pScrn, enable);
if (enable)
exaEnableDisableFBAccess(pScreen, enable);
}
void
uxa_glyph_unrealize(ScreenPtr screen,
GlyphPtr glyph)
{
struct uxa_glyph *priv;
/* Use Lookup in case we have not attached to this glyph. */
priv = dixLookupPrivate(&glyph->devPrivates, &uxa_glyph_key);
if (priv == NULL)
return;
priv->cache->glyphs[priv->pos] = NULL;
uxa_glyph_set_private(glyph, NULL);
free(priv);
}
Bool
fbCloseScreen (int index, ScreenPtr pScreen)
{
int d;
DepthPtr depths = pScreen->allowedDepths;
for (d = 0; d < pScreen->numDepths; d++)
xfree (depths[d].vids);
xfree (depths);
xfree (pScreen->visuals);
xfree (pScreen->devPrivate);
#ifdef FB_SCREEN_PRIVATE
xfree (dixLookupPrivate(&pScreen->devPrivates, fbGetScreenPrivateKey()));
#endif
return TRUE;
}
static Bool
xwlVidModeGetCurrentModeline(ScreenPtr pScreen, DisplayModePtr *mode, int *dotClock)
{
DisplayModePtr pMod;
RROutputPtr output;
RRCrtcPtr crtc;
xRRModeInfo rrmode;
pMod = dixLookupPrivate(&pScreen->devPrivates, xwlVidModePrivateKey);
if (pMod == NULL)
return FALSE;
output = RRFirstOutput(pScreen);
if (output == NULL)
return FALSE;
crtc = output->crtc;
if (crtc == NULL)
return FALSE;
rrmode = crtc->mode->mode;
pMod->next = pMod;
pMod->prev = pMod;
pMod->name = "";
pMod->VScan = 1;
pMod->Private = NULL;
pMod->HDisplay = rrmode.width;
pMod->HSyncStart = rrmode.hSyncStart;
pMod->HSyncEnd = rrmode.hSyncEnd;
pMod->HTotal = rrmode.hTotal;
pMod->HSkew = rrmode.hSkew;
pMod->VDisplay = rrmode.height;
pMod->VSyncStart = rrmode.vSyncStart;
pMod->VSyncEnd = rrmode.vSyncEnd;
pMod->VTotal = rrmode.vTotal;
pMod->Flags = rrmode.modeFlags;
pMod->Clock = rrmode.dotClock / 1000.0;
pMod->VRefresh = mode_refresh(&rrmode); /* Or RRVerticalRefresh() */
pMod->HSync = mode_hsync(&rrmode);
*mode = pMod;
if (dotClock != NULL)
*dotClock = rrmode.dotClock / 1000.0;
return TRUE;
}
void
MultibufferExtensionInit()
{
ExtensionEntry *extEntry;
int i, j;
ScreenPtr pScreen;
MultibufferScreenPtr pMultibufferScreen;
for (i = 0; i < screenInfo.numScreens; i++)
{
pScreen = screenInfo.screens[i];
if (!(pMultibufferScreen = (MultibufferScreenPtr) xalloc (sizeof (MultibufferScreenRec))))
{
for (j = 0; j < i; j++)
xfree (dixLookupPrivate(&screenInfo.screens[j]->devPrivates, MultibufferScreenPrivKey));
return;
}
dixSetPrivate(&pScreen->devPrivates, MultibufferScreenPrivKey, pMultibufferScreen);
/*
* wrap PositionWindow to resize the pixmap when the window
* changes size
*/
pMultibufferScreen->PositionWindow = pScreen->PositionWindow;
pScreen->PositionWindow = MultibufferPositionWindow;
}
/*
* create the resource types
*/
MultibufferDrawableResType =
CreateNewResourceType(MultibufferDrawableDelete)|RC_DRAWABLE;
MultibufferResType = CreateNewResourceType(MultibufferDelete);
MultibuffersResType = CreateNewResourceType(MultibuffersDelete);
OtherClientResType = CreateNewResourceType(OtherClientDelete);
if (MultibufferDrawableResType && MultibufferResType &&
MultibuffersResType && OtherClientResType &&
(extEntry = AddExtension(MULTIBUFFER_PROTOCOL_NAME,
MultibufferNumberEvents,
MultibufferNumberErrors,
ProcMultibufferDispatch, SProcMultibufferDispatch,
MultibufferResetProc, StandardMinorOpcode)))
{
MultibufferEventBase = extEntry->eventBase;
MultibufferErrorBase = extEntry->errorBase;
EventSwapVector[MultibufferEventBase + MultibufferClobberNotify] = (EventSwapPtr) SClobberNotifyEvent;
EventSwapVector[MultibufferEventBase + MultibufferUpdateNotify] = (EventSwapPtr) SUpdateNotifyEvent;
}
}
static int
ProcSELinuxGetClientContext(ClientPtr client)
{
ClientPtr target;
SELinuxSubjectRec *subj;
int rc;
REQUEST(SELinuxGetContextReq);
REQUEST_SIZE_MATCH(SELinuxGetContextReq);
rc = dixLookupClient(&target, stuff->id, client, DixGetAttrAccess);
if (rc != Success)
return rc;
subj = dixLookupPrivate(&target->devPrivates, subjectKey);
return SELinuxSendContextReply(client, subj->sid);
}
static int
ProcSELinuxGetSelectionContext(ClientPtr client, pointer privKey)
{
Selection *pSel;
SELinuxObjectRec *obj;
int rc;
REQUEST(SELinuxGetContextReq);
REQUEST_SIZE_MATCH(SELinuxGetContextReq);
rc = dixLookupSelection(&pSel, stuff->id, client, DixGetAttrAccess);
if (rc != Success)
return rc;
obj = dixLookupPrivate(&pSel->devPrivates, privKey);
return SELinuxSendContextReply(client, obj->sid);
}
static Bool
VGAarbiterEnterVT(ScrnInfoPtr pScrn)
{
Bool val;
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
VGAarbiterScreenPtr pScreenPriv =
(VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
VGAarbiterScreenKey);
VGAGet(pScreen);
pScrn->EnterVT = pScreenPriv->EnterVT;
val = (*pScrn->EnterVT) (pScrn);
pScreenPriv->EnterVT = pScrn->EnterVT;
pScrn->EnterVT = VGAarbiterEnterVT;
VGAPut();
return val;
}
Bool
xf86QueryLargestOffscreenLinear(ScreenPtr pScreen,
int *size, int gran, int severity)
{
FBManagerFuncsPtr funcs;
*size = 0;
if (xf86FBManagerKey == NULL)
return FALSE;
if (!(funcs = (FBManagerFuncsPtr) dixLookupPrivate(&pScreen->devPrivates,
xf86FBManagerKey)))
return FALSE;
return (*funcs->QueryLargestOffscreenLinear) (pScreen, size, gran,
severity);
}
static FBAreaPtr
localAllocateOffscreenArea(ScreenPtr pScreen,
int w, int h,
int gran,
MoveAreaCallbackProcPtr moveCB,
RemoveAreaCallbackProcPtr removeCB, void *privData)
{
FBManagerPtr offman;
FBAreaPtr area = NULL;
offman = (FBManagerPtr) dixLookupPrivate(&pScreen->devPrivates,
xf86FBScreenKey);
if ((area = AllocateArea(offman, w, h, gran, moveCB, removeCB, privData)))
SendCallFreeBoxCallbacks(offman);
return area;
}
static Bool
localPurgeUnlockedOffscreenAreas(ScreenPtr pScreen)
{
FBManagerPtr offman;
FBLinkPtr pLink, tmp, pPrev = NULL;
RegionRec FreedRegion;
Bool anyUsed = FALSE;
offman = (FBManagerPtr) dixLookupPrivate(&pScreen->devPrivates,
xf86FBScreenKey);
pLink = offman->UsedAreas;
if (!pLink)
return TRUE;
while (pLink) {
if (pLink->area.RemoveAreaCallback) {
(*pLink->area.RemoveAreaCallback) (&pLink->area);
RegionInit(&FreedRegion, &(pLink->area.box), 1);
RegionAppend(offman->FreeBoxes, &FreedRegion);
RegionUninit(&FreedRegion);
if (pPrev)
pPrev->next = pLink->next;
else
offman->UsedAreas = pLink->next;
tmp = pLink;
pLink = pLink->next;
free(tmp);
offman->NumUsedAreas--;
anyUsed = TRUE;
}
else {
pPrev = pLink;
pLink = pLink->next;
}
}
if (anyUsed) {
RegionValidate(offman->FreeBoxes, &anyUsed);
SendCallFreeBoxCallbacks(offman);
}
return TRUE;
}
static void
shadowReportFunc(DamagePtr pDamage, RegionPtr pRegion, void *closure)
{
ScreenPtr pScreen = closure;
shadowBufPtr pBuf = (shadowBufPtr)
dixLookupPrivate(&pScreen->devPrivates, shadowScrPrivateKey);
/* Register the damaged region, use DamageReportNone below when we
* want to break BC below... */
RegionUnion(&pDamage->damage, &pDamage->damage, pRegion);
/*
* BC hack. In 7.0 and earlier several drivers would inspect the
* 'damage' member directly, so we have to keep it existing.
*/
RegionCopy(&pBuf->damage, pRegion);
}
