Attachment #648982 for bug #732298

Lines 41-47 Link Here

(-)a/src/amdgpu_dri3.c (-2 / +2 lines)
41	#include <errno.h>	41	#include <errno.h>
42	#include <libgen.h>	42	#include <libgen.h>
43		43
44	static int open_master_node(ScreenPtr screen, int *out)	44	static int open_primary_node(ScreenPtr screen, int *out)
45	{	45	{
46	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);	46	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
47	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);	47	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);
Lines 112-118 Link Here
112	ret = open_render_node(screen, out);	112	ret = open_render_node(screen, out);
113		113
114	if (ret != Success)	114	if (ret != Success)
115	ret = open_master_node(screen, out);	115	ret = open_primary_node(screen, out);
116		116
117	return ret;	117	return ret;
118	}	118	}




} AMDGPUOpts;

static inline ScreenPtr
amdgpu_primary_screen(ScreenPtr screen)
{
	if (screen->current_primary)
		return screen->current_primary;

	return screen;
}

static inline ScreenPtr
amdgpu_dirty_primary(PixmapDirtyUpdatePtr dirty)
{
	return amdgpu_primary_screen(dirty->secondary_dst->drawable.pScreen);
}

static inline DrawablePtr

Lines 349-355 Link Here

(-)a/src/amdgpu_glamor.c (-1 / +1 lines)
349		349
350		350
351	static Bool	351	static Bool
352	amdgpu_glamor_share_pixmap_backing(PixmapPtr pixmap, ScreenPtr slave,	352	amdgpu_glamor_share_pixmap_backing(PixmapPtr pixmap, ScreenPtr secondary,
353	void **handle_p)	353	void **handle_p)
354	{	354	{
355	ScreenPtr screen = pixmap->drawable.pScreen;	355	ScreenPtr screen = pixmap->drawable.pScreen;




	if (dirty->rotation != RR_Rotate_0) {
		dstregion = transform_region(damageregion,
					     &dirty->f_inverse,
					     dirty->secondary_dst->drawable.width,
					     dirty->secondary_dst->drawable.height);
	} else
#endif
	{


		dstregion = RegionDuplicate(damageregion);
		RegionTranslate(dstregion, -dirty->x, -dirty->y);
		PixmapRegionInit(&pixregion, dirty->secondary_dst);
		RegionIntersect(dstregion, dstregion, &pixregion);
		RegionUninit(&pixregion);
	}

	if (RegionNil(region))
		goto out;

	if (dirty->secondary_dst->primary_pixmap)
		DamageRegionAppend(&dirty->secondary_dst->drawable, region);

#ifdef HAS_DIRTYTRACKING_ROTATION
	PixmapSyncDirtyHelper(dirty);

#endif

	amdgpu_glamor_flush(src_scrn);
	if (dirty->secondary_dst->primary_pixmap)
		DamageRegionProcessPending(&dirty->secondary_dst->drawable);

out:
	DamageEmpty(dirty->damage);

void
amdgpu_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);
	PixmapDirtyUpdatePtr ent;
	RegionPtr region;

	xorg_list_for_each_entry(ent, &primary_screen->pixmap_dirty_list, ent) {
		if (!amdgpu_dirty_src_equals(dirty, ent->secondary_dst))
			continue;

		region = dirty_region(ent);

#if HAS_SYNC_SHARED_PIXMAP

static Bool
primary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);

	return primary_screen->SyncSharedPixmap != NULL;
}

static Bool
secondary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr secondary_screen = dirty->secondary_dst->drawable.pScreen;

	return secondary_screen->SyncSharedPixmap != NULL;
}

static void
call_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);

	primary_screen->SyncSharedPixmap(dirty);
}

#else /* !HAS_SYNC_SHARED_PIXMAP */

static Bool
primary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
{
	ScrnInfoPtr primary_scrn = xf86ScreenToScrn(amdgpu_dirty_primary(dirty));

	return primary_scrn->driverName == scrn->driverName;
}

static Bool
secondary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
{
	ScrnInfoPtr secondary_scrn = xf86ScreenToScrn(dirty->secondary_dst->drawable.pScreen);

	return secondary_scrn->driverName == scrn->driverName;
}

static void

