andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

xserver/output: rename some badly named variables/APIs. 

This is an API and ABI break

Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Dave Airlie 2020-07-06 07:00:50 +10:00
parent 15b7738389
commit ea47af87f6
23 changed files with 363 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
dix/dispatch.c
View File

@ -3860,7 +3860,7 @@ static int init_screen(ScreenPtr pScreen, int i, Bool gpu)
pScreen->CreateScreenResources = 0;
xorg_list_init(&pScreen->pixmap_dirty_list);
xorg_list_init(&pScreen->slave_list);
xorg_list_init(&pScreen->secondary_list);
/*
* This loop gets run once for every Screen that gets added,
@ -4028,54 +4028,54 @@ void
AttachUnboundGPU(ScreenPtr pScreen, ScreenPtr new)
{
assert(new->isGPU);
assert(!new->current_master);
xorg_list_add(&new->slave_head, &pScreen->slave_list);
new->current_master = pScreen;
assert(!new->current_primary);
xorg_list_add(&new->secondary_head, &pScreen->secondary_list);
new->current_primary = pScreen;
}
void
DetachUnboundGPU(ScreenPtr slave)
DetachUnboundGPU(ScreenPtr secondary)
{
assert(slave->isGPU);
assert(!slave->is_output_slave);
assert(!slave->is_offload_slave);
xorg_list_del(&slave->slave_head);
slave->current_master = NULL;
assert(secondary->isGPU);
assert(!secondary->is_output_secondary);
assert(!secondary->is_offload_secondary);
xorg_list_del(&secondary->secondary_head);
secondary->current_primary = NULL;
}
void
AttachOutputGPU(ScreenPtr pScreen, ScreenPtr new)
{
assert(new->isGPU);
assert(!new->is_output_slave);
assert(new->current_master == pScreen);
new->is_output_slave = TRUE;
new->current_master->output_slaves++;
assert(!new->is_output_secondary);
assert(new->current_primary == pScreen);
new->is_output_secondary = TRUE;
new->current_primary->output_secondarys++;
}
void
DetachOutputGPU(ScreenPtr slave)
DetachOutputGPU(ScreenPtr secondary)
{
assert(slave->isGPU);
assert(slave->is_output_slave);
slave->current_master->output_slaves--;
slave->is_output_slave = FALSE;
assert(secondary->isGPU);
assert(secondary->is_output_secondary);
secondary->current_primary->output_secondarys--;
secondary->is_output_secondary = FALSE;
}
void
AttachOffloadGPU(ScreenPtr pScreen, ScreenPtr new)
{
assert(new->isGPU);
assert(!new->is_offload_slave);
assert(new->current_master == pScreen);
new->is_offload_slave = TRUE;
assert(!new->is_offload_secondary);
assert(new->current_primary == pScreen);
new->is_offload_secondary = TRUE;
}
void
DetachOffloadGPU(ScreenPtr slave)
DetachOffloadGPU(ScreenPtr secondary)
{
assert(slave->isGPU);
assert(slave->is_offload_slave);
slave->is_offload_slave = FALSE;
assert(secondary->isGPU);
assert(secondary->is_offload_secondary);
secondary->is_offload_secondary = FALSE;
}

52
dix/pixmap.c
View File

@ -132,40 +132,40 @@ FreePixmap(PixmapPtr pPixmap)
free(pPixmap);
}
void PixmapUnshareSlavePixmap(PixmapPtr slave_pixmap)
void PixmapUnshareSecondaryPixmap(PixmapPtr secondary_pixmap)
{
int ihandle = -1;
ScreenPtr pScreen = slave_pixmap->drawable.pScreen;
pScreen->SetSharedPixmapBacking(slave_pixmap, ((void *)(long)ihandle));
ScreenPtr pScreen = secondary_pixmap->drawable.pScreen;
pScreen->SetSharedPixmapBacking(secondary_pixmap, ((void *)(long)ihandle));
}
PixmapPtr PixmapShareToSlave(PixmapPtr pixmap, ScreenPtr slave)
PixmapPtr PixmapShareToSecondary(PixmapPtr pixmap, ScreenPtr secondary)
{
PixmapPtr spix;
int ret;
void *handle;
ScreenPtr master = pixmap->drawable.pScreen;
ScreenPtr primary = pixmap->drawable.pScreen;
int depth = pixmap->drawable.depth;
ret = master->SharePixmapBacking(pixmap, slave, &handle);
ret = primary->SharePixmapBacking(pixmap, secondary, &handle);
if (ret == FALSE)
return NULL;
spix = slave->CreatePixmap(slave, 0, 0, depth,
spix = secondary->CreatePixmap(secondary, 0, 0, depth,
CREATE_PIXMAP_USAGE_SHARED);
slave->ModifyPixmapHeader(spix, pixmap->drawable.width,
pixmap->drawable.height, depth, 0,
pixmap->devKind, NULL);
secondary->ModifyPixmapHeader(spix, pixmap->drawable.width,
pixmap->drawable.height, depth, 0,
pixmap->devKind, NULL);
/* have the slave pixmap take a reference on the master pixmap
/* have the secondary pixmap take a reference on the primary pixmap
later we destroy them both at the same time */
pixmap->refcnt++;
spix->master_pixmap = pixmap;
spix->primary_pixmap = pixmap;
ret = slave->SetSharedPixmapBacking(spix, handle);
ret = secondary->SetSharedPixmapBacking(spix, handle);
if (ret == FALSE) {
slave->DestroyPixmap(spix);
secondary->DestroyPixmap(spix);
return NULL;
}
@ -182,7 +182,7 @@ PixmapDirtyDamageDestroy(DamagePtr damage, void *closure)
Bool
PixmapStartDirtyTracking(DrawablePtr src,
PixmapPtr slave_dst,
PixmapPtr secondary_dst,
int x, int y, int dst_x, int dst_y,
Rotation rotation)
{
@ -197,7 +197,7 @@ PixmapStartDirtyTracking(DrawablePtr src,
return FALSE;
dirty_update->src = src;
dirty_update->slave_dst = slave_dst;
dirty_update->secondary_dst = secondary_dst;
dirty_update->x = x;
dirty_update->y = y;
dirty_update->dst_x = dst_x;
@ -209,8 +209,8 @@ PixmapStartDirtyTracking(DrawablePtr src,
if (rotation != RR_Rotate_0) {
RRTransformCompute(x, y,
slave_dst->drawable.width,
slave_dst->drawable.height,
secondary_dst->drawable.width,
secondary_dst->drawable.height,
rotation,
NULL,
&dirty_update->transform,
@ -229,11 +229,11 @@ PixmapStartDirtyTracking(DrawablePtr src,
box.y1 = dirty_update->y;
if (dirty_update->rotation == RR_Rotate_90 ||
dirty_update->rotation == RR_Rotate_270) {
box.x2 = dirty_update->x + slave_dst->drawable.height;
box.y2 = dirty_update->y + slave_dst->drawable.width;
box.x2 = dirty_update->x + secondary_dst->drawable.height;
box.y2 = dirty_update->y + secondary_dst->drawable.width;
} else {
box.x2 = dirty_update->x + slave_dst->drawable.width;
box.y2 = dirty_update->y + slave_dst->drawable.height;
box.x2 = dirty_update->x + secondary_dst->drawable.width;
box.y2 = dirty_update->y + secondary_dst->drawable.height;
}
RegionInit(&dstregion, &box, 1);
damageregion = DamageRegion(dirty_update->damage);
@ -246,13 +246,13 @@ PixmapStartDirtyTracking(DrawablePtr src,
}
Bool
PixmapStopDirtyTracking(DrawablePtr src, PixmapPtr slave_dst)
PixmapStopDirtyTracking(DrawablePtr src, PixmapPtr secondary_dst)
{
ScreenPtr screen = src->pScreen;
PixmapDirtyUpdatePtr ent, safe;
xorg_list_for_each_entry_safe(ent, safe, &screen->pixmap_dirty_list, ent) {
if (ent->src == src && ent->slave_dst == slave_dst) {
if (ent->src == src && ent->secondary_dst == secondary_dst) {
if (ent->damage)
DamageDestroy(ent->damage);
xorg_list_del(&ent->ent);
@ -372,9 +372,9 @@ Bool PixmapSyncDirtyHelper(PixmapDirtyUpdatePtr dirty)
RegionRec pixregion;
BoxRec box;
dst = dirty->slave_dst->master_pixmap;
dst = dirty->secondary_dst->primary_pixmap;
if (!dst)
dst = dirty->slave_dst;
dst = dirty->secondary_dst;
box.x1 = 0;
box.y1 = 0;

2
fb/fbpixmap.c
View File

@ -68,7 +68,7 @@ fbCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,
pPixmap->devKind = paddedWidth;
pPixmap->refcnt = 1;
pPixmap->devPrivate.ptr = (void *) ((char *) pPixmap + base + adjust);
pPixmap->master_pixmap = NULL;
pPixmap->primary_pixmap = NULL;
#ifdef FB_DEBUG
pPixmap->devPrivate.ptr =

68
hw/xfree86/dri2/dri2.c
View File

@ -98,7 +98,7 @@ typedef struct _DRI2Drawable {
unsigned blocked[3];
Bool needInvalidate;
int prime_id;
PixmapPtr prime_slave_pixmap;
PixmapPtr prime_secondary_pixmap;
PixmapPtr redirectpixmap;
} DRI2DrawableRec, *DRI2DrawablePtr;
@ -181,33 +181,33 @@ DRI2GetScreen(ScreenPtr pScreen)
}
static ScreenPtr
GetScreenPrime(ScreenPtr master, int prime_id)
GetScreenPrime(ScreenPtr primary, int prime_id)
{
ScreenPtr slave;
ScreenPtr secondary;
if (prime_id == 0) {
return master;
return primary;
}
xorg_list_for_each_entry(slave, &master->slave_list, slave_head) {
xorg_list_for_each_entry(secondary, &primary->secondary_list, secondary_head) {
DRI2ScreenPtr ds;
if (!slave->is_offload_slave)
if (!secondary->is_offload_secondary)
continue;
ds = DRI2GetScreen(slave);
ds = DRI2GetScreen(secondary);
if (ds == NULL)
continue;
if (ds->prime_id == prime_id)
return slave;
return secondary;
}
return master;
return primary;
}
static DRI2ScreenPtr
DRI2GetScreenPrime(ScreenPtr master, int prime_id)
DRI2GetScreenPrime(ScreenPtr primary, int prime_id)
{
ScreenPtr slave = GetScreenPrime(master, prime_id);
return DRI2GetScreen(slave);
ScreenPtr secondary = GetScreenPrime(primary, prime_id);
return DRI2GetScreen(secondary);
}
static DRI2DrawablePtr
@ -262,7 +262,7 @@ DRI2AllocateDrawable(DrawablePtr pDraw)
xorg_list_init(&pPriv->reference_list);
pPriv->needInvalidate = FALSE;
pPriv->redirectpixmap = NULL;
pPriv->prime_slave_pixmap = NULL;
pPriv->prime_secondary_pixmap = NULL;
if (pDraw->type == DRAWABLE_WINDOW) {
pWin = (WindowPtr) pDraw;
dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);
@ -427,9 +427,9 @@ DRI2DrawableGone(void *p, XID id)
dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, NULL);
}
if (pPriv->prime_slave_pixmap) {
(*pPriv->prime_slave_pixmap->master_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap->master_pixmap);
(*pPriv->prime_slave_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap);
if (pPriv->prime_secondary_pixmap) {
(*pPriv->prime_secondary_pixmap->primary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap->primary_pixmap);
(*pPriv->prime_secondary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap);
}
if (pPriv->buffers != NULL) {
@ -815,10 +815,10 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
PixmapPtr spix;
PixmapPtr mpix = GetDrawablePixmap(pDraw);
ScreenPtr master, slave;
ScreenPtr primary, secondary;
Bool ret;
master = mpix->drawable.pScreen;
primary = mpix->drawable.pScreen;
if (pDraw->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr)pDraw;
@ -831,15 +831,15 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
pPriv->redirectpixmap->drawable.depth == pDraw->depth) {
mpix = pPriv->redirectpixmap;
} else {
if (master->ReplaceScanoutPixmap) {
mpix = (*master->CreatePixmap)(master, pDraw->width, pDraw->height,
if (primary->ReplaceScanoutPixmap) {
mpix = (*primary->CreatePixmap)(primary, pDraw->width, pDraw->height,
pDraw->depth, CREATE_PIXMAP_USAGE_SHARED);
if (!mpix)
return NULL;
ret = (*master->ReplaceScanoutPixmap)(pDraw, mpix, TRUE);
ret = (*primary->ReplaceScanoutPixmap)(pDraw, mpix, TRUE);
if (ret == FALSE) {
(*master->DestroyPixmap)(mpix);
(*primary->DestroyPixmap)(mpix);
return NULL;
}
pPriv->redirectpixmap = mpix;
@ -847,31 +847,31 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
return NULL;
}
} else if (pPriv->redirectpixmap) {
(*master->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
(*master->DestroyPixmap)(pPriv->redirectpixmap);
(*primary->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
(*primary->DestroyPixmap)(pPriv->redirectpixmap);
pPriv->redirectpixmap = NULL;
}
}
slave = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
secondary = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
/* check if the pixmap is still fine */
if (pPriv->prime_slave_pixmap) {
if (pPriv->prime_slave_pixmap->master_pixmap == mpix)
return &pPriv->prime_slave_pixmap->drawable;
if (pPriv->prime_secondary_pixmap) {
if (pPriv->prime_secondary_pixmap->primary_pixmap == mpix)
return &pPriv->prime_secondary_pixmap->drawable;
else {
PixmapUnshareSlavePixmap(pPriv->prime_slave_pixmap);
(*pPriv->prime_slave_pixmap->master_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap->master_pixmap);
(*slave->DestroyPixmap)(pPriv->prime_slave_pixmap);
pPriv->prime_slave_pixmap = NULL;
PixmapUnshareSecondaryPixmap(pPriv->prime_secondary_pixmap);
(*pPriv->prime_secondary_pixmap->primary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap->primary_pixmap);
(*secondary->DestroyPixmap)(pPriv->prime_secondary_pixmap);
pPriv->prime_secondary_pixmap = NULL;
}
}
spix = PixmapShareToSlave(mpix, slave);
spix = PixmapShareToSecondary(mpix, secondary);
if (!spix)
return NULL;
pPriv->prime_slave_pixmap = spix;
pPriv->prime_secondary_pixmap = spix;
#ifdef COMPOSITE
spix->screen_x = mpix->screen_x;
spix->screen_y = mpix->screen_y;

78
hw/xfree86/drivers/modesetting/driver.c
View File

@ -569,14 +569,14 @@ dispatch_dirty_pixmap(ScrnInfoPtr scrn, xf86CrtcPtr crtc, PixmapPtr ppix)
{
modesettingPtr ms = modesettingPTR(scrn);
msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix);
DamagePtr damage = ppriv->slave_damage;
DamagePtr damage = ppriv->secondary_damage;
int fb_id = ppriv->fb_id;
dispatch_dirty_region(scrn, ppix, damage, fb_id);
}
static void
dispatch_slave_dirty(ScreenPtr pScreen)
dispatch_secondary_dirty(ScreenPtr pScreen)
{
ScrnInfoPtr scrn = xf86ScreenToScrn(pScreen);
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
@ -601,28 +601,28 @@ redisplay_dirty(ScreenPtr screen, PixmapDirtyUpdatePtr dirty, int *timeout)
{
RegionRec pixregion;
PixmapRegionInit(&pixregion, dirty->slave_dst);
DamageRegionAppend(&dirty->slave_dst->drawable, &pixregion);
PixmapRegionInit(&pixregion, dirty->secondary_dst);
DamageRegionAppend(&dirty->secondary_dst->drawable, &pixregion);
PixmapSyncDirtyHelper(dirty);
if (!screen->isGPU) {
#ifdef GLAMOR_HAS_GBM
modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(screen));
/*
* When copying from the master framebuffer to the shared pixmap,
* we must ensure the copy is complete before the slave starts a
* copy to its own framebuffer (some slaves scanout directly from
* When copying from the primary framebuffer to the shared pixmap,
* we must ensure the copy is complete before the secondary starts a
* copy to its own framebuffer (some secondarys scanout directly from
* the shared pixmap, but not all).
*/
if (ms->drmmode.glamor)
ms->glamor.finish(screen);
#endif
/* Ensure the slave processes the damage immediately */
/* Ensure the secondary processes the damage immediately */
if (timeout)
*timeout = 0;
}
DamageRegionProcessPending(&dirty->slave_dst->drawable);
DamageRegionProcessPending(&dirty->secondary_dst->drawable);
RegionUninit(&pixregion);
}
@ -642,13 +642,13 @@ ms_dirty_update(ScreenPtr screen, int *timeout)
if (RegionNotEmpty(region)) {
if (!screen->isGPU) {
msPixmapPrivPtr ppriv =
msGetPixmapPriv(&ms->drmmode, ent->slave_dst->master_pixmap);
msGetPixmapPriv(&ms->drmmode, ent->secondary_dst->primary_pixmap);
if (ppriv->notify_on_damage) {
ppriv->notify_on_damage = FALSE;
ent->slave_dst->drawable.pScreen->
SharedPixmapNotifyDamage(ent->slave_dst);
ent->secondary_dst->drawable.pScreen->
SharedPixmapNotifyDamage(ent->secondary_dst);
}
/* Requested manual updating */
@ -663,7 +663,7 @@ ms_dirty_update(ScreenPtr screen, int *timeout)
}
static PixmapDirtyUpdatePtr
ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
ms_dirty_get_ent(ScreenPtr screen, PixmapPtr secondary_dst)
{
PixmapDirtyUpdatePtr ent;
@ -671,7 +671,7 @@ ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
return NULL;
xorg_list_for_each_entry(ent, &screen->pixmap_dirty_list, ent) {
if (ent->slave_dst == slave_dst)
if (ent->secondary_dst == secondary_dst)
return ent;
}
@ -688,7 +688,7 @@ msBlockHandler(ScreenPtr pScreen, void *timeout)
ms->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = msBlockHandler;
if (pScreen->isGPU && !ms->drmmode.reverse_prime_offload_mode)
dispatch_slave_dirty(pScreen);
dispatch_secondary_dirty(pScreen);
else if (ms->dirty_enabled)
dispatch_dirty(pScreen);
@ -1291,32 +1291,32 @@ msDisableSharedPixmapFlipping(RRCrtcPtr crtc)
static Bool
msStartFlippingPixmapTracking(RRCrtcPtr crtc, DrawablePtr src,
PixmapPtr slave_dst1, PixmapPtr slave_dst2,
PixmapPtr secondary_dst1, PixmapPtr secondary_dst2,
int x, int y, int dst_x, int dst_y,
Rotation rotation)
{
ScreenPtr pScreen = src->pScreen;
modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, slave_dst1->master_pixmap),
ppriv2 = msGetPixmapPriv(&ms->drmmode, slave_dst2->master_pixmap);
msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, secondary_dst1->primary_pixmap),
ppriv2 = msGetPixmapPriv(&ms->drmmode, secondary_dst2->primary_pixmap);
if (!PixmapStartDirtyTracking(src, slave_dst1, x, y,
if (!PixmapStartDirtyTracking(src, secondary_dst1, x, y,
dst_x, dst_y, rotation)) {
return FALSE;
}
if (!PixmapStartDirtyTracking(src, slave_dst2, x, y,
if (!PixmapStartDirtyTracking(src, secondary_dst2, x, y,
dst_x, dst_y, rotation)) {
PixmapStopDirtyTracking(src, slave_dst1);
PixmapStopDirtyTracking(src, secondary_dst1);
return FALSE;
}
ppriv1->slave_src = src;
ppriv2->slave_src = src;
ppriv1->secondary_src = src;
ppriv2->secondary_src = src;
ppriv1->dirty = ms_dirty_get_ent(pScreen, slave_dst1);
ppriv2->dirty = ms_dirty_get_ent(pScreen, slave_dst2);
ppriv1->dirty = ms_dirty_get_ent(pScreen, secondary_dst1);
ppriv2->dirty = ms_dirty_get_ent(pScreen, secondary_dst2);
ppriv1->defer_dirty_update = TRUE;
ppriv2->defer_dirty_update = TRUE;
@ -1325,17 +1325,17 @@ msStartFlippingPixmapTracking(RRCrtcPtr crtc, DrawablePtr src,
}
static Bool
msPresentSharedPixmap(PixmapPtr slave_dst)
msPresentSharedPixmap(PixmapPtr secondary_dst)
{
ScreenPtr pScreen = slave_dst->master_pixmap->drawable.pScreen;
ScreenPtr pScreen = secondary_dst->primary_pixmap->drawable.pScreen;
modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, slave_dst->master_pixmap);
msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, secondary_dst->primary_pixmap);
RegionPtr region = DamageRegion(ppriv->dirty->damage);
if (RegionNotEmpty(region)) {
redisplay_dirty(ppriv->slave_src->pScreen, ppriv->dirty, NULL);
redisplay_dirty(ppriv->secondary_src->pScreen, ppriv->dirty, NULL);
DamageEmpty(ppriv->dirty->damage);
return TRUE;
@ -1346,22 +1346,22 @@ msPresentSharedPixmap(PixmapPtr slave_dst)
static Bool
msStopFlippingPixmapTracking(DrawablePtr src,
PixmapPtr slave_dst1, PixmapPtr slave_dst2)
PixmapPtr secondary_dst1, PixmapPtr secondary_dst2)
{
ScreenPtr pScreen = src->pScreen;
modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, slave_dst1->master_pixmap),
ppriv2 = msGetPixmapPriv(&ms->drmmode, slave_dst2->master_pixmap);
msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, secondary_dst1->primary_pixmap),
ppriv2 = msGetPixmapPriv(&ms->drmmode, secondary_dst2->primary_pixmap);
Bool ret = TRUE;
ret &= PixmapStopDirtyTracking(src, slave_dst1);
ret &= PixmapStopDirtyTracking(src, slave_dst2);
ret &= PixmapStopDirtyTracking(src, secondary_dst1);
ret &= PixmapStopDirtyTracking(src, secondary_dst2);
if (ret) {
ppriv1->slave_src = NULL;
ppriv2->slave_src = NULL;
ppriv1->secondary_src = NULL;
ppriv2->secondary_src = NULL;
ppriv1->dirty = NULL;
ppriv2->dirty = NULL;
@ -1455,7 +1455,7 @@ CreateScreenResources(ScreenPtr pScreen)
}
static Bool
msSharePixmapBacking(PixmapPtr ppix, ScreenPtr slave, void **handle)
msSharePixmapBacking(PixmapPtr ppix, ScreenPtr secondary, void **handle)
{
#ifdef GLAMOR_HAS_GBM
modesettingPtr ms =
@ -1515,7 +1515,7 @@ msRequestSharedPixmapNotifyDamage(PixmapPtr ppix)
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
modesettingPtr ms = modesettingPTR(scrn);
msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix->master_pixmap);
msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix->primary_pixmap);
ppriv->notify_on_damage = TRUE;
@ -1548,7 +1548,7 @@ msSharedPixmapNotifyDamage(PixmapPtr ppix)
if (!(drmmode_crtc->prime_pixmap && drmmode_crtc->prime_pixmap_back))
continue;
// Received damage on master screen pixmap, schedule present on vblank
// Received damage on primary screen pixmap, schedule present on vblank
ret |= drmmode_SharedPixmapPresentOnVBlank(ppix, crtc, &ms->drmmode);
}

24
hw/xfree86/drivers/modesetting/drmmode_display.c
View File

@ -1089,9 +1089,9 @@ static Bool
drmmode_SharedPixmapPresent(PixmapPtr ppix, xf86CrtcPtr crtc,
drmmode_ptr drmmode)
{
ScreenPtr master = crtc->randr_crtc->pScreen->current_master;
ScreenPtr primary = crtc->randr_crtc->pScreen->current_primary;
if (master->PresentSharedPixmap(ppix)) {
if (primary->PresentSharedPixmap(ppix)) {
/* Success, queue flip to back target */
if (drmmode_SharedPixmapFlip(ppix, crtc, drmmode))
return TRUE;
@ -1103,13 +1103,13 @@ drmmode_SharedPixmapPresent(PixmapPtr ppix, xf86CrtcPtr crtc,
}
/* Failed to present, try again on next vblank after damage */
if (master->RequestSharedPixmapNotifyDamage) {
if (primary->RequestSharedPixmapNotifyDamage) {
msPixmapPrivPtr ppriv = msGetPixmapPriv(drmmode, ppix);
/* Set flag first in case we are immediately notified */
ppriv->wait_for_damage = TRUE;
if (master->RequestSharedPixmapNotifyDamage(ppix))
if (primary->RequestSharedPixmapNotifyDamage(ppix))
return TRUE;
else
ppriv->wait_for_damage = FALSE;
@ -1750,9 +1750,9 @@ drmmode_set_target_scanout_pixmap_cpu(xf86CrtcPtr crtc, PixmapPtr ppix,
ppriv = msGetPixmapPriv(drmmode, *target);
drmModeRmFB(drmmode->fd, ppriv->fb_id);
ppriv->fb_id = 0;
if (ppriv->slave_damage) {
DamageUnregister(ppriv->slave_damage);
ppriv->slave_damage = NULL;
if (ppriv->secondary_damage) {
DamageUnregister(ppriv->secondary_damage);
ppriv->secondary_damage = NULL;
}
*target = NULL;
}
@ -1761,16 +1761,16 @@ drmmode_set_target_scanout_pixmap_cpu(xf86CrtcPtr crtc, PixmapPtr ppix,
return TRUE;
ppriv = msGetPixmapPriv(drmmode, ppix);
if (!ppriv->slave_damage) {
ppriv->slave_damage = DamageCreate(NULL, NULL,
if (!ppriv->secondary_damage) {
ppriv->secondary_damage = DamageCreate(NULL, NULL,
DamageReportNone,
TRUE,
crtc->randr_crtc->pScreen,
NULL);
}
ptr = drmmode_map_slave_bo(drmmode, ppriv);
ptr = drmmode_map_secondary_bo(drmmode, ppriv);
ppix->devPrivate.ptr = ptr;
DamageRegister(&ppix->drawable, ppriv->slave_damage);
DamageRegister(&ppix->drawable, ppriv->secondary_damage);
if (ppriv->fb_id == 0) {
drmModeAddFB(drmmode->fd, ppix->drawable.width,
@ -3862,7 +3862,7 @@ drmmode_map_front_bo(drmmode_ptr drmmode)
}
void *
drmmode_map_slave_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv)
drmmode_map_secondary_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv)
{
int ret;

6
hw/xfree86/drivers/modesetting/drmmode_display.h
View File

@ -227,7 +227,7 @@ typedef struct _msPixmapPriv {
uint32_t fb_id;
struct dumb_bo *backing_bo; /* if this pixmap is backed by a dumb bo */
DamagePtr slave_damage;
DamagePtr secondary_damage;
/** Sink fields for flipping shared pixmaps */
int flip_seq; /* seq of current page flip event handler */
@ -236,7 +236,7 @@ typedef struct _msPixmapPriv {
/** Source fields for flipping shared pixmaps */
Bool defer_dirty_update; /* if we want to manually update */
PixmapDirtyUpdatePtr dirty; /* cached dirty ent to avoid searching list */
DrawablePtr slave_src; /* if we exported shared pixmap, dirty tracking src */
DrawablePtr secondary_src; /* if we exported shared pixmap, dirty tracking src */
Bool notify_on_damage; /* if sink has requested damage notification */
} msPixmapPrivRec, *msPixmapPrivPtr;
@ -259,7 +259,7 @@ int drmmode_bo_destroy(drmmode_ptr drmmode, drmmode_bo *bo);
uint32_t drmmode_bo_get_pitch(drmmode_bo *bo);
uint32_t drmmode_bo_get_handle(drmmode_bo *bo);
Bool drmmode_glamor_handle_new_screen_pixmap(drmmode_ptr drmmode);
void *drmmode_map_slave_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv);
void *drmmode_map_secondary_bo(drmmode_ptr drmmode, msPixmapPrivPtr ppriv);
Bool drmmode_SetSlaveBO(PixmapPtr ppix,
drmmode_ptr drmmode,
int fd_handle, int pitch, int size);

26
hw/xfree86/drivers/modesetting/vblank.c
View File

@ -115,7 +115,7 @@ ms_crtc_on(xf86CrtcPtr crtc)
/*
* Return the first output which is connected to an active CRTC on this screen.
*
* RRFirstOutput() will return an output from a slave screen if it is primary,
* RRFirstOutput() will return an output from a secondary screen if it is primary,
* which is not the behavior that ms_covering_crtc() wants.
*/
@ -188,10 +188,10 @@ ms_covering_xf86_crtc(ScreenPtr pScreen, BoxPtr box, Bool screen_is_ms)
}
}
/* Fallback to primary crtc for drawable's on slave outputs */
/* Fallback to primary crtc for drawable's on secondary outputs */
if (best_crtc == NULL && !pScreen->isGPU) {
RROutputPtr primary_output = NULL;
ScreenPtr slave;
ScreenPtr secondary;
if (dixPrivateKeyRegistered(rrPrivKey))
primary_output = ms_first_output(scrn->pScreen);
@ -202,12 +202,12 @@ ms_covering_xf86_crtc(ScreenPtr pScreen, BoxPtr box, Bool screen_is_ms)
if (!ms_crtc_on(crtc))
return NULL;
xorg_list_for_each_entry(slave, &pScreen->slave_list, slave_head) {
if (!slave->is_output_slave)
xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
if (!secondary->is_output_secondary)
continue;
if (ms_covering_xf86_crtc(slave, box, FALSE)) {
/* The drawable is on a slave output, return primary crtc */
if (ms_covering_xf86_crtc(secondary, box, FALSE)) {
/* The drawable is on a secondary output, return primary crtc */
return crtc;
}
}
@ -260,10 +260,10 @@ ms_covering_randr_crtc(ScreenPtr pScreen, BoxPtr box, Bool screen_is_ms)
}
}
/* Fallback to primary crtc for drawable's on slave outputs */
/* Fallback to primary crtc for drawable's on secondary outputs */
if (best_crtc == NULL && !pScreen->isGPU) {
RROutputPtr primary_output = NULL;
ScreenPtr slave;
ScreenPtr secondary;
if (dixPrivateKeyRegistered(rrPrivKey))
primary_output = ms_first_output(scrn->pScreen);
@ -274,12 +274,12 @@ ms_covering_randr_crtc(ScreenPtr pScreen, BoxPtr box, Bool screen_is_ms)
if (!ms_crtc_on((xf86CrtcPtr) crtc->devPrivate))
return NULL;
xorg_list_for_each_entry(slave, &pScreen->slave_list, slave_head) {
if (!slave->is_output_slave)
xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
if (!secondary->is_output_secondary)
continue;
if (ms_covering_randr_crtc(slave, box, FALSE)) {
/* The drawable is on a slave output, return primary crtc */
if (ms_covering_randr_crtc(secondary, box, FALSE)) {
/* The drawable is on a secondary output, return primary crtc */
return crtc;
}
}

2
hw/xfree86/modes/xf86Crtc.c
View File

@ -3110,7 +3110,7 @@ xf86DisableUnusedFunctions(ScrnInfoPtr pScrn)
pScrn->ModeSet(pScrn);
if (pScrn->pScreen) {
if (pScrn->pScreen->isGPU)
xf86CursorResetCursor(pScrn->pScreen->current_master);
xf86CursorResetCursor(pScrn->pScreen->current_primary);
else
xf86CursorResetCursor(pScrn->pScreen);
}

2
hw/xfree86/modes/xf86RandR12.c
View File

@ -2183,7 +2183,7 @@ xf86RandR14ProviderDestroy(ScreenPtr screen, RRProviderPtr provider)
config->randr_provider->output_source = NULL;
RRSetChanged(screen);
}
if (screen->current_master)
if (screen->current_primary)
DetachUnboundGPU(screen);
}
config->randr_provider = NULL;

4
hw/xfree86/modes/xf86Rotate.c
View File

@ -315,8 +315,8 @@ xf86CrtcFitsScreen(xf86CrtcPtr crtc, struct pict_f_transform *crtc_to_fb)
*/
if (pScrn->is_gpu) {
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
if (pScreen->current_master)
pScrn = xf86ScreenToScrn(pScreen->current_master);
if (pScreen->current_primary)
pScrn = xf86ScreenToScrn(pScreen->current_primary);
}
if (pScrn->virtualX == 0 || pScrn->virtualY == 0)

4
hw/xfree86/ramdac/xf86CursorRD.c
View File

@ -461,8 +461,8 @@ xf86CurrentCursor(ScreenPtr pScreen)
{
xf86CursorScreenPtr ScreenPriv;
if (pScreen->is_output_slave)
pScreen = pScreen->current_master;
if (pScreen->is_output_secondary)
pScreen = pScreen->current_primary;
ScreenPriv = dixLookupPrivate(&pScreen->devPrivates, xf86CursorScreenKey);
return ScreenPriv->CurrentCursor;

14
hw/xfree86/ramdac/xf86HWCurs.c
View File

@ -150,7 +150,7 @@ xf86CheckHWCursor(ScreenPtr pScreen, CursorPtr cursor, xf86CursorInfoPtr infoPtr
}
/* ask each driver consuming a pixmap if it can support HW cursor */
xorg_list_for_each_entry(pSlave, &pScreen->slave_list, slave_head) {
xorg_list_for_each_entry(pSlave, &pScreen->secondary_list, secondary_head) {
xf86CursorScreenPtr sPriv;
if (!RRHasScanoutPixmap(pSlave))
@ -162,7 +162,7 @@ xf86CheckHWCursor(ScreenPtr pScreen, CursorPtr cursor, xf86CursorInfoPtr infoPtr
break;
}
/* FALSE if HWCursor not supported by slave */
/* FALSE if HWCursor not supported by secondary */
if (!xf86ScreenCheckHWCursor(pSlave, cursor, sPriv->CursorInfoPtr)) {
use_hw_cursor = FALSE;
break;
@ -252,14 +252,14 @@ xf86SetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y)
if (!xf86ScreenSetCursor(pScreen, pCurs, x, y))
goto out;
/* ask each slave driver to set the cursor. */
xorg_list_for_each_entry(pSlave, &pScreen->slave_list, slave_head) {
/* ask each secondary driver to set the cursor. */
xorg_list_for_each_entry(pSlave, &pScreen->secondary_list, secondary_head) {
if (!RRHasScanoutPixmap(pSlave))
continue;
if (!xf86ScreenSetCursor(pSlave, pCurs, x, y)) {
/*
* hide the master (and successfully set slave) cursors,
* hide the primary (and successfully set secondary) cursors,
* otherwise both the hw and sw cursor will show.
*/
xf86SetCursor(pScreen, NullCursor, x, y);
@ -328,8 +328,8 @@ xf86MoveCursor(ScreenPtr pScreen, int x, int y)
xf86ScreenMoveCursor(pScreen, x, y);
/* ask each slave driver to move the cursor */
xorg_list_for_each_entry(pSlave, &pScreen->slave_list, slave_head) {
/* ask each secondary driver to move the cursor */
xorg_list_for_each_entry(pSlave, &pScreen->secondary_list, secondary_head) {
if (!RRHasScanoutPixmap(pSlave))
continue;

4
include/pixmap.h
View File

@ -113,10 +113,10 @@ extern _X_EXPORT PixmapPtr AllocatePixmap(ScreenPtr /*pScreen */ ,
extern _X_EXPORT void FreePixmap(PixmapPtr /*pPixmap */ );
extern _X_EXPORT PixmapPtr
PixmapShareToSlave(PixmapPtr pixmap, ScreenPtr slave);
PixmapShareToSecondary(PixmapPtr pixmap, ScreenPtr secondary);
extern _X_EXPORT void
PixmapUnshareSlavePixmap(PixmapPtr slave_pixmap);
PixmapUnshareSecondaryPixmap(PixmapPtr secondary_pixmap);
#define HAS_DIRTYTRACKING_ROTATION 1
#define HAS_DIRTYTRACKING_DRAWABLE_SRC 1

4
include/pixmapstr.h
View File

@ -84,12 +84,12 @@ typedef struct _Pixmap {
#endif
unsigned usage_hint; /* see CREATE_PIXMAP_USAGE_* */
PixmapPtr master_pixmap; /* pointer to master copy of pixmap for pixmap sharing */
PixmapPtr primary_pixmap; /* pointer to primary copy of pixmap for pixmap sharing */
} PixmapRec;
typedef struct _PixmapDirtyUpdate {
DrawablePtr src; /* Root window / shared pixmap */
PixmapPtr slave_dst; /* Shared / scanout pixmap */
PixmapPtr secondary_dst; /* Shared / scanout pixmap */
int x, y;
DamagePtr damage;
struct xorg_list ent;

26
include/scrnintstr.h
View File

@ -362,17 +362,17 @@ typedef Bool (*SetSharedPixmapBackingProcPtr)(PixmapPtr, void *);
#define HAS_SYNC_SHARED_PIXMAP 1
/* The SyncSharedPixmap hook has two purposes:
*
* 1. If the master driver has it, the slave driver can use it to
* 1. If the primary driver has it, the secondary driver can use it to
* synchronize the shared pixmap contents with the screen pixmap.
* 2. If the slave driver has it, the master driver can expect the slave
* driver to call the master screen's SyncSharedPixmap hook, so the master
* 2. If the secondary driver has it, the primary driver can expect the secondary
* driver to call the primary screen's SyncSharedPixmap hook, so the primary
* driver doesn't have to synchronize the shared pixmap contents itself,
* e.g. from the BlockHandler.
*
* A driver must only set the hook if it handles both cases correctly.
*
* The argument is the slave screen's pixmap_dirty_list entry, the hook is
* responsible for finding the corresponding entry in the master screen's
* The argument is the secondary screen's pixmap_dirty_list entry, the hook is
* responsible for finding the corresponding entry in the primary screen's
* pixmap_dirty_list.
*/
typedef void (*SyncSharedPixmapProcPtr)(PixmapDirtyUpdatePtr);
@ -634,14 +634,14 @@ typedef struct _Screen {
Bool isGPU;
/* Info on this screen's slaves (if any) */
struct xorg_list slave_list;
struct xorg_list slave_head;
int output_slaves;
/* Info for when this screen is a slave */
ScreenPtr current_master;
Bool is_output_slave;
Bool is_offload_slave;
/* Info on this screen's secondarys (if any) */
struct xorg_list secondary_list;
struct xorg_list secondary_head;
int output_secondarys;
/* Info for when this screen is a secondary */
ScreenPtr current_primary;
Bool is_output_secondary;
Bool is_offload_secondary;
SharePixmapBackingProcPtr SharePixmapBacking;
SetSharedPixmapBackingProcPtr SetSharedPixmapBacking;

112
randr/randr.c
View File

@ -484,7 +484,7 @@ TellChanged(WindowPtr pWin, void *value)
ClientPtr client;
ScreenPtr pScreen = pWin->drawable.pScreen;
ScreenPtr iter;
rrScrPrivPtr pSlaveScrPriv;
rrScrPrivPtr pSecondaryScrPriv;
rrScrPriv(pScreen);
int i;
@ -510,13 +510,13 @@ TellChanged(WindowPtr pWin, void *value)
RRDeliverCrtcEvent(client, pWin, crtc);
}
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
if (!iter->is_output_slave)
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
if (!iter->is_output_secondary)
continue;
pSlaveScrPriv = rrGetScrPriv(iter);
for (i = 0; i < pSlaveScrPriv->numCrtcs; i++) {
RRCrtcPtr crtc = pSlaveScrPriv->crtcs[i];
pSecondaryScrPriv = rrGetScrPriv(iter);
for (i = 0; i < pSecondaryScrPriv->numCrtcs; i++) {
RRCrtcPtr crtc = pSecondaryScrPriv->crtcs[i];
if (crtc->changed)
RRDeliverCrtcEvent(client, pWin, crtc);
@ -532,13 +532,13 @@ TellChanged(WindowPtr pWin, void *value)
RRDeliverOutputEvent(client, pWin, output);
}
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
if (!iter->is_output_slave)
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
if (!iter->is_output_secondary)
continue;
pSlaveScrPriv = rrGetScrPriv(iter);
for (i = 0; i < pSlaveScrPriv->numOutputs; i++) {
RROutputPtr output = pSlaveScrPriv->outputs[i];
pSecondaryScrPriv = rrGetScrPriv(iter);
for (i = 0; i < pSecondaryScrPriv->numOutputs; i++) {
RROutputPtr output = pSecondaryScrPriv->outputs[i];
if (output->changed)
RRDeliverOutputEvent(client, pWin, output);
@ -547,10 +547,10 @@ TellChanged(WindowPtr pWin, void *value)
}
if (pRREvent->mask & RRProviderChangeNotifyMask) {
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
pSlaveScrPriv = rrGetScrPriv(iter);
if (pSlaveScrPriv->provider->changed)
RRDeliverProviderEvent(client, pWin, pSlaveScrPriv->provider);
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
pSecondaryScrPriv = rrGetScrPriv(iter);
if (pSecondaryScrPriv->provider->changed)
RRDeliverProviderEvent(client, pWin, pSecondaryScrPriv->provider);
}
}
@ -572,23 +572,23 @@ TellChanged(WindowPtr pWin, void *value)
void
RRSetChanged(ScreenPtr pScreen)
{
/* set changed bits on the master screen only */
ScreenPtr master;
/* set changed bits on the primary screen only */
ScreenPtr primary;
rrScrPriv(pScreen);
rrScrPrivPtr mastersp;
rrScrPrivPtr primarysp;
if (pScreen->isGPU) {
master = pScreen->current_master;
if (!master)
primary = pScreen->current_primary;
if (!primary)
return;
mastersp = rrGetScrPriv(master);
primarysp = rrGetScrPriv(primary);
}
else {
master = pScreen;
mastersp = pScrPriv;
primary = pScreen;
primarysp = pScrPriv;
}
mastersp->changed = TRUE;
primarysp->changed = TRUE;
}
/*
@ -597,69 +597,69 @@ RRSetChanged(ScreenPtr pScreen)
void
RRTellChanged(ScreenPtr pScreen)
{
ScreenPtr master;
ScreenPtr primary;
rrScrPriv(pScreen);
rrScrPrivPtr mastersp;
rrScrPrivPtr primarysp;
int i;
ScreenPtr iter;
rrScrPrivPtr pSlaveScrPriv;
rrScrPrivPtr pSecondaryScrPriv;
if (pScreen->isGPU) {
master = pScreen->current_master;
if (!master)
primary = pScreen->current_primary;
if (!primary)
return;
mastersp = rrGetScrPriv(master);
primarysp = rrGetScrPriv(primary);
}
else {
master = pScreen;
mastersp = pScrPriv;
primary = pScreen;
primarysp = pScrPriv;
}
xorg_list_for_each_entry(iter, &master->slave_list, slave_head) {
pSlaveScrPriv = rrGetScrPriv(iter);
xorg_list_for_each_entry(iter, &primary->secondary_list, secondary_head) {
pSecondaryScrPriv = rrGetScrPriv(iter);
if (!iter->is_output_slave)
if (!iter->is_output_secondary)
continue;
if (CompareTimeStamps(mastersp->lastSetTime,
pSlaveScrPriv->lastSetTime) == EARLIER) {
mastersp->lastSetTime = pSlaveScrPriv->lastSetTime;
if (CompareTimeStamps(primarysp->lastSetTime,
pSecondaryScrPriv->lastSetTime) == EARLIER) {
primarysp->lastSetTime = pSecondaryScrPriv->lastSetTime;
}
}
if (mastersp->changed) {
if (primarysp->changed) {
UpdateCurrentTimeIf();
if (mastersp->configChanged) {
mastersp->lastConfigTime = currentTime;
mastersp->configChanged = FALSE;
if (primarysp->configChanged) {
primarysp->lastConfigTime = currentTime;
primarysp->configChanged = FALSE;
}
pScrPriv->changed = FALSE;
mastersp->changed = FALSE;
primarysp->changed = FALSE;
WalkTree(master, TellChanged, (void *) master);
WalkTree(primary, TellChanged, (void *) primary);
mastersp->resourcesChanged = FALSE;
primarysp->resourcesChanged = FALSE;
for (i = 0; i < pScrPriv->numOutputs; i++)
pScrPriv->outputs[i]->changed = FALSE;
for (i = 0; i < pScrPriv->numCrtcs; i++)
pScrPriv->crtcs[i]->changed = FALSE;
xorg_list_for_each_entry(iter, &master->slave_list, slave_head) {
pSlaveScrPriv = rrGetScrPriv(iter);
pSlaveScrPriv->provider->changed = FALSE;
if (iter->is_output_slave) {
for (i = 0; i < pSlaveScrPriv->numOutputs; i++)
pSlaveScrPriv->outputs[i]->changed = FALSE;
for (i = 0; i < pSlaveScrPriv->numCrtcs; i++)
pSlaveScrPriv->crtcs[i]->changed = FALSE;
xorg_list_for_each_entry(iter, &primary->secondary_list, secondary_head) {
pSecondaryScrPriv = rrGetScrPriv(iter);
pSecondaryScrPriv->provider->changed = FALSE;
if (iter->is_output_secondary) {
for (i = 0; i < pSecondaryScrPriv->numOutputs; i++)
pSecondaryScrPriv->outputs[i]->changed = FALSE;
for (i = 0; i < pSecondaryScrPriv->numCrtcs; i++)
pSecondaryScrPriv->crtcs[i]->changed = FALSE;
}
}
if (mastersp->layoutChanged) {
if (primarysp->layoutChanged) {
pScrPriv->layoutChanged = FALSE;
RRPointerScreenConfigured(master);
RRSendConfigNotify(master);
RRPointerScreenConfigured(primary);
RRSendConfigNotify(primary);
}
}
}

2
randr/randrstr.h
View File

@ -1043,7 +1043,7 @@ extern _X_EXPORT void
RRDeliverProviderEvent(ClientPtr client, WindowPtr pWin, RRProviderPtr provider);
extern _X_EXPORT void
RRProviderAutoConfigGpuScreen(ScreenPtr pScreen, ScreenPtr masterScreen);
RRProviderAutoConfigGpuScreen(ScreenPtr pScreen, ScreenPtr primaryScreen);
/* rrproviderproperty.c */

132
randr/rrcrtc.c
View File

@ -373,17 +373,17 @@ RRComputeContiguity(ScreenPtr pScreen)
static void
rrDestroySharedPixmap(RRCrtcPtr crtc, PixmapPtr pPixmap) {
ScreenPtr master = crtc->pScreen->current_master;
ScreenPtr primary = crtc->pScreen->current_primary;
if (master && pPixmap->master_pixmap) {
if (primary && pPixmap->primary_pixmap) {
/*
* Unref the pixmap twice: once for the original reference, and once
* for the reference implicitly added by PixmapShareToSlave.
* for the reference implicitly added by PixmapShareToSecondary.
*/
PixmapUnshareSlavePixmap(pPixmap);
PixmapUnshareSecondaryPixmap(pPixmap);
master->DestroyPixmap(pPixmap->master_pixmap);
master->DestroyPixmap(pPixmap->master_pixmap);
primary->DestroyPixmap(pPixmap->primary_pixmap);
primary->DestroyPixmap(pPixmap->primary_pixmap);
}
crtc->pScreen->DestroyPixmap(pPixmap);
@ -395,14 +395,14 @@ RRCrtcDetachScanoutPixmap(RRCrtcPtr crtc)
rrScrPriv(crtc->pScreen);
if (crtc->scanout_pixmap) {
ScreenPtr master = crtc->pScreen->current_master;
DrawablePtr mrootdraw = &master->root->drawable;
ScreenPtr primary = crtc->pScreen->current_primary;
DrawablePtr mrootdraw = &primary->root->drawable;
if (crtc->scanout_pixmap_back) {
pScrPriv->rrDisableSharedPixmapFlipping(crtc);
if (mrootdraw) {
master->StopFlippingPixmapTracking(mrootdraw,
primary->StopFlippingPixmapTracking(mrootdraw,
crtc->scanout_pixmap,
crtc->scanout_pixmap_back);
}
@ -414,7 +414,7 @@ RRCrtcDetachScanoutPixmap(RRCrtcPtr crtc)
pScrPriv->rrCrtcSetScanoutPixmap(crtc, NULL);
if (mrootdraw) {
master->StopPixmapTracking(mrootdraw,
primary->StopPixmapTracking(mrootdraw,
crtc->scanout_pixmap);
}
}
@ -427,20 +427,20 @@ RRCrtcDetachScanoutPixmap(RRCrtcPtr crtc)
}
static PixmapPtr
rrCreateSharedPixmap(RRCrtcPtr crtc, ScreenPtr master,
rrCreateSharedPixmap(RRCrtcPtr crtc, ScreenPtr primary,
int width, int height, int depth,
int x, int y, Rotation rotation)
{
PixmapPtr mpix, spix;
mpix = master->CreatePixmap(master, width, height, depth,
mpix = primary->CreatePixmap(primary, width, height, depth,
CREATE_PIXMAP_USAGE_SHARED);
if (!mpix)
return NULL;
spix = PixmapShareToSlave(mpix, crtc->pScreen);
spix = PixmapShareToSecondary(mpix, crtc->pScreen);
if (spix == NULL) {
master->DestroyPixmap(mpix);
primary->DestroyPixmap(mpix);
return NULL;
}
@ -502,30 +502,30 @@ rrSetupPixmapSharing(RRCrtcPtr crtc, int width, int height,
int x, int y, Rotation rotation, Bool sync,
int numOutputs, RROutputPtr * outputs)
{
ScreenPtr master = crtc->pScreen->current_master;
rrScrPrivPtr pMasterScrPriv = rrGetScrPriv(master);
rrScrPrivPtr pSlaveScrPriv = rrGetScrPriv(crtc->pScreen);
DrawablePtr mrootdraw = &master->root->drawable;
ScreenPtr primary = crtc->pScreen->current_primary;
rrScrPrivPtr pPrimaryScrPriv = rrGetScrPriv(primary);
rrScrPrivPtr pSecondaryScrPriv = rrGetScrPriv(crtc->pScreen);
DrawablePtr mrootdraw = &primary->root->drawable;
int depth = mrootdraw->depth;
PixmapPtr spix_front;
/* Create a pixmap on the master screen, then get a shared handle for it.
Create a shared pixmap on the slave screen using the handle.
/* Create a pixmap on the primary screen, then get a shared handle for it.
Create a shared pixmap on the secondary screen using the handle.
If sync == FALSE --
Set slave screen to scanout shared linear pixmap.
Set the master screen to do dirty updates to the shared pixmap
Set secondary screen to scanout shared linear pixmap.
Set the primary screen to do dirty updates to the shared pixmap
from the screen pixmap on its own accord.
If sync == TRUE --
If any of the below steps fail, clean up and fall back to sync == FALSE.
Create another shared pixmap on the slave screen using the handle.
Set slave screen to prepare for scanout and flipping between shared
Create another shared pixmap on the secondary screen using the handle.
Set secondary screen to prepare for scanout and flipping between shared
linear pixmaps.
Set the master screen to do dirty updates to the shared pixmaps from the
screen pixmap when prompted to by us or the slave.
Prompt the master to do a dirty update on the first shared pixmap, then
defer to the slave.
Set the primary screen to do dirty updates to the shared pixmaps from the
screen pixmap when prompted to by us or the secondary.
Prompt the primary to do a dirty update on the first shared pixmap, then
defer to the secondary.
*/
if (crtc->scanout_pixmap)
@ -535,7 +535,7 @@ rrSetupPixmapSharing(RRCrtcPtr crtc, int width, int height,
return TRUE;
}
spix_front = rrCreateSharedPixmap(crtc, master,
spix_front = rrCreateSharedPixmap(crtc, primary,
width, height, depth,
x, y, rotation);
if (spix_front == NULL) {
@ -545,36 +545,36 @@ rrSetupPixmapSharing(RRCrtcPtr crtc, int width, int height,
/* Both source and sink must support required ABI funcs for flipping */
if (sync &&
pSlaveScrPriv->rrEnableSharedPixmapFlipping &&
pSlaveScrPriv->rrDisableSharedPixmapFlipping &&
pMasterScrPriv->rrStartFlippingPixmapTracking &&
master->PresentSharedPixmap &&
master->StopFlippingPixmapTracking) {
pSecondaryScrPriv->rrEnableSharedPixmapFlipping &&
pSecondaryScrPriv->rrDisableSharedPixmapFlipping &&
pPrimaryScrPriv->rrStartFlippingPixmapTracking &&
primary->PresentSharedPixmap &&
primary->StopFlippingPixmapTracking) {
PixmapPtr spix_back = rrCreateSharedPixmap(crtc, master,
PixmapPtr spix_back = rrCreateSharedPixmap(crtc, primary,
width, height, depth,
x, y, rotation);
if (spix_back == NULL)
goto fail;
if (!pSlaveScrPriv->rrEnableSharedPixmapFlipping(crtc,
if (!pSecondaryScrPriv->rrEnableSharedPixmapFlipping(crtc,
spix_front, spix_back))
goto fail;
crtc->scanout_pixmap = spix_front;
crtc->scanout_pixmap_back = spix_back;
if (!pMasterScrPriv->rrStartFlippingPixmapTracking(crtc,
if (!pPrimaryScrPriv->rrStartFlippingPixmapTracking(crtc,
mrootdraw,
spix_front,
spix_back,
x, y, 0, 0,
rotation)) {
pSlaveScrPriv->rrDisableSharedPixmapFlipping(crtc);
pSecondaryScrPriv->rrDisableSharedPixmapFlipping(crtc);
goto fail;
}
master->PresentSharedPixmap(spix_front);
primary->PresentSharedPixmap(spix_front);
return TRUE;
@ -593,14 +593,14 @@ fail: /* If flipping funcs fail, just fall back to unsynchronized */
rrSetPixmapSharingSyncProp(0, numOutputs, outputs);
}
if (!pSlaveScrPriv->rrCrtcSetScanoutPixmap(crtc, spix_front)) {
if (!pSecondaryScrPriv->rrCrtcSetScanoutPixmap(crtc, spix_front)) {
rrDestroySharedPixmap(crtc, spix_front);
ErrorF("randr: failed to set shadow slave pixmap\n");
ErrorF("randr: failed to set shadow secondary pixmap\n");
return FALSE;
}
crtc->scanout_pixmap = spix_front;
master->StartPixmapTracking(mrootdraw, spix_front, x, y, 0, 0, rotation);
primary->StartPixmapTracking(mrootdraw, spix_front, x, y, 0, 0, rotation);
return TRUE;
}
@ -633,7 +633,7 @@ rrCheckPixmapBounding(ScreenPtr pScreen,
int c;
BoxRec newbox;
BoxPtr newsize;
ScreenPtr slave;
ScreenPtr secondary;
int new_width, new_height;
PixmapPtr screen_pixmap = pScreen->GetScreenPixmap(pScreen);
rrScrPriv(pScreen);
@ -641,8 +641,8 @@ rrCheckPixmapBounding(ScreenPtr pScreen,
PixmapRegionInit(&root_pixmap_region, screen_pixmap);
RegionInit(&total_region, NULL, 0);
/* have to iterate all the crtcs of the attached gpu masters
and all their output slaves */
/* have to iterate all the crtcs of the attached gpu primarys
and all their output secondarys */
for (c = 0; c < pScrPriv->numCrtcs; c++) {
RRCrtcPtr crtc = pScrPriv->crtcs[c];
@ -666,16 +666,16 @@ rrCheckPixmapBounding(ScreenPtr pScreen,
RegionUnion(&total_region, &total_region, &new_crtc_region);
}
xorg_list_for_each_entry(slave, &pScreen->slave_list, slave_head) {
rrScrPrivPtr slave_priv = rrGetScrPriv(slave);
xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
rrScrPrivPtr secondary_priv = rrGetScrPriv(secondary);
if (!slave->is_output_slave)
if (!secondary->is_output_secondary)
continue;
for (c = 0; c < slave_priv->numCrtcs; c++) {
RRCrtcPtr slave_crtc = slave_priv->crtcs[c];
for (c = 0; c < secondary_priv->numCrtcs; c++) {
RRCrtcPtr secondary_crtc = secondary_priv->crtcs[c];
if (slave_crtc == rr_crtc) {
if (secondary_crtc == rr_crtc) {
newbox.x1 = x;
newbox.y1 = y;
if (rotation == RR_Rotate_90 ||
@ -688,9 +688,9 @@ rrCheckPixmapBounding(ScreenPtr pScreen,
}
}
else {
if (!slave_crtc->mode)
if (!secondary_crtc->mode)
continue;
crtc_to_box(&newbox, slave_crtc);
crtc_to_box(&newbox, secondary_crtc);
}
RegionInit(&new_crtc_region, &newbox, 1);
RegionUnion(&total_region, &total_region, &new_crtc_region);
@ -756,19 +756,19 @@ RRCrtcSet(RRCrtcPtr crtc,
}
else {
if (pScreen->isGPU) {
ScreenPtr master = pScreen->current_master;
ScreenPtr primary = pScreen->current_primary;
int width = 0, height = 0;
if (mode) {
width = mode->mode.width;
height = mode->mode.height;
}
ret = rrCheckPixmapBounding(master, crtc,
ret = rrCheckPixmapBounding(primary, crtc,
rotation, x, y, width, height);
if (!ret)
return FALSE;
if (pScreen->current_master) {
if (pScreen->current_primary) {
Bool sync = rrGetPixmapSharingSyncProp(numOutputs, outputs);
ret = rrSetupPixmapSharing(crtc, width, height,
x, y, rotation, sync,
@ -1384,8 +1384,8 @@ ProcRRSetCrtcConfig(ClientPtr client)
int width, height;
if (pScreen->isGPU) {
width = pScreen->current_master->width;
height = pScreen->current_master->height;
width = pScreen->current_primary->width;
height = pScreen->current_primary->height;
}
else {
width = pScreen->width;
@ -1887,7 +1887,7 @@ RRConstrainCursorHarder(DeviceIntPtr pDev, ScreenPtr pScreen, int mode, int *x,
{
rrScrPriv(pScreen);
Bool ret;
ScreenPtr slave;
ScreenPtr secondary;
/* intentional dead space -> let it float */
if (pScrPriv->discontiguous)
@ -1898,11 +1898,11 @@ RRConstrainCursorHarder(DeviceIntPtr pDev, ScreenPtr pScreen, int mode, int *x,
if (ret == TRUE)
return;
xorg_list_for_each_entry(slave, &pScreen->slave_list, slave_head) {
if (!slave->is_output_slave)
xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
if (!secondary->is_output_secondary)
continue;
ret = check_all_screen_crtcs(slave, x, y);
ret = check_all_screen_crtcs(secondary, x, y);
if (ret == TRUE)
return;
}
@ -1912,11 +1912,11 @@ RRConstrainCursorHarder(DeviceIntPtr pDev, ScreenPtr pScreen, int mode, int *x,
if (ret == TRUE)
return;
xorg_list_for_each_entry(slave, &pScreen->slave_list, slave_head) {
if (!slave->is_output_slave)
xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
if (!secondary->is_output_secondary)
continue;
ret = constrain_all_screen_crtcs(pDev, slave, x, y);
ret = constrain_all_screen_crtcs(pDev, secondary, x, y);
if (ret == TRUE)
return;
}
@ -2015,7 +2015,7 @@ RRHasScanoutPixmap(ScreenPtr pScreen)
rrScrPriv(pScreen);
int i;
if (!pScreen->is_output_slave)
if (!pScreen->is_output_secondary)
return FALSE;
for (i = 0; i < pScrPriv->numCrtcs; i++) {

36
randr/rrmonitor.c
View File

@ -195,21 +195,21 @@ RRMonitorInitList(ScreenPtr screen, RRMonitorListPtr mon_list, Bool get_active)
rrScrPrivPtr pScrPriv = rrGetScrPriv(screen);
int m, o, c, sc;
int numCrtcs;
ScreenPtr slave;
ScreenPtr secondary;
if (!RRGetInfo(screen, FALSE))
return FALSE;
/* Count the number of crtcs in this and any slave screens */
/* Count the number of crtcs in this and any secondary screens */
numCrtcs = pScrPriv->numCrtcs;
xorg_list_for_each_entry(slave, &screen->slave_list, slave_head) {
rrScrPrivPtr pSlavePriv;
xorg_list_for_each_entry(secondary, &screen->secondary_list, secondary_head) {
rrScrPrivPtr pSecondaryPriv;
if (!slave->is_output_slave)
if (!secondary->is_output_secondary)
continue;
pSlavePriv = rrGetScrPriv(slave);
numCrtcs += pSlavePriv->numCrtcs;
pSecondaryPriv = rrGetScrPriv(secondary);
numCrtcs += pSecondaryPriv->numCrtcs;
}
mon_list->num_crtcs = numCrtcs;
@ -224,16 +224,16 @@ RRMonitorInitList(ScreenPtr screen, RRMonitorListPtr mon_list, Bool get_active)
mon_list->server_crtc[c] = pScrPriv->crtcs[sc];
}
xorg_list_for_each_entry(slave, &screen->slave_list, slave_head) {
rrScrPrivPtr pSlavePriv;
xorg_list_for_each_entry(secondary, &screen->secondary_list, secondary_head) {
rrScrPrivPtr pSecondaryPriv;
if (!slave->is_output_slave)
if (!secondary->is_output_secondary)
continue;
pSlavePriv = rrGetScrPriv(slave);
for (sc = 0; sc < pSlavePriv->numCrtcs; sc++, c++) {
if (pSlavePriv->crtcs[sc]->mode != NULL)
mon_list->server_crtc[c] = pSlavePriv->crtcs[sc];
pSecondaryPriv = rrGetScrPriv(secondary);
for (sc = 0; sc < pSecondaryPriv->numCrtcs; sc++, c++) {
if (pSecondaryPriv->crtcs[sc]->mode != NULL)
mon_list->server_crtc[c] = pSecondaryPriv->crtcs[sc];
}
}
@ -464,7 +464,7 @@ RRMonitorAdd(ClientPtr client, ScreenPtr screen, RRMonitorPtr monitor)
{
rrScrPrivPtr pScrPriv = rrGetScrPriv(screen);
int m;
ScreenPtr slave;
ScreenPtr secondary;
RRMonitorPtr *monitors;
if (!pScrPriv)
@ -479,11 +479,11 @@ RRMonitorAdd(ClientPtr client, ScreenPtr screen, RRMonitorPtr monitor)
return BadValue;
}
xorg_list_for_each_entry(slave, &screen->slave_list, slave_head) {
if (!slave->is_output_slave)
xorg_list_for_each_entry(secondary, &screen->secondary_list, secondary_head) {
if (!secondary->is_output_secondary)
continue;
if (RRMonitorMatchesOutputName(slave, monitor->name)) {
if (RRMonitorMatchesOutputName(secondary, monitor->name)) {
client->errorValue = monitor->name;
return BadValue;
}

28
randr/rroutput.c
View File

@ -32,27 +32,27 @@ RESTYPE RROutputType;
void
RROutputChanged(RROutputPtr output, Bool configChanged)
{
/* set changed bits on the master screen only */
/* set changed bits on the primary screen only */
ScreenPtr pScreen = output->pScreen;
rrScrPrivPtr mastersp;
rrScrPrivPtr primarysp;
output->changed = TRUE;
if (!pScreen)
return;
if (pScreen->isGPU) {
ScreenPtr master = pScreen->current_master;
if (!master)
ScreenPtr primary = pScreen->current_primary;
if (!primary)
return;
mastersp = rrGetScrPriv(master);
primarysp = rrGetScrPriv(primary);
}
else {
mastersp = rrGetScrPriv(pScreen);
primarysp = rrGetScrPriv(pScreen);
}
RRSetChanged(pScreen);
if (configChanged)
mastersp->configChanged = TRUE;
primarysp->configChanged = TRUE;
}
/*
@ -609,7 +609,7 @@ ProcRRSetOutputPrimary(ClientPtr client)
WindowPtr pWin;
rrScrPrivPtr pScrPriv;
int ret;
ScreenPtr slave;
ScreenPtr secondary;
REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
@ -627,7 +627,7 @@ ProcRRSetOutputPrimary(ClientPtr client)
client->errorValue = stuff->window;
return BadMatch;
}
if (output->pScreen->isGPU && output->pScreen->current_master != pWin->drawable.pScreen) {
if (output->pScreen->isGPU && output->pScreen->current_primary != pWin->drawable.pScreen) {
client->errorValue = stuff->window;
return BadMatch;
}
@ -638,11 +638,11 @@ ProcRRSetOutputPrimary(ClientPtr client)
{
RRSetPrimaryOutput(pWin->drawable.pScreen, pScrPriv, output);
xorg_list_for_each_entry(slave,
&pWin->drawable.pScreen->slave_list,
slave_head) {
if (slave->is_output_slave)
RRSetPrimaryOutput(slave, rrGetScrPriv(slave), output);
xorg_list_for_each_entry(secondary,
&pWin->drawable.pScreen->secondary_list,
secondary_head) {
if (secondary->is_output_secondary)
RRSetPrimaryOutput(secondary, rrGetScrPriv(secondary), output);
}
}

36
randr/rrprovider.c
View File

@ -75,7 +75,7 @@ ProcRRGetProviders (ClientPtr client)
if (pScrPriv->provider)
total_providers++;
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
pScrPriv = rrGetScrPriv(iter);
total_providers += pScrPriv->provider ? 1 : 0;
}
@ -111,7 +111,7 @@ ProcRRGetProviders (ClientPtr client)
providers = (RRProvider *)extra;
ADD_PROVIDER(pScreen);
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
ADD_PROVIDER(iter);
}
}
@ -174,8 +174,8 @@ ProcRRGetProviderInfo (ClientPtr client)
if (provider->output_source &&
provider->output_source != provider->offload_sink)
rep.nAssociatedProviders++;
xorg_list_for_each_entry(provscreen, &pScreen->slave_list, slave_head) {
if (provscreen->is_output_slave || provscreen->is_offload_slave)
xorg_list_for_each_entry(provscreen, &pScreen->secondary_list, secondary_head) {
if (provscreen->is_output_secondary || provscreen->is_offload_secondary)
rep.nAssociatedProviders++;
}
@ -227,17 +227,17 @@ ProcRRGetProviderInfo (ClientPtr client)
swapl(&prov_cap[i]);
i++;
}
xorg_list_for_each_entry(provscreen, &pScreen->slave_list, slave_head) {
if (!provscreen->is_output_slave && !provscreen->is_offload_slave)
xorg_list_for_each_entry(provscreen, &pScreen->secondary_list, secondary_head) {
if (!provscreen->is_output_secondary && !provscreen->is_offload_secondary)
continue;
pScrProvPriv = rrGetScrPriv(provscreen);
providers[i] = pScrProvPriv->provider->id;
if (client->swapped)
swapl(&providers[i]);
prov_cap[i] = 0;
if (provscreen->is_output_slave)
if (provscreen->is_output_secondary)
prov_cap[i] |= RR_Capability_SinkOutput;
if (provscreen->is_offload_slave)
if (provscreen->is_offload_secondary)
prov_cap[i] |= RR_Capability_SourceOffload;
if (client->swapped)
swapl(&prov_cap[i]);
@ -488,26 +488,26 @@ RRDeliverProviderEvent(ClientPtr client, WindowPtr pWin, RRProviderPtr provider)
}
void
RRProviderAutoConfigGpuScreen(ScreenPtr pScreen, ScreenPtr masterScreen)
RRProviderAutoConfigGpuScreen(ScreenPtr pScreen, ScreenPtr primaryScreen)
{
rrScrPrivPtr pScrPriv = rrGetScrPriv(pScreen);
rrScrPrivPtr masterPriv = rrGetScrPriv(masterScreen);
rrScrPrivPtr primaryPriv = rrGetScrPriv(primaryScreen);
RRProviderPtr provider = pScrPriv->provider;
RRProviderPtr master_provider = masterPriv->provider;
RRProviderPtr primary_provider = primaryPriv->provider;
if (!provider || !master_provider)
if (!provider || !primary_provider)
return;
if ((provider->capabilities & RR_Capability_SinkOutput) &&
(master_provider->capabilities & RR_Capability_SourceOutput)) {
pScrPriv->rrProviderSetOutputSource(pScreen, provider, master_provider);
(primary_provider->capabilities & RR_Capability_SourceOutput)) {
pScrPriv->rrProviderSetOutputSource(pScreen, provider, primary_provider);
RRInitPrimeSyncProps(pScreen);
masterPriv->configChanged = TRUE;
RRSetChanged(masterScreen);
primaryPriv->configChanged = TRUE;
RRSetChanged(primaryScreen);
}
if ((provider->capabilities & RR_Capability_SourceOffload) &&
(master_provider->capabilities & RR_Capability_SinkOffload))
pScrPriv->rrProviderSetOffloadSink(pScreen, provider, master_provider);
(primary_provider->capabilities & RR_Capability_SinkOffload))
pScrPriv->rrProviderSetOffloadSink(pScreen, provider, primary_provider);
}

12
randr/rrscreen.c
View File

@ -380,7 +380,7 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
CARD8 *names;
int has_primary = 0;
/* we need to iterate all the GPU masters and all their output slaves */
/* we need to iterate all the GPU primarys and all their output secondarys */
total_crtcs = 0;
total_outputs = 0;
total_modes = 0;
@ -394,8 +394,8 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
update_totals(pScreen, pScrPriv);
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
if (!iter->is_output_slave)
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
if (!iter->is_output_secondary)
continue;
pScrPriv = rrGetScrPriv(iter);
@ -453,8 +453,8 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
}
update_arrays(pScreen, pScrPriv, primary_crtc, has_primary);
xorg_list_for_each_entry(iter, &pScreen->slave_list, slave_head) {
if (!iter->is_output_slave)
xorg_list_for_each_entry(iter, &pScreen->secondary_list, secondary_head) {
if (!iter->is_output_secondary)
continue;
pScrPriv = rrGetScrPriv(iter);
@ -509,7 +509,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
if (!RRGetInfo(pScreen, query))
return BadAlloc;
if (pScreen->output_slaves)
if (pScreen->output_secondarys)
return rrGetMultiScreenResources(client, query, pScreen);
if (!pScrPriv) {