Commit ea47af87 authored by Dave Airlie's avatar Dave Airlie
Browse files

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



This is an API and ABI break
Reviewed-by: Peter Hutterer's avatarPeter Hutterer <peter.hutterer@who-t.net>
parent 15b77383
......@@ -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;
}
......@@ -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;
......
......@@ -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 =
......
......@@ -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;
......
......@@ -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);
}
......
......@@ -1089,9 +1089,9 @@ static Bool
drmmode_SharedPixmapPresent(PixmapPtr ppix, xf86CrtcPtr crtc,
drmmode_ptr drmmode)
{