static xf86CrtcPtr
amdgpu_prime_dirty_to_crtc(PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr screen = dirty->secondary_dst->drawable.pScreen;
	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
	int c;

	/* Find the CRTC which is scanning out from this secondary pixmap */
	for (c = 0; c < xf86_config->num_crtc; c++) {
		xf86CrtcPtr xf86_crtc = xf86_config->crtc[c];
		drmmode_crtc_private_ptr drmmode_crtc = xf86_crtc->driver_private;

		if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {
			RegionPtr region;

			if (primary_has_sync_shared_pixmap(scrn, dirty))
				call_sync_shared_pixmap(dirty);

			region = dirty_region(dirty);

				amdgpu_glamor_flush(scrn);
				RegionCopy(&drmmode_crtc->scanout_last_region, region);
				RegionTranslate(region, -crtc->x, -crtc->y);
				dirty->secondary_dst = drmmode_crtc->scanout[scanout_id];
			}

			redisplay_dirty(dirty, region);

static void
amdgpu_prime_scanout_update(PixmapDirtyUpdatePtr dirty)
{
	ScreenPtr screen = dirty->secondary_dst->drawable.pScreen;
	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);
	xf86CrtcPtr xf86_crtc = amdgpu_prime_dirty_to_crtc(dirty);

static void
amdgpu_prime_scanout_flip(PixmapDirtyUpdatePtr ent)
{
	ScreenPtr screen = ent->secondary_dst->drawable.pScreen;
	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);
	xf86CrtcPtr crtc = amdgpu_prime_dirty_to_crtc(ent);

		if (screen->isGPU) {
			PixmapDirtyUpdatePtr region_ent = ent;

			if (primary_has_sync_shared_pixmap(scrn, ent)) {
				ScreenPtr primary_screen = amdgpu_dirty_primary(ent);

				xorg_list_for_each_entry(region_ent, &primary_screen->pixmap_dirty_list, ent) {
					if (amdgpu_dirty_src_equals(ent, region_ent->secondary_dst))
						break;
				}
			}


			RegionDestroy(region);
		} else {
			if (secondary_has_sync_shared_pixmap(scrn, ent))
				continue;

			region = dirty_region(ent);

	(*pScreen->BlockHandler) (BLOCKHANDLER_ARGS);
	pScreen->BlockHandler = AMDGPUBlockHandler_KMS;

	if (!xf86ScreenToScrn(amdgpu_primary_screen(pScreen))->vtSema)
		return;

	if (!pScreen->isGPU)

	}
}

static Bool amdgpu_set_drm_primary(ScrnInfoPtr pScrn)
{
	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);
	int err;


	err = drmSetMaster(pAMDGPUEnt->fd);
	if (err)
		ErrorF("Unable to retrieve primary\n");

	return err == 0;
}

static void amdgpu_drop_drm_primary(ScrnInfoPtr pScrn)
{
	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);


	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
	int c;

	if (xf86ScreenToScrn(amdgpu_primary_screen(screen))->vtSema)
		return 0;

	/* Unreference the all-black FB created by AMDGPULeaveVT_KMS. After

	}

	amdgpu_sync_close(pScreen);
	amdgpu_drop_drm_primary(pScrn);

	drmmode_fini(pScrn, &info->drmmode);
	if (info->dri2.enabled) {

		return FALSE;
	miSetPixmapDepths();

	if (!amdgpu_set_drm_primary(pScrn))
		return FALSE;

	info->directRenderingEnabled = FALSE;

	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,
		       "AMDGPUEnterVT_KMS\n");

	amdgpu_set_drm_primary(pScrn);

	if (info->shadow_fb) {
		int pitch;

		if (!front_buffer) {
			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
				   "Failed to allocate new scanout BO after VT switch, "
				   "other DRM primarys may see screen contents\n");
		}
	}


 hide_cursors:
	xf86_hide_cursors(pScrn);

	amdgpu_drop_drm_primary(pScrn);

	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,
		       "Ok, leaving now...\n");




	return drmAuthMagic(fd, 0) != -EACCES;
}

static Bool amdgpu_open_drm_primary(ScrnInfoPtr pScrn,
				   struct pci_device *pci_dev,
				   struct xf86_platform_device *platform_dev,
				   AMDGPUEntPtr pAMDGPUEnt)

	if (pAMDGPUEnt->fd == -1)
		return FALSE;

	/* Check that what we opened is a primary or a primary-capable FD */
	if (!local_drmIsMaster(pAMDGPUEnt->fd)) {
		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
			   "[drm] device is not DRM primary.\n");
		amdgpu_kernel_close_fd(pAMDGPUEnt);
		return FALSE;
	}

	uint32_t minor_version;

	pAMDGPUEnt->platform_dev = platform_dev;
	if (!amdgpu_open_drm_primary(pScrn, pci_dev, platform_dev,
				    pAMDGPUEnt))
		return FALSE;


Lines 658-664 Link Here

(-)a/src/drmmode_display.c (-2 / +2 lines)
658	xorg_list_for_each_entry(dirty, &screen->pixmap_dirty_list,	658	xorg_list_for_each_entry(dirty, &screen->pixmap_dirty_list,
659	ent) {	659	ent) {
660	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {	660	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {
661	dirty->slave_dst =	661	dirty->secondary_dst =
662	drmmode_crtc->scanout[scanout_id];	662	drmmode_crtc->scanout[scanout_id];
663	break;	663	break;
664	}	664	}
Lines 1790-1796 Link Here
1790		1790
1791	xorg_list_for_each_entry(dirty, &screen->pixmap_dirty_list, ent) {	1791	xorg_list_for_each_entry(dirty, &screen->pixmap_dirty_list, ent) {
1792	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {	1792	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {
1793	PixmapStopDirtyTracking(dirty->src, dirty->slave_dst);	1793	PixmapStopDirtyTracking(dirty->src, dirty->secondary_dst);
1794	break;	1794	break;
1795	}	1795	}
1796	}	1796	}

Return to bug 732298

Lines 168-185 Link Here

(-)a/src/amdgpu_drv.h (-5 / +5 lines)
168	} AMDGPUOpts;	168	} AMDGPUOpts;
169		169
170	static inline ScreenPtr	170	static inline ScreenPtr
171	amdgpu_master_screen(ScreenPtr screen)	171	amdgpu_primary_screen(ScreenPtr screen)
172	{	172	{
173	if (screen->current_master)	173	if (screen->current_primary)
174	return screen->current_master;	174	return screen->current_primary;
175		175
176	return screen;	176	return screen;
177	}	177	}
178		178
179	static inline ScreenPtr	179	static inline ScreenPtr
180	amdgpu_dirty_master(PixmapDirtyUpdatePtr dirty)	180	amdgpu_dirty_primary(PixmapDirtyUpdatePtr dirty)
181	{	181	{
182	return amdgpu_master_screen(dirty->slave_dst->drawable.pScreen);	182	return amdgpu_primary_screen(dirty->secondary_dst->drawable.pScreen);
183	}	183	}
184		184
185	static inline DrawablePtr	185	static inline DrawablePtr

Lines 192-198 Link Here

(-)a/src/amdgpu_probe.c (-4 / +4 lines)
192	return drmAuthMagic(fd, 0) != -EACCES;	192	return drmAuthMagic(fd, 0) != -EACCES;
193	}	193	}
194		194
195	static Bool amdgpu_open_drm_master(ScrnInfoPtr pScrn,	195	static Bool amdgpu_open_drm_primary(ScrnInfoPtr pScrn,
196	struct pci_device *pci_dev,	196	struct pci_device *pci_dev,
197	struct xf86_platform_device *platform_dev,	197	struct xf86_platform_device *platform_dev,
198	AMDGPUEntPtr pAMDGPUEnt)	198	AMDGPUEntPtr pAMDGPUEnt)
Lines 201-210 Link Here
201	if (pAMDGPUEnt->fd == -1)	201	if (pAMDGPUEnt->fd == -1)
202	return FALSE;	202	return FALSE;
203		203
204	/* Check that what we opened is a master or a master-capable FD */	204	/* Check that what we opened is a primary or a primary-capable FD */
205	if (!local_drmIsMaster(pAMDGPUEnt->fd)) {	205	if (!local_drmIsMaster(pAMDGPUEnt->fd)) {
206	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,	206	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
207	"[drm] device is not DRM master.\n");	207	"[drm] device is not DRM primary.\n");
208	amdgpu_kernel_close_fd(pAMDGPUEnt);	208	amdgpu_kernel_close_fd(pAMDGPUEnt);
209	return FALSE;	209	return FALSE;
210	}	210	}
Lines 221-227 Link Here
221	uint32_t minor_version;	221	uint32_t minor_version;
222		222
223	pAMDGPUEnt->platform_dev = platform_dev;	223	pAMDGPUEnt->platform_dev = platform_dev;
224	if (!amdgpu_open_drm_master(pScrn, pci_dev, platform_dev,	224	if (!amdgpu_open_drm_primary(pScrn, pci_dev, platform_dev,
225	pAMDGPUEnt))	225	pAMDGPUEnt))
226	return FALSE;	226	return FALSE;
227		227

Lines 604-611 Link Here

(-)a/src/amdgpu_kms.c (-45 / +45 lines)
604	if (dirty->rotation != RR_Rotate_0) {	604	if (dirty->rotation != RR_Rotate_0) {
605	dstregion = transform_region(damageregion,	605	dstregion = transform_region(damageregion,
606	&dirty->f_inverse,	606	&dirty->f_inverse,
607	dirty->slave_dst->drawable.width,	607	dirty->secondary_dst->drawable.width,
608	dirty->slave_dst->drawable.height);	608	dirty->secondary_dst->drawable.height);
609	} else	609	} else
610	#endif	610	#endif
611	{	611	{
Lines 613-619 Link Here
613		613
614	dstregion = RegionDuplicate(damageregion);	614	dstregion = RegionDuplicate(damageregion);
615	RegionTranslate(dstregion, -dirty->x, -dirty->y);	615	RegionTranslate(dstregion, -dirty->x, -dirty->y);
616	PixmapRegionInit(&pixregion, dirty->slave_dst);	616	PixmapRegionInit(&pixregion, dirty->secondary_dst);
617	RegionIntersect(dstregion, dstregion, &pixregion);	617	RegionIntersect(dstregion, dstregion, &pixregion);
618	RegionUninit(&pixregion);	618	RegionUninit(&pixregion);
619	}	619	}
Lines 630-637 Link Here
630	if (RegionNil(region))	630	if (RegionNil(region))
631	goto out;	631	goto out;
632		632
633	if (dirty->slave_dst->master_pixmap)	633	if (dirty->secondary_dst->primary_pixmap)
634	DamageRegionAppend(&dirty->slave_dst->drawable, region);	634	DamageRegionAppend(&dirty->secondary_dst->drawable, region);
635		635
636	#ifdef HAS_DIRTYTRACKING_ROTATION	636	#ifdef HAS_DIRTYTRACKING_ROTATION
637	PixmapSyncDirtyHelper(dirty);	637	PixmapSyncDirtyHelper(dirty);
Lines 640-647 Link Here
640	#endif	640	#endif
641		641
642	amdgpu_glamor_flush(src_scrn);	642	amdgpu_glamor_flush(src_scrn);
643	if (dirty->slave_dst->master_pixmap)	643	if (dirty->secondary_dst->primary_pixmap)
644	DamageRegionProcessPending(&dirty->slave_dst->drawable);	644	DamageRegionProcessPending(&dirty->secondary_dst->drawable);
645		645
646	out:	646	out:
647	DamageEmpty(dirty->damage);	647	DamageEmpty(dirty->damage);
Lines 658-669 Link Here
658	void	658	void
659	amdgpu_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)	659	amdgpu_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)
660	{	660	{
661	ScreenPtr master_screen = amdgpu_dirty_master(dirty);	661	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);
662	PixmapDirtyUpdatePtr ent;	662	PixmapDirtyUpdatePtr ent;
663	RegionPtr region;	663	RegionPtr region;
664		664
665	xorg_list_for_each_entry(ent, &master_screen->pixmap_dirty_list, ent) {	665	xorg_list_for_each_entry(ent, &primary_screen->pixmap_dirty_list, ent) {
666	if (!amdgpu_dirty_src_equals(dirty, ent->slave_dst))	666	if (!amdgpu_dirty_src_equals(dirty, ent->secondary_dst))
667	continue;	667	continue;
668		668
669	region = dirty_region(ent);	669	region = dirty_region(ent);
Lines 676-720 Link Here
676	#if HAS_SYNC_SHARED_PIXMAP	676	#if HAS_SYNC_SHARED_PIXMAP
677		677
678	static Bool	678	static Bool
679	master_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)	679	primary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
680	{	680	{
681	ScreenPtr master_screen = amdgpu_dirty_master(dirty);	681	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);
682		682
683	return master_screen->SyncSharedPixmap != NULL;	683	return primary_screen->SyncSharedPixmap != NULL;
684	}	684	}
685		685
686	static Bool	686	static Bool
687	slave_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)	687	secondary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
688	{	688	{
689	ScreenPtr slave_screen = dirty->slave_dst->drawable.pScreen;	689	ScreenPtr secondary_screen = dirty->secondary_dst->drawable.pScreen;
690		690
691	return slave_screen->SyncSharedPixmap != NULL;	691	return secondary_screen->SyncSharedPixmap != NULL;
692	}	692	}
693		693
694	static void	694	static void
695	call_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)	695	call_sync_shared_pixmap(PixmapDirtyUpdatePtr dirty)
696	{	696	{
697	ScreenPtr master_screen = amdgpu_dirty_master(dirty);	697	ScreenPtr primary_screen = amdgpu_dirty_primary(dirty);
698		698
699	master_screen->SyncSharedPixmap(dirty);	699	primary_screen->SyncSharedPixmap(dirty);
700	}	700	}
701		701
702	#else /* !HAS_SYNC_SHARED_PIXMAP */	702	#else /* !HAS_SYNC_SHARED_PIXMAP */
703		703
704	static Bool	704	static Bool
705	master_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)	705	primary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
706	{	706	{
707	ScrnInfoPtr master_scrn = xf86ScreenToScrn(amdgpu_dirty_master(dirty));	707	ScrnInfoPtr primary_scrn = xf86ScreenToScrn(amdgpu_dirty_primary(dirty));
708		708
709	return master_scrn->driverName == scrn->driverName;	709	return primary_scrn->driverName == scrn->driverName;
710	}	710	}
711		711
712	static Bool	712	static Bool
713	slave_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)	713	secondary_has_sync_shared_pixmap(ScrnInfoPtr scrn, PixmapDirtyUpdatePtr dirty)
714	{	714	{
715	ScrnInfoPtr slave_scrn = xf86ScreenToScrn(dirty->slave_dst->drawable.pScreen);	715	ScrnInfoPtr secondary_scrn = xf86ScreenToScrn(dirty->secondary_dst->drawable.pScreen);
716		716
717	return slave_scrn->driverName == scrn->driverName;	717	return secondary_scrn->driverName == scrn->driverName;
718	}	718	}
719		719
720	static void	720	static void
Lines 729-740 Link Here
729	static xf86CrtcPtr	729	static xf86CrtcPtr
730	amdgpu_prime_dirty_to_crtc(PixmapDirtyUpdatePtr dirty)	730	amdgpu_prime_dirty_to_crtc(PixmapDirtyUpdatePtr dirty)
731	{	731	{
732	ScreenPtr screen = dirty->slave_dst->drawable.pScreen;	732	ScreenPtr screen = dirty->secondary_dst->drawable.pScreen;
733	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);	733	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
734	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);	734	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
735	int c;	735	int c;
736		736
737	/* Find the CRTC which is scanning out from this slave pixmap */	737	/* Find the CRTC which is scanning out from this secondary pixmap */
738	for (c = 0; c < xf86_config->num_crtc; c++) {	738	for (c = 0; c < xf86_config->num_crtc; c++) {
739	xf86CrtcPtr xf86_crtc = xf86_config->crtc[c];	739	xf86CrtcPtr xf86_crtc = xf86_config->crtc[c];
740	drmmode_crtc_private_ptr drmmode_crtc = xf86_crtc->driver_private;	740	drmmode_crtc_private_ptr drmmode_crtc = xf86_crtc->driver_private;
Lines 759-765 Link Here
759	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {	759	if (amdgpu_dirty_src_equals(dirty, drmmode_crtc->prime_scanout_pixmap)) {
760	RegionPtr region;	760	RegionPtr region;
761		761
762	if (master_has_sync_shared_pixmap(scrn, dirty))	762	if (primary_has_sync_shared_pixmap(scrn, dirty))
763	call_sync_shared_pixmap(dirty);	763	call_sync_shared_pixmap(dirty);
764		764
765	region = dirty_region(dirty);	765	region = dirty_region(dirty);
Lines 772-778 Link Here
772	amdgpu_glamor_flush(scrn);	772	amdgpu_glamor_flush(scrn);
773	RegionCopy(&drmmode_crtc->scanout_last_region, region);	773	RegionCopy(&drmmode_crtc->scanout_last_region, region);
774	RegionTranslate(region, -crtc->x, -crtc->y);	774	RegionTranslate(region, -crtc->x, -crtc->y);
775	dirty->slave_dst = drmmode_crtc->scanout[scanout_id];	775	dirty->secondary_dst = drmmode_crtc->scanout[scanout_id];
776	}	776	}
777		777
778	redisplay_dirty(dirty, region);	778	redisplay_dirty(dirty, region);
Lines 799-805 Link Here
799	static void	799	static void
800	amdgpu_prime_scanout_update(PixmapDirtyUpdatePtr dirty)	800	amdgpu_prime_scanout_update(PixmapDirtyUpdatePtr dirty)
801	{	801	{
802	ScreenPtr screen = dirty->slave_dst->drawable.pScreen;	802	ScreenPtr screen = dirty->secondary_dst->drawable.pScreen;
803	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);	803	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
804	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);	804	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);
805	xf86CrtcPtr xf86_crtc = amdgpu_prime_dirty_to_crtc(dirty);	805	xf86CrtcPtr xf86_crtc = amdgpu_prime_dirty_to_crtc(dirty);
Lines 863-869 Link Here
863	static void	863	static void
864	amdgpu_prime_scanout_flip(PixmapDirtyUpdatePtr ent)	864	amdgpu_prime_scanout_flip(PixmapDirtyUpdatePtr ent)
865	{	865	{
866	ScreenPtr screen = ent->slave_dst->drawable.pScreen;	866	ScreenPtr screen = ent->secondary_dst->drawable.pScreen;
867	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);	867	ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
868	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);	868	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(scrn);
869	xf86CrtcPtr crtc = amdgpu_prime_dirty_to_crtc(ent);	869	xf86CrtcPtr crtc = amdgpu_prime_dirty_to_crtc(ent);
Lines 938-948 Link Here
938	if (screen->isGPU) {	938	if (screen->isGPU) {
939	PixmapDirtyUpdatePtr region_ent = ent;	939	PixmapDirtyUpdatePtr region_ent = ent;
940		940
941	if (master_has_sync_shared_pixmap(scrn, ent)) {	941	if (primary_has_sync_shared_pixmap(scrn, ent)) {
942	ScreenPtr master_screen = amdgpu_dirty_master(ent);	942	ScreenPtr primary_screen = amdgpu_dirty_primary(ent);
943		943
944	xorg_list_for_each_entry(region_ent, &master_screen->pixmap_dirty_list, ent) {	944	xorg_list_for_each_entry(region_ent, &primary_screen->pixmap_dirty_list, ent) {
945	if (amdgpu_dirty_src_equals(ent, region_ent->slave_dst))	945	if (amdgpu_dirty_src_equals(ent, region_ent->secondary_dst))
946	break;	946	break;
947	}	947	}
948	}	948	}
Lines 966-972 Link Here
966		966
967	RegionDestroy(region);	967	RegionDestroy(region);
968	} else {	968	} else {
969	if (slave_has_sync_shared_pixmap(scrn, ent))	969	if (secondary_has_sync_shared_pixmap(scrn, ent))
970	continue;	970	continue;
971		971
972	region = dirty_region(ent);	972	region = dirty_region(ent);
Lines 1257-1263 Link Here
1257	(*pScreen->BlockHandler) (BLOCKHANDLER_ARGS);	1257	(*pScreen->BlockHandler) (BLOCKHANDLER_ARGS);
1258	pScreen->BlockHandler = AMDGPUBlockHandler_KMS;	1258	pScreen->BlockHandler = AMDGPUBlockHandler_KMS;
1259		1259
1260	if (!xf86ScreenToScrn(amdgpu_master_screen(pScreen))->vtSema)	1260	if (!xf86ScreenToScrn(amdgpu_primary_screen(pScreen))->vtSema)
1261	return;	1261	return;
1262		1262
1263	if (!pScreen->isGPU)	1263	if (!pScreen->isGPU)
Lines 1809-1815 Link Here
1809	}	1809	}
1810	}	1810	}
1811		1811
1812	static Bool amdgpu_set_drm_master(ScrnInfoPtr pScrn)	1812	static Bool amdgpu_set_drm_primary(ScrnInfoPtr pScrn)
1813	{	1813	{
1814	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);	1814	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);
1815	int err;	1815	int err;
Lines 1822-1833 Link Here
1822		1822
1823	err = drmSetMaster(pAMDGPUEnt->fd);	1823	err = drmSetMaster(pAMDGPUEnt->fd);
1824	if (err)	1824	if (err)
1825	ErrorF("Unable to retrieve master\n");	1825	ErrorF("Unable to retrieve primary\n");
1826		1826
1827	return err == 0;	1827	return err == 0;
1828	}	1828	}
1829		1829
1830	static void amdgpu_drop_drm_master(ScrnInfoPtr pScrn)	1830	static void amdgpu_drop_drm_primary(ScrnInfoPtr pScrn)
1831	{	1831	{
1832	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);	1832	AMDGPUEntPtr pAMDGPUEnt = AMDGPUEntPriv(pScrn);
1833		1833
Lines 1850-1856 Link Here
1850	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);	1850	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
1851	int c;	1851	int c;
1852		1852
1853	if (xf86ScreenToScrn(amdgpu_master_screen(screen))->vtSema)	1853	if (xf86ScreenToScrn(amdgpu_primary_screen(screen))->vtSema)
1854	return 0;	1854	return 0;
1855		1855
1856	/* Unreference the all-black FB created by AMDGPULeaveVT_KMS. After	1856	/* Unreference the all-black FB created by AMDGPULeaveVT_KMS. After
Lines 1913-1919 Link Here
1913	}	1913	}
1914		1914
1915	amdgpu_sync_close(pScreen);	1915	amdgpu_sync_close(pScreen);
1916	amdgpu_drop_drm_master(pScrn);	1916	amdgpu_drop_drm_primary(pScrn);
1917		1917
1918	drmmode_fini(pScrn, &info->drmmode);	1918	drmmode_fini(pScrn, &info->drmmode);
1919	if (info->dri2.enabled) {	1919	if (info->dri2.enabled) {
Lines 1964-1970 Link Here
1964	return FALSE;	1964	return FALSE;
1965	miSetPixmapDepths();	1965	miSetPixmapDepths();
1966		1966
1967	if (!amdgpu_set_drm_master(pScrn))	1967	if (!amdgpu_set_drm_primary(pScrn))
1968	return FALSE;	1968	return FALSE;
1969		1969
1970	info->directRenderingEnabled = FALSE;	1970	info->directRenderingEnabled = FALSE;
Lines 2199-2205 Link Here
2199	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,	2199	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,
2200	"AMDGPUEnterVT_KMS\n");	2200	"AMDGPUEnterVT_KMS\n");
2201		2201
2202	amdgpu_set_drm_master(pScrn);	2202	amdgpu_set_drm_primary(pScrn);
2203		2203
2204	if (info->shadow_fb) {	2204	if (info->shadow_fb) {
2205	int pitch;	2205	int pitch;
Lines 2225-2231 Link Here
2225	if (!front_buffer) {	2225	if (!front_buffer) {
2226	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,	2226	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
2227	"Failed to allocate new scanout BO after VT switch, "	2227	"Failed to allocate new scanout BO after VT switch, "
2228	"other DRM masters may see screen contents\n");	2228	"other DRM primarys may see screen contents\n");
2229	}	2229	}
2230	}	2230	}
2231		2231
Lines 2360-2366 Link Here
2360	hide_cursors:	2360	hide_cursors:
2361	xf86_hide_cursors(pScrn);	2361	xf86_hide_cursors(pScrn);
2362		2362
2363	amdgpu_drop_drm_master(pScrn);	2363	amdgpu_drop_drm_primary(pScrn);
2364		2364
2365	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,	2365	xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, AMDGPU_LOGLEVEL_DEBUG,
2366	"Ok, leaving now...\n");	2366	"Ok, leaving now...\n");