From c67c5ea255d4837816e298a0d49f8dc3ccb4c288 Mon Sep 17 00:00:00 2001 From: Egbert Eich Date: Thu, 27 Jan 2011 11:59:27 +0100 Subject: [PATCH] Add VGA arbitration. This version of VGA arbitration is SIGIO save. --- xorg-server-1.6.5/configure.ac | 2 + xorg-server-1.6.5/hw/xfree86/common/Makefile.am | 6 +- xorg-server-1.6.5/hw/xfree86/common/xf86Bus.c | 220 +--- xorg-server-1.6.5/hw/xfree86/common/xf86DPMS.c | 4 +- xorg-server-1.6.5/hw/xfree86/common/xf86Init.c | 17 +- xorg-server-1.6.5/hw/xfree86/common/xf86PM.c | 5 - xorg-server-1.6.5/hw/xfree86/common/xf86Priv.h | 1 - .../hw/xfree86/common/xf86VGAarbiter.c | 1419 ++++++++++++++++++++ .../hw/xfree86/common/xf86VGAarbiter.h | 48 + xorg-server-1.6.5/hw/xfree86/common/xf86pciBus.c | 7 + xorg-server-1.6.5/hw/xfree86/common/xf86str.h | 3 +- xorg-server-1.6.5/hw/xfree86/dri/dri.c | 7 + xorg-server-1.6.5/hw/xfree86/dri2/dri2.c | 7 + xorg-server-1.6.5/hw/xfree86/loader/xf86sym.c | 11 + xorg-server-1.6.5/include/xorg-config.h.in | 6 + 15 files changed, 1530 insertions(+), 233 deletions(-) create mode 100644 xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c create mode 100644 xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h diff --git a/xorg-server-1.6.5/configure.ac b/xorg-server-1.6.5/configure.ac index 7379069..2b2b799 100644 --- a/xorg-server-1.6.5/configure.ac +++ b/xorg-server-1.6.5/configure.ac @@ -1298,6 +1298,8 @@ if test "x$XORG" = xyes; then LIBS=$PCIACCESS_LIBS AC_CHECK_FUNCS([pci_system_init_dev_mem]) AC_CHECK_FUNCS([pci_device_enable]) + AC_CHECK_FUNCS([pci_device_is_boot_vga]) + AC_CHECK_FUNCS([pci_device_vgaarb_init]) LIBS=$SAVE_LIBS CFLAGS=$SAVE_CFLAGS XORG_SYS_LIBS="$XORG_SYS_LIBS $PCIACCESS_LIBS $DLOPEN_LIBS $GLX_SYS_LIBS $SELINUX_LIB" diff --git a/xorg-server-1.6.5/hw/xfree86/common/Makefile.am b/xorg-server-1.6.5/hw/xfree86/common/Makefile.am index b38c14a..881fdcb 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/Makefile.am +++ b/xorg-server-1.6.5/hw/xfree86/common/Makefile.am @@ -28,7 +28,7 @@ AM_LDFLAGS = -r libcommon_la_SOURCES = xf86Configure.c xf86ShowOpts.c xf86Bus.c xf86Config.c \ xf86Cursor.c xf86DGA.c xf86DPMS.c \ xf86Events.c xf86Globals.c xf86AutoConfig.c \ - xf86Option.c \ + xf86Option.c xf86VGAarbiter.c \ xf86VidMode.c xf86fbman.c xf86cmap.c \ xf86Helper.c xf86PM.c xf86RAC.c xf86Xinput.c xisb.c \ xf86Mode.c xorgHelper.c \ @@ -47,7 +47,7 @@ sdk_HEADERS = compiler.h fourcc.h xf86.h xf86Module.h xf86Opt.h \ xf86PciInfo.h xf86Priv.h xf86Privstr.h xf86Resources.h \ xf86cmap.h xf86fbman.h xf86str.h xf86RAC.h xf86Xinput.h xisb.h \ $(XVSDKINCS) xorgVersion.h \ - xf86sbusBus.h xf86xvpriv.h + xf86sbusBus.h xf86xvpriv.h xf86VGAarbiter.h DISTCLEANFILES = xf86Build.h CLEANFILES = $(BUILT_SOURCES) @@ -79,6 +79,8 @@ EXTRA_DIST = \ xf86Date.h \ $(MODEDEFSOURCES) \ modeline2c.awk \ + xf86VGAarbiter.h \ + xf86VGAarbiterPriv.h \ $(DISTKBDSOURCES) if LNXACPI diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86Bus.c b/xorg-server-1.6.5/hw/xfree86/common/xf86Bus.c index e624a17..fbf896c 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86Bus.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86Bus.c @@ -41,6 +41,7 @@ #include "xf86.h" #include "xf86Priv.h" #include "xf86Resources.h" +#include "xf86VGAarbiter.h" /* Bus-specific headers */ @@ -87,7 +88,6 @@ _X_EXPORT resRange res8514Exclusive[] = {_8514_EXCLUSIVE, _END}; _X_EXPORT resRange res8514Shared[] = {_8514_SHARED, _END}; /* Flag: do we need RAC ? */ -static Bool needRAC = FALSE; static Bool doFramebufferMode = FALSE; /* state change notification callback list */ @@ -1546,11 +1546,6 @@ SetSIGIOForState(xf86State state) void xf86EnterServerState(xf86State state) { - EntityPtr pEnt; - ScrnInfoPtr pScrn; - int i,j; - int needVGA = 0; - resType rt; /* * This is a good place to block SIGIO during SETUP state. * SIGIO should be blocked in SETUP state otherwise (u)sleep() @@ -1564,86 +1559,7 @@ xf86EnterServerState(xf86State state) else ErrorF("Entering OPERATING state\n"); #endif - - /* When servicing a dumb framebuffer we don't need to do anything */ - if (doFramebufferMode) return; - - for (i=0; ientityList[pScrn->numEntities - 1]; - pScrn->access = xf86Entities[j]->access; - - for (j = 0; jnumEntities; j++) { - pEnt = xf86Entities[xf86Screens[i]->entityList[j]]; - if (pEnt->entityProp & (state == SETUP ? NEED_VGA_ROUTED_SETUP - : NEED_VGA_ROUTED)) - xf86Screens[i]->busAccess = pEnt->busAcc; - } - if (xf86Screens[i]->busAccess) - needVGA ++; - } - - /* - * if we just have one screen we don't have RAC. - * Therefore just enable the screen and return. - */ - if (!needRAC) { - xf86EnableAccess(xf86Screens[0]); - notifyStateChange(NOTIFY_ENABLE); - return; - } - - if (state == SETUP) - notifyStateChange(NOTIFY_SETUP_TRANSITION); - else - notifyStateChange(NOTIFY_OPERATING_TRANSITION); - - clearAccess(); - for (i=0; inumEntities; j++) { - pEnt = xf86Entities[xf86Screens[i]->entityList[j]]; - setAccess(pEnt,state); - - if (pEnt->access->rt != NONE) { - if (rt != NONE && rt != pEnt->access->rt) - rt = MEM_IO; - else - rt = pEnt->access->rt; - } - } - xf86Screens[i]->resourceType = rt; - if (rt == NONE) { - xf86Screens[i]->access = NULL; - if (needVGA < 2) - xf86Screens[i]->busAccess = NULL; - } - -#ifdef DEBUG - if (xf86Screens[i]->busAccess) - ErrorF("Screen %i setting vga route\n",i); -#endif - switch (rt) { - case MEM_IO: - xf86MsgVerb(X_INFO, 3, "Screen %i shares mem & io resources\n",i); - break; - case IO: - xf86MsgVerb(X_INFO, 3, "Screen %i shares io resources\n",i); - break; - case MEM: - xf86MsgVerb(X_INFO, 3, "Screen %i shares mem resources\n",i); - break; - default: - xf86MsgVerb(X_INFO, 3, "Entity %i shares no resources\n",i); - break; - } - } - if (state == SETUP) - notifyStateChange(NOTIFY_SETUP); - else - notifyStateChange(NOTIFY_OPERATING); + return; } /* @@ -1652,34 +1568,7 @@ xf86EnterServerState(xf86State state) _X_EXPORT resPtr xf86SetOperatingState(resList list, int entityIndex, int mask) { - resPtr acc; - resPtr r_fail = NULL; - resRange range; - - while (list->type != ResEnd) { - range = *list; - convertRange2Host(entityIndex,&range); - - acc = Acc; - while (acc) { -#define MASK (ResTypeMask | ResExtMask) - if ((acc->entityIndex == entityIndex) - && (acc->val.a == range.a) && (acc->val.b == range.b) - && ((acc->val.type & MASK) == (range.type & MASK))) - break; -#undef MASK - acc = acc->next; - } - if (acc) - acc->val.type = (acc->val.type & ~ResOprMask) - | (mask & ResOprMask); - else { - r_fail = xf86AddResToList(r_fail,&range,entityIndex); - } - list ++; - } - - return r_fail; + return NULL; } /* @@ -1950,26 +1839,6 @@ checkRequiredResources(int entityIndex) } void -xf86PostPreInit() -{ - if (doFramebufferMode) return; - - if (xf86NumScreens > 1) - needRAC = TRUE; - - xf86MsgVerb(X_INFO, 3, "do I need RAC?"); - - if (needRAC) { - xf86ErrorFVerb(3, " Yes, I do.\n"); - } else { - xf86ErrorFVerb(3, " No, I don't.\n"); - } - - xf86MsgVerb(X_INFO, 3, "resource ranges after preInit:\n"); - xf86PrintResList(3, Acc); -} - -void xf86PostScreenInit(void) { int i,j; @@ -1982,90 +1851,11 @@ xf86PostScreenInit(void) return; } -#ifdef DEBUG - ErrorF("PostScreenInit generation: %i\n",serverGeneration); -#endif - if (serverGeneration == 1) { - checkRoutingForScreens(OPERATING); - for (i=0; ientityProp & NEED_MEM_SHARED) - nummem++; - if (xf86Entities[i]->entityProp & NEED_IO_SHARED) - numio++; - } - for (i = 0; i < xf86NumEntities; i++) { - if (nummem < 2) - xf86Entities[i]->entityProp &= ~NEED_MEM_SHARED; - if (numio < 2) - xf86Entities[i]->entityProp &= ~NEED_IO_SHARED; - } - } - if (xf86Screens && needRAC) { - int needRACforVga = 0; - - for (i = 0; i < xf86NumScreens; i++) { - for (j = 0; j < xf86Screens[i]->numEntities; j++) { - if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp - & NEED_VGA_ROUTED) { - needRACforVga ++; - break; /* only count each screen once */ - } - } - } - - for (i = 0; i < xf86NumScreens; i++) { - Bool needRACforMem = FALSE, needRACforIo = FALSE; - - for (j = 0; j < xf86Screens[i]->numEntities; j++) { - if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp - & NEED_MEM_SHARED) - needRACforMem = TRUE; - if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp - & NEED_IO_SHARED) - needRACforIo = TRUE; - /* - * We may need RAC although we don't share any resources - * as we need to route VGA to the correct bus. This can - * only be done simultaniously for MEM and IO. - */ - if (needRACforVga > 1) { - if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp - & NEED_VGA_MEM) - needRACforMem = TRUE; - if (xf86Entities[xf86Screens[i]->entityList[j]]->entityProp - & NEED_VGA_IO) - needRACforIo = TRUE; - } - } - - pScreen = xf86Screens[i]->pScreen; - flags = 0; - if (needRACforMem) { - flags |= xf86Screens[i]->racMemFlags; - xf86ErrorFVerb(3, "Screen %d is using RAC for mem\n", i); - } - if (needRACforIo) { - flags |= xf86Screens[i]->racIoFlags; - xf86ErrorFVerb(3, "Screen %d is using RAC for io\n", i); - } - - xf86RACInit(pScreen,flags); - } - } + xf86VGAarbiterWrapFunctions(); + DebugF("PostScreenInit generation: %i\n",serverGeneration); xf86EnterServerState(OPERATING); - } /* diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86DPMS.c b/xorg-server-1.6.5/hw/xfree86/common/xf86DPMS.c index 889e05d..fb9c819 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86DPMS.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86DPMS.c @@ -44,6 +44,7 @@ #include #include "dpmsproc.h" #endif +#include "xf86VGAarbiter.h" #ifdef DPMSExtension @@ -169,8 +170,9 @@ DPMSSet(ClientPtr client, int level) pDPMS = (DPMSPtr)dixLookupPrivate(&screenInfo.screens[i]->devPrivates, DPMSKey); if (pDPMS && pScrn->DPMSSet && pDPMS->Enabled && pScrn->vtSema) { - xf86EnableAccess(pScrn); + xf86VGAarbiterLock(pScrn); pScrn->DPMSSet(pScrn, level, 0); + xf86VGAarbiterUnlock(pScrn); } } return Success; diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86Init.c b/xorg-server-1.6.5/hw/xfree86/common/xf86Init.c index 5a47fea..8358377 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86Init.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86Init.c @@ -80,6 +80,7 @@ #include "picturestr.h" #endif +#include "xf86VGAarbiter.h" #include "globals.h" #ifdef DPMSExtension @@ -925,6 +926,8 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) return; } + xf86VGAarbiterInit(); + /* * Match up the screens found by the probes against those specified * in the config file. Remove the ones that won't be used. Sort @@ -1005,10 +1008,12 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) */ for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); + xf86VGAarbiterScrnInit(xf86Screens[i]); + xf86VGAarbiterLock(xf86Screens[i]); if (xf86Screens[i]->PreInit && xf86Screens[i]->PreInit(xf86Screens[i], 0)) xf86Screens[i]->configured = TRUE; + xf86VGAarbiterUnlock(xf86Screens[i]); } for (i = 0; i < xf86NumScreens; i++) if (!xf86Screens[i]->configured) @@ -1164,9 +1169,6 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) } } - /* set up the proper access funcs */ - xf86PostPreInit(); - } else { /* * serverGeneration != 1; some OSs have to do things here, too. @@ -1231,7 +1233,7 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) #endif /* SCO325 */ for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); + xf86VGAarbiterLock(xf86Screens[i]); /* * Almost everything uses these defaults, and many of those that * don't, will wrap them. @@ -1244,6 +1246,7 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv) xf86Screens[i]->DriverFunc = NULL; xf86Screens[i]->pScreen = NULL; scr_index = AddScreen(xf86Screens[i]->ScreenInit, argc, argv); + xf86VGAarbiterUnlock(xf86Screens[i]); if (scr_index == i) { /* * Hook in our ScrnInfoRec, and initialise some other pScreen @@ -1387,14 +1390,13 @@ ddxGiveUp() { int i; + xf86VGAarbiterFini(); #ifdef XF86PM if (xf86OSPMClose) xf86OSPMClose(); xf86OSPMClose = NULL; #endif - xf86AccessLeaveState(); - for (i = 0; i < xf86NumScreens; i++) { /* * zero all access functions to @@ -1449,7 +1451,6 @@ AbortDDX() * we might not have been wrapped yet. Therefore enable * screen explicitely. */ - xf86EnableAccess(xf86Screens[i]); (xf86Screens[i]->LeaveVT)(i, 0); } } diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86PM.c b/xorg-server-1.6.5/hw/xfree86/common/xf86PM.c index 7c8320d..54c6068 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86PM.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86PM.c @@ -70,7 +70,6 @@ suspend (pmEvent event, Bool undo) xf86inSuspend = TRUE; for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); if (xf86Screens[i]->EnableDisableFBAccess) (*xf86Screens[i]->EnableDisableFBAccess) (i, FALSE); } @@ -81,7 +80,6 @@ suspend (pmEvent event, Bool undo) } xf86EnterServerState(SETUP); for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); if (xf86Screens[i]->PMEvent) xf86Screens[i]->PMEvent(i,event,undo); else { @@ -102,7 +100,6 @@ resume(pmEvent event, Bool undo) xf86AccessEnter(); xf86EnterServerState(SETUP); for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); if (xf86Screens[i]->PMEvent) xf86Screens[i]->PMEvent(i,event,undo); else { @@ -112,7 +109,6 @@ resume(pmEvent event, Bool undo) } xf86EnterServerState(OPERATING); for (i = 0; i < xf86NumScreens; i++) { - xf86EnableAccess(xf86Screens[i]); if (xf86Screens[i]->EnableDisableFBAccess) (*xf86Screens[i]->EnableDisableFBAccess) (i, TRUE); } @@ -167,7 +163,6 @@ DoApmEvent(pmEvent event, Bool undo) if (xf86Screens[i]->PMEvent) { if (!setup) xf86EnterServerState(SETUP); setup = 1; - xf86EnableAccess(xf86Screens[i]); xf86Screens[i]->PMEvent(i,event,undo); } } diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86Priv.h b/xorg-server-1.6.5/hw/xfree86/common/xf86Priv.h index 80d4d00..70af690 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86Priv.h +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86Priv.h @@ -140,7 +140,6 @@ void xf86ResourceBrokerInit(void); void xf86PostProbe(void); void xf86ClearEntityListForScreen(int scrnIndex); void xf86AddDevToEntity(int entityIndex, GDevPtr dev); -extern void xf86PostPreInit(void); extern void xf86PostScreenInit(void); /* xf86Config.c */ diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c new file mode 100644 index 0000000..9158b2d --- /dev/null +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c @@ -0,0 +1,1419 @@ +/* + * This code was stolen from RAC and adapted to control the legacy vga + * interface. + * + * + * Copyright (c) 2007 Paulo R. Zanoni, Tiago Vignatti + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#ifdef HAVE_XORG_CONFIG_H +#include +#endif + +#ifdef HAVE_PCI_DEVICE_VGAARB_INIT +#include "misc.h" +#include "xf86.h" +#include "xf86_OSproc.h" +#include +#include "colormapst.h" +#include "scrnintstr.h" +#include "screenint.h" +#include "gcstruct.h" +#include "pixmapstr.h" +#include "pixmap.h" +#include "windowstr.h" +#include "window.h" +#include "xf86str.h" +#include "mipointer.h" +#include "mipointrst.h" +#ifdef RENDER +# include "picturestr.h" +#endif +#include "xf86Bus.h" +#include "xf86Priv.h" +#include "pciaccess.h" +#include "xf86VGAarbiter.h" + +#if 1 +# define DEBUG(x) +#else +# define DEBUG(x) do { x; } while (0) +#endif +#define WRAP_SCREEN(x,y) {pScreenPriv->x = pScreen->x; pScreen->x = y;} + +#define UNWRAP_SCREEN(x) pScreen->x = pScreenPriv->x + +#define SCREEN_PROLOG(x) pScreen->x = ((VGAarbiterScreenPtr) \ + dixLookupPrivate(&(pScreen)->devPrivates, VGAarbiterScreenKey))->x + +#define SCREEN_EPILOG(x,y) pScreen->x = y; + +#define WRAP_PICT(x,y) if (ps) {pScreenPriv->x = ps->x;\ + ps->x = y;} + +#define UNWRAP_PICT(x) if (ps) {ps->x = pScreenPriv->x;} + +#define PICTURE_PROLOGUE(field) ps->field = \ + ((VGAarbiterScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, \ + VGAarbiterScreenKey))->field + +#define PICTURE_EPILOGUE(field, wrap) ps->field = wrap + +#define WRAP_SCREEN_INFO(x,y) do {pScreenPriv->x = pScrn->x; pScrn->x = y;} while(0) + +#define UNWRAP_SCREEN_INFO(x) pScrn->x = pScreenPriv->x + +#define SPRITE_PROLOG miPointerScreenPtr PointPriv = \ + (miPointerScreenPtr)dixLookupPrivate(&pScreen->devPrivates, \ + miPointerScreenKey); VGAarbiterScreenPtr pScreenPriv = \ + ((VGAarbiterScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, \ + VGAarbiterScreenKey)); PointPriv->spriteFuncs = pScreenPriv->miSprite; + +#define SPRITE_EPILOG pScreenPriv->miSprite = PointPriv->spriteFuncs;\ + PointPriv->spriteFuncs = &VGAarbiterSpriteFuncs; + +#define WRAP_SPRITE do { pScreenPriv->miSprite = PointPriv->spriteFuncs;\ + PointPriv->spriteFuncs = &VGAarbiterSpriteFuncs; \ + } while (0) + +#define UNWRAP_SPRITE PointPriv->spriteFuncs = pScreenPriv->miSprite + +#define GC_WRAP(x) pGCPriv->wrapOps = (x)->ops;\ + pGCPriv->wrapFuncs = (x)->funcs; (x)->ops = &VGAarbiterGCOps;\ + (x)->funcs = &VGAarbiterGCFuncs; + +#define GC_UNWRAP(x) VGAarbiterGCPtr pGCPriv = \ + (VGAarbiterGCPtr)dixLookupPrivate(&(x)->devPrivates, VGAarbiterGCKey);\ + (x)->ops = pGCPriv->wrapOps; (x)->funcs = pGCPriv->wrapFuncs; + +#define GC_SCREEN register ScrnInfoPtr pScrn = \ + xf86Screens[pGC->pScreen->myNum] + +#define VGAGet(x) int sigiostate = xf86BlockSIGIO(); \ + DEBUG(ErrorF("VGA lock: %s %p\n",__FUNCTION__,(xf86Screens[pScreen->myNum]->vgaDev))); \ + assert(!currVgaLock || currVgaLock == xf86Screens[pScreen->myNum]->vgaDev); \ + currVgaLock = xf86Screens[pScreen->myNum]->vgaDev; \ + currVgaLockCnt++; \ + pci_device_vgaarb_set_target(xf86Screens[pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_lock(); \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); \ + xf86UnblockSIGIO(sigiostate); + +#define VGAGet_GC(x) int sigiostate = xf86BlockSIGIO(); \ + DEBUG(ErrorF("VGA lock: %s %p\n",__FUNCTION__,(xf86Screens[pGC->pScreen->myNum]->vgaDev))); \ + assert(!currVgaLock || currVgaLock == xf86Screens[pGC->pScreen->myNum]->vgaDev); \ + currVgaLock = xf86Screens[pGC->pScreen->myNum]->vgaDev; \ + currVgaLockCnt++; \ + pci_device_vgaarb_set_target(xf86Screens[pGC->pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_lock(); \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); \ + xf86UnblockSIGIO(sigiostate); + +#define VGAPut(x) sigiostate = xf86BlockSIGIO(); \ + DEBUG(ErrorF("VGA unlock: %s %p\n",__FUNCTION__,(xf86Screens[pScreen->myNum]->vgaDev))); \ + assert(currVgaLock && currVgaLock == xf86Screens[pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_unlock(); \ + currVgaLockCnt--; \ + if (!currVgaLockCnt) currVgaLock = NULL; \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); \ + xf86UnblockSIGIO(sigiostate); + +#define VGAPut_GC(x) sigiostate = xf86BlockSIGIO(); \ + DEBUG(ErrorF("VGA unlock: %s %p\n",__FUNCTION__,(xf86Screens[pGC->pScreen->myNum]->vgaDev))); \ + assert(currVgaLock && currVgaLock == xf86Screens[pGC->pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_unlock(); \ + currVgaLockCnt--; \ + if (!currVgaLockCnt) currVgaLock = NULL; \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); \ + xf86UnblockSIGIO(sigiostate); + +#define VGACursorGet(x)\ + int sigiostate = xf86BlockSIGIO(); \ + struct pci_device *saveVgaLock = NULL; \ + int saveVgaLockCnt = 0; \ + DEBUG(ErrorF("VGA lock: %s %p\n",__FUNCTION__,(xf86Screens[pScreen->myNum]->vgaDev))); \ + if (currVgaLock && (currVgaLock != xf86Screens[pScreen->myNum]->vgaDev)) { \ + DEBUG(ErrorF("CURSOR VGA unlock: %s %p\n",__FUNCTION__,currVgaLock)); \ + saveVgaLock = currVgaLock; \ + saveVgaLockCnt = currVgaLockCnt; \ + while (currVgaLockCnt) { \ + currVgaLockCnt--; \ + pci_device_vgaarb_unlock(); \ + } \ + } \ + currVgaLock = xf86Screens[pScreen->myNum]->vgaDev; \ + currVgaLockCnt++; \ + pci_device_vgaarb_set_target(xf86Screens[pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_lock(); \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); + +#define VGACursorPut(x)\ + DEBUG(ErrorF("VGA unlock: %s %p\n",__FUNCTION__,(xf86Screens[pScreen->myNum]->vgaDev))); \ + assert(!currVgaLock || currVgaLock == xf86Screens[pScreen->myNum]->vgaDev); \ + pci_device_vgaarb_unlock(); \ + currVgaLockCnt--; \ + if (saveVgaLock) { \ + assert(!currVgaLockCnt); \ + DEBUG(ErrorF("CURSOR VGA restore: %s %p LockCnt restored: %i\n",__FUNCTION__,saveVgaLock,currVgaLockCnt)); \ + currVgaLockCnt = saveVgaLockCnt; \ + pci_device_vgaarb_set_target(saveVgaLock); \ + while (saveVgaLockCnt--) \ + pci_device_vgaarb_lock(); \ + currVgaLock = saveVgaLock; \ + } else if (!currVgaLockCnt) currVgaLock = NULL; \ + xf86UnblockSIGIO(sigiostate); \ + DEBUG(ErrorF("done. LockCnt: %i\n",currVgaLockCnt)); + +typedef struct _VGAarbiterScreen { + CreateGCProcPtr CreateGC; + CloseScreenProcPtr CloseScreen; + ScreenBlockHandlerProcPtr BlockHandler; + ScreenWakeupHandlerProcPtr WakeupHandler; + GetImageProcPtr GetImage; + GetSpansProcPtr GetSpans; + SourceValidateProcPtr SourceValidate; + CopyWindowProcPtr CopyWindow; + ClearToBackgroundProcPtr ClearToBackground; + CreatePixmapProcPtr CreatePixmap; + SaveScreenProcPtr SaveScreen; + /* Colormap */ + StoreColorsProcPtr StoreColors; + /* Cursor */ + DisplayCursorProcPtr DisplayCursor; + RealizeCursorProcPtr RealizeCursor; + UnrealizeCursorProcPtr UnrealizeCursor; + RecolorCursorProcPtr RecolorCursor; + SetCursorPositionProcPtr SetCursorPosition; + void (*AdjustFrame)(int,int,int,int); + Bool (*SwitchMode)(int, DisplayModePtr,int); + Bool (*EnterVT)(int, int); + void (*LeaveVT)(int, int); + void (*FreeScreen)(int, int); + miPointerSpriteFuncPtr miSprite; +#ifdef RENDER + CompositeProcPtr Composite; + GlyphsProcPtr Glyphs; + CompositeRectsProcPtr CompositeRects; +#endif +} VGAarbiterScreenRec, *VGAarbiterScreenPtr; + +typedef struct _VGAarbiterGC { + GCOps *wrapOps; + GCFuncs *wrapFuncs; +} VGAarbiterGCRec, *VGAarbiterGCPtr; + +/* Screen funcs */ +static void VGAarbiterBlockHandler(int i, pointer blockData, pointer pTimeout, pointer pReadmask); +static void VGAarbiterWakeupHandler(int i, pointer blockData, unsigned long result, pointer pReadmask); +static Bool VGAarbiterCloseScreen (int i, ScreenPtr pScreen); +static void VGAarbiterGetImage (DrawablePtr pDrawable, int sx, int sy, int w, + int h, unsigned int format, unsigned long planemask, char *pdstLine); +static void VGAarbiterGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr + ppt, int *pwidth, int nspans, char *pdstStart); +static void VGAarbiterSourceValidate (DrawablePtr pDrawable, int x, int y, + int width, int height); +static void VGAarbiterCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, + RegionPtr prgnSrc); +static void VGAarbiterClearToBackground (WindowPtr pWin, int x, int y, int w, + int h, Bool generateExposures); +static PixmapPtr VGAarbiterCreatePixmap(ScreenPtr pScreen, int w, int h, + int depth, unsigned int usage_hint); +static Bool VGAarbiterCreateGC(GCPtr pGC); +static Bool VGAarbiterSaveScreen(ScreenPtr pScreen, Bool unblank); +static void VGAarbiterStoreColors (ColormapPtr pmap, int ndef, xColorItem + *pdefs); +static void VGAarbiterRecolorCursor (DeviceIntPtr pDev, ScreenPtr pScreen, + CursorPtr pCurs, Bool displayed); +static Bool VGAarbiterRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, + CursorPtr pCursor); +static Bool VGAarbiterUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, + CursorPtr pCursor); +static Bool VGAarbiterDisplayCursor (DeviceIntPtr pDev, ScreenPtr pScreen, + CursorPtr pCursor); +static Bool VGAarbiterSetCursorPosition (DeviceIntPtr pDev, ScreenPtr + pScreen, int x, int y, Bool generateEvent); +static void VGAarbiterAdjustFrame(int index, int x, int y, int flags); +static Bool VGAarbiterSwitchMode(int index, DisplayModePtr mode, int flags); +static Bool VGAarbiterEnterVT(int index, int flags); +static void VGAarbiterLeaveVT(int index, int flags); +static void VGAarbiterFreeScreen(int index, int flags); + +/* GC funcs */ +static void VGAarbiterValidateGC(GCPtr pGC, unsigned long changes, + DrawablePtr pDraw); +static void VGAarbiterChangeGC(GCPtr pGC, unsigned long mask); +static void VGAarbiterCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst); +static void VGAarbiterDestroyGC(GCPtr pGC); +static void VGAarbiterChangeClip(GCPtr pGC, int type, pointer pvalue, + int nrects); +static void VGAarbiterDestroyClip(GCPtr pGC); +static void VGAarbiterCopyClip(GCPtr pgcDst, GCPtr pgcSrc); + +/* GC ops */ +static void VGAarbiterFillSpans( DrawablePtr pDraw, GC *pGC, int nInit, + DDXPointPtr pptInit, int *pwidthInit, int fSorted); +static void VGAarbiterSetSpans(DrawablePtr pDraw, GCPtr pGC, char *pcharsrc, + register DDXPointPtr ppt, int *pwidth, int nspans, int fSorted); +static void VGAarbiterPutImage(DrawablePtr pDraw, GCPtr pGC, int depth, + int x, int y, int w, int h, int leftPad, int format, char *pImage); +static RegionPtr VGAarbiterCopyArea(DrawablePtr pSrc, DrawablePtr pDst, + GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty); +static RegionPtr VGAarbiterCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, + GCPtr pGC, int srcx, int srcy, int width, int height, int dstx, int dsty, + unsigned long bitPlane); +static void VGAarbiterPolyPoint(DrawablePtr pDraw, GCPtr pGC, int mode, + int npt, xPoint *pptInit); +static void VGAarbiterPolylines(DrawablePtr pDraw, GCPtr pGC, int mode, + int npt, DDXPointPtr pptInit); +static void VGAarbiterPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg, + xSegment *pSeg); +static void VGAarbiterPolyRectangle(DrawablePtr pDraw, GCPtr pGC, + int nRectsInit, xRectangle *pRectsInit); +static void VGAarbiterPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, + xArc *parcs); +static void VGAarbiterFillPolygon(DrawablePtr pDraw, GCPtr pGC, int shape, + int mode, int count, DDXPointPtr ptsIn); +static void VGAarbiterPolyFillRect( DrawablePtr pDraw, GCPtr pGC, + int nrectFill, xRectangle *prectInit); +static void VGAarbiterPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs, + xArc *parcs); +static int VGAarbiterPolyText8(DrawablePtr pDraw, GCPtr pGC, int x, int y, + int count, char *chars); +static int VGAarbiterPolyText16(DrawablePtr pDraw, GCPtr pGC, int x, int y, + int count, unsigned short *chars); +static void VGAarbiterImageText8(DrawablePtr pDraw, GCPtr pGC, int x, int y, + int count, char *chars); +static void VGAarbiterImageText16(DrawablePtr pDraw, GCPtr pGC, int x, int y, + int count, unsigned short *chars); +static void VGAarbiterImageGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int xInit, + int yInit, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); +static void VGAarbiterPolyGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int xInit, + int yInit, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); +static void VGAarbiterPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr + pDraw, int dx, int dy, int xOrg, int yOrg); + +/* miSpriteFuncs */ +static Bool VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr + pScreen, CursorPtr pCur); +static Bool VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr + pScreen, CursorPtr pCur); +static void VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, + CursorPtr pCur, int x, int y); +static void VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, + int x, int y); +static Bool VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen); +static void VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen); + + +#ifdef RENDER +static void VGAarbiterComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, + PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, + INT16 xDst, INT16 yDst, CARD16 width, CARD16 height); +static void VGAarbiterGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, + PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist, GlyphListPtr + list, GlyphPtr *glyphs); +static void VGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor + *color, int nRect, xRectangle *rects); +#endif + +static GCFuncs VGAarbiterGCFuncs = { + VGAarbiterValidateGC, VGAarbiterChangeGC, VGAarbiterCopyGC, + VGAarbiterDestroyGC, VGAarbiterChangeClip, VGAarbiterDestroyClip, + VGAarbiterCopyClip +}; + +static GCOps VGAarbiterGCOps = { + VGAarbiterFillSpans, VGAarbiterSetSpans, VGAarbiterPutImage, + VGAarbiterCopyArea, VGAarbiterCopyPlane, VGAarbiterPolyPoint, + VGAarbiterPolylines, VGAarbiterPolySegment, VGAarbiterPolyRectangle, + VGAarbiterPolyArc, VGAarbiterFillPolygon, VGAarbiterPolyFillRect, + VGAarbiterPolyFillArc, VGAarbiterPolyText8, VGAarbiterPolyText16, + VGAarbiterImageText8, VGAarbiterImageText16, VGAarbiterImageGlyphBlt, + VGAarbiterPolyGlyphBlt, VGAarbiterPushPixels, + {NULL} /* devPrivate */ +}; + +static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = { + VGAarbiterSpriteRealizeCursor, VGAarbiterSpriteUnrealizeCursor, + VGAarbiterSpriteSetCursor, VGAarbiterSpriteMoveCursor, + VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup +}; + +static int VGAarbiterKeyIndex; +static DevPrivateKey VGAarbiterScreenKey = &VGAarbiterKeyIndex; +static int VGAarbiterGCIndex; +static DevPrivateKey VGAarbiterGCKey = &VGAarbiterGCIndex; + +static int vga_no_arb = 0; +static struct pci_device *currVgaLock = NULL; +static int currVgaLockCnt = 0; + +void +xf86VGAarbiterInit(void) +{ + if (pci_device_vgaarb_init() != 0) { + vga_no_arb = 1; + xf86Msg(X_WARNING, "VGA arbiter: cannot open kernel arbiter, no multi-card support\n"); + } +} + +void +xf86VGAarbiterFini(void) +{ + if (vga_no_arb) + return; + pci_device_vgaarb_fini(); +} + +void +xf86VGAarbiterLock(ScrnInfoPtr pScrn) +{ + if (vga_no_arb) + return; + DEBUG(ErrorF("%s %p\n",__FUNCTION__,pScrn->vgaDev)); + pci_device_vgaarb_set_target(pScrn->vgaDev); + pci_device_vgaarb_lock(); +} + +void +xf86VGAarbiterUnlock(ScrnInfoPtr pScrn) +{ + if (vga_no_arb) + return; + DEBUG(ErrorF("%s %p\n",__FUNCTION__,pScrn->vgaDev)); + pci_device_vgaarb_unlock(); + DEBUG(ErrorF("done\n")); +} + +Bool xf86VGAarbiterAllowDRI(ScreenPtr pScreen) +{ + int vga_count; + int rsrc_decodes; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + + if (vga_no_arb) + return TRUE; + + pci_device_vgaarb_get_info(pScrn->vgaDev, &vga_count, &rsrc_decodes); + if (vga_count > 1) { + if (rsrc_decodes) { + return FALSE; + } + } + return TRUE; +} + +void +xf86VGAarbiterScrnInit(ScrnInfoPtr pScrn) +{ + struct pci_device *dev; + EntityPtr pEnt; + + if (vga_no_arb) + return; + + pEnt = xf86Entities[pScrn->entityList[0]]; + if (pEnt->bus.type != BUS_PCI) + return; + + dev = pEnt->bus.id.pci; + pScrn->vgaDev = dev; +} + +void +xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn) +{ + if (vga_no_arb) + return; + pci_device_vgaarb_decodes(VGA_ARB_RSRC_LEGACY_MEM | VGA_ARB_RSRC_LEGACY_IO); +} + +Bool +xf86VGAarbiterWrapFunctions(void) +{ + ScrnInfoPtr pScrn; + VGAarbiterScreenPtr pScreenPriv; + miPointerScreenPtr PointPriv; +#ifdef RENDER + PictureScreenPtr ps; +#endif + ScreenPtr pScreen; + int vga_count, i; + + if (vga_no_arb) + return FALSE; + + /* + * we need to wrap the arbiter if we have more than + * one VGA card - hotplug cries. + */ + pci_device_vgaarb_get_info(NULL, &vga_count, NULL); + if (vga_count < 2 || !xf86Screens) + return FALSE; + + xf86Msg(X_INFO,"Found %d VGA devices: arbiter wrapping enabled\n", + vga_count); + + for (i = 0; i < xf86NumScreens; i++) { + pScreen = xf86Screens[i]->pScreen; +#ifdef RENDER + ps = GetPictureScreenIfSet(pScreen); +#endif + pScrn = xf86Screens[pScreen->myNum]; + PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey); + + if (!dixRequestPrivate(VGAarbiterGCKey, sizeof(VGAarbiterGCRec))) + return FALSE; + + if (!(pScreenPriv = xalloc(sizeof(VGAarbiterScreenRec)))) + return FALSE; + + dixSetPrivate(&pScreen->devPrivates, VGAarbiterScreenKey, pScreenPriv); + + WRAP_SCREEN(CloseScreen, VGAarbiterCloseScreen); + WRAP_SCREEN(SaveScreen, VGAarbiterSaveScreen); + WRAP_SCREEN(WakeupHandler, VGAarbiterWakeupHandler); + WRAP_SCREEN(BlockHandler, VGAarbiterBlockHandler); + WRAP_SCREEN(CreateGC, VGAarbiterCreateGC); + WRAP_SCREEN(GetImage, VGAarbiterGetImage); + WRAP_SCREEN(GetSpans, VGAarbiterGetSpans); + WRAP_SCREEN(SourceValidate, VGAarbiterSourceValidate); + WRAP_SCREEN(CopyWindow, VGAarbiterCopyWindow); + WRAP_SCREEN(ClearToBackground, VGAarbiterClearToBackground); + WRAP_SCREEN(CreatePixmap, VGAarbiterCreatePixmap); + WRAP_SCREEN(StoreColors, VGAarbiterStoreColors); + WRAP_SCREEN(DisplayCursor, VGAarbiterDisplayCursor); + WRAP_SCREEN(RealizeCursor, VGAarbiterRealizeCursor); + WRAP_SCREEN(UnrealizeCursor, VGAarbiterUnrealizeCursor); + WRAP_SCREEN(RecolorCursor, VGAarbiterRecolorCursor); + WRAP_SCREEN(SetCursorPosition, VGAarbiterSetCursorPosition); +#ifdef RENDER + WRAP_PICT(Composite,VGAarbiterComposite); + WRAP_PICT(Glyphs,VGAarbiterGlyphs); + WRAP_PICT(CompositeRects,VGAarbiterCompositeRects); +#endif + WRAP_SCREEN_INFO(AdjustFrame, VGAarbiterAdjustFrame); + WRAP_SCREEN_INFO(SwitchMode, VGAarbiterSwitchMode); + WRAP_SCREEN_INFO(EnterVT, VGAarbiterEnterVT); + WRAP_SCREEN_INFO(LeaveVT, VGAarbiterLeaveVT); + WRAP_SCREEN_INFO(FreeScreen, VGAarbiterFreeScreen); + WRAP_SPRITE; + } + + return TRUE; +} + +/* Screen funcs */ +static Bool +VGAarbiterCloseScreen (int i, ScreenPtr pScreen) +{ + Bool val; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + miPointerScreenPtr PointPriv = (miPointerScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, miPointerScreenKey); +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + + UNWRAP_SCREEN(CreateGC); + UNWRAP_SCREEN(CloseScreen); + UNWRAP_SCREEN(GetImage); + UNWRAP_SCREEN(GetSpans); + UNWRAP_SCREEN(SourceValidate); + UNWRAP_SCREEN(CopyWindow); + UNWRAP_SCREEN(ClearToBackground); + UNWRAP_SCREEN(SaveScreen); + UNWRAP_SCREEN(StoreColors); + UNWRAP_SCREEN(DisplayCursor); + UNWRAP_SCREEN(RealizeCursor); + UNWRAP_SCREEN(UnrealizeCursor); + UNWRAP_SCREEN(RecolorCursor); + UNWRAP_SCREEN(SetCursorPosition); +#ifdef RENDER + UNWRAP_PICT(Composite); + UNWRAP_PICT(Glyphs); + UNWRAP_PICT(CompositeRects); +#endif + UNWRAP_SCREEN_INFO(AdjustFrame); + UNWRAP_SCREEN_INFO(SwitchMode); + UNWRAP_SCREEN_INFO(EnterVT); + UNWRAP_SCREEN_INFO(LeaveVT); + UNWRAP_SCREEN_INFO(FreeScreen); + UNWRAP_SPRITE; + + xfree ((pointer) pScreenPriv); + xf86VGAarbiterLock(xf86Screens[i]); + val = (*pScreen->CloseScreen) (i, pScreen); + xf86VGAarbiterUnlock(xf86Screens[i]); + return val; +} + +static void +VGAarbiterBlockHandler(int i, + pointer blockData, pointer pTimeout, pointer pReadmask) +{ + ScreenPtr pScreen = screenInfo.screens[i]; + SCREEN_PROLOG(BlockHandler); + VGAGet(); + pScreen->BlockHandler(i, blockData, pTimeout, pReadmask); + VGAPut(); + SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler); +} + +static void +VGAarbiterWakeupHandler(int i, pointer blockData, unsigned long result, pointer pReadmask) +{ + ScreenPtr pScreen = screenInfo.screens[i]; + SCREEN_PROLOG(WakeupHandler); + VGAGet(); + pScreen->WakeupHandler(i, blockData, result, pReadmask); + VGAPut(); + SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler); +} + +static void +VGAarbiterGetImage ( + DrawablePtr pDrawable, + int sx, int sy, int w, int h, + unsigned int format, + unsigned long planemask, + char *pdstLine + ) +{ + ScreenPtr pScreen = pDrawable->pScreen; + SCREEN_PROLOG(GetImage); +// if (xf86Screens[pScreen->myNum]->vtSema) { + VGAGet(); +// } + (*pScreen->GetImage) (pDrawable, sx, sy, w, h, + format, planemask, pdstLine); + VGAPut(); + SCREEN_EPILOG (GetImage, VGAarbiterGetImage); +} + +static void +VGAarbiterGetSpans ( + DrawablePtr pDrawable, + int wMax, + DDXPointPtr ppt, + int *pwidth, + int nspans, + char *pdstStart + ) +{ + ScreenPtr pScreen = pDrawable->pScreen; + + SCREEN_PROLOG (GetSpans); + VGAGet(); + (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart); + VGAPut(); + SCREEN_EPILOG (GetSpans, VGAarbiterGetSpans); +} + +static void +VGAarbiterSourceValidate ( + DrawablePtr pDrawable, + int x, int y, int width, int height ) +{ + ScreenPtr pScreen = pDrawable->pScreen; + SCREEN_PROLOG (SourceValidate); + VGAGet(); + if (pScreen->SourceValidate) + (*pScreen->SourceValidate) (pDrawable, x, y, width, height); + VGAPut(); + SCREEN_EPILOG (SourceValidate, VGAarbiterSourceValidate); +} + +static void +VGAarbiterCopyWindow( + WindowPtr pWin, + DDXPointRec ptOldOrg, + RegionPtr prgnSrc ) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + + SCREEN_PROLOG (CopyWindow); + VGAGet(); + (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc); + VGAPut(); + SCREEN_EPILOG (CopyWindow, VGAarbiterCopyWindow); +} + +static void +VGAarbiterClearToBackground ( + WindowPtr pWin, + int x, int y, + int w, int h, + Bool generateExposures ) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + + SCREEN_PROLOG ( ClearToBackground); + VGAGet(); + (*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures); + VGAPut(); + SCREEN_EPILOG (ClearToBackground, VGAarbiterClearToBackground); +} + +static PixmapPtr +VGAarbiterCreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned usage_hint) +{ + PixmapPtr pPix; + + SCREEN_PROLOG ( CreatePixmap); + VGAGet(); + pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint); + VGAPut(); + SCREEN_EPILOG (CreatePixmap, VGAarbiterCreatePixmap); + + return pPix; +} + +static Bool +VGAarbiterSaveScreen(ScreenPtr pScreen, Bool unblank) +{ + Bool val; + + SCREEN_PROLOG (SaveScreen); + VGAGet(); + val = (*pScreen->SaveScreen) (pScreen, unblank); + VGAPut(); + SCREEN_EPILOG (SaveScreen, VGAarbiterSaveScreen); + + return val; +} + +static void +VGAarbiterStoreColors ( + ColormapPtr pmap, + int ndef, + xColorItem *pdefs) +{ + ScreenPtr pScreen = pmap->pScreen; + + SCREEN_PROLOG (StoreColors); + VGAGet(); + (*pScreen->StoreColors) (pmap,ndef,pdefs); + VGAPut(); + SCREEN_EPILOG ( StoreColors, VGAarbiterStoreColors); +} + +static void +VGAarbiterRecolorCursor ( + DeviceIntPtr pDev, + ScreenPtr pScreen, + CursorPtr pCurs, + Bool displayed + ) +{ + SCREEN_PROLOG (RecolorCursor); + VGACursorGet(); + (*pScreen->RecolorCursor) (pDev, pScreen, pCurs, displayed); + VGACursorPut(); + SCREEN_EPILOG ( RecolorCursor, VGAarbiterRecolorCursor); +} + +static Bool +VGAarbiterRealizeCursor ( + DeviceIntPtr pDev, + ScreenPtr pScreen, + CursorPtr pCursor + ) +{ + Bool val; + + SCREEN_PROLOG (RealizeCursor); + VGACursorGet(); + val = (*pScreen->RealizeCursor) (pDev, pScreen,pCursor); + VGACursorPut(); + SCREEN_EPILOG ( RealizeCursor, VGAarbiterRealizeCursor); + return val; +} + +static Bool +VGAarbiterUnrealizeCursor ( + DeviceIntPtr pDev, + ScreenPtr pScreen, + CursorPtr pCursor + ) +{ + Bool val; + + SCREEN_PROLOG (UnrealizeCursor); + VGACursorGet(); + val = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor); + VGACursorPut(); + SCREEN_EPILOG ( UnrealizeCursor, VGAarbiterUnrealizeCursor); + return val; +} + +static Bool +VGAarbiterDisplayCursor ( + DeviceIntPtr pDev, + ScreenPtr pScreen, + CursorPtr pCursor + ) +{ + Bool val; + + SCREEN_PROLOG (DisplayCursor); + // VGACursorGet(); + val = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor); + // VGACursorPut(); + SCREEN_EPILOG ( DisplayCursor, VGAarbiterDisplayCursor); + return val; +} + +static Bool +VGAarbiterSetCursorPosition ( + DeviceIntPtr pDev, + ScreenPtr pScreen, + int x, int y, + Bool generateEvent) +{ + Bool val; + + SCREEN_PROLOG (SetCursorPosition); + VGACursorGet(); + val = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent); + VGACursorPut(); + SCREEN_EPILOG ( SetCursorPosition, VGAarbiterSetCursorPosition); + return val; +} + +static void +VGAarbiterAdjustFrame(int index, int x, int y, int flags) +{ + ScreenPtr pScreen = screenInfo.screens[index]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + (*pScreenPriv->AdjustFrame)(index, x, y, flags); + VGAPut(); +} + +static Bool +VGAarbiterSwitchMode(int index, DisplayModePtr mode, int flags) +{ + Bool val; + ScreenPtr pScreen = screenInfo.screens[index]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + val = (*pScreenPriv->SwitchMode)(index, mode, flags); + VGAPut(); + return val; +} + +static Bool +VGAarbiterEnterVT(int index, int flags) +{ + Bool val; + ScreenPtr pScreen = screenInfo.screens[index]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + val = (*pScreenPriv->EnterVT)(index, flags); + VGAPut(); + return val; +} + +static void +VGAarbiterLeaveVT(int index, int flags) +{ + ScreenPtr pScreen = screenInfo.screens[index]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + (*pScreenPriv->LeaveVT)(index, flags); + VGAPut(); +} + +static void +VGAarbiterFreeScreen(int index, int flags) +{ + ScreenPtr pScreen = screenInfo.screens[index]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + (*pScreenPriv->FreeScreen)(index, flags); + VGAPut(); +} + +static Bool +VGAarbiterCreateGC(GCPtr pGC) +{ + ScreenPtr pScreen = pGC->pScreen; + VGAarbiterGCPtr pGCPriv = (VGAarbiterGCPtr)dixLookupPrivate(&pGC->devPrivates, VGAarbiterGCKey); + Bool ret; + + SCREEN_PROLOG(CreateGC); + VGAGet(); + ret = (*pScreen->CreateGC)(pGC); + VGAPut(); + GC_WRAP(pGC); + SCREEN_EPILOG(CreateGC,VGAarbiterCreateGC); + + return ret; +} + +/* GC funcs */ +static void +VGAarbiterValidateGC( + GCPtr pGC, + unsigned long changes, + DrawablePtr pDraw ) +{ + GC_UNWRAP(pGC); + (*pGC->funcs->ValidateGC)(pGC, changes, pDraw); + GC_WRAP(pGC); +} + + +static void +VGAarbiterDestroyGC(GCPtr pGC) +{ + GC_UNWRAP (pGC); + (*pGC->funcs->DestroyGC)(pGC); + GC_WRAP (pGC); +} + +static void +VGAarbiterChangeGC ( + GCPtr pGC, + unsigned long mask) +{ + GC_UNWRAP (pGC); + (*pGC->funcs->ChangeGC) (pGC, mask); + GC_WRAP (pGC); +} + +static void +VGAarbiterCopyGC ( + GCPtr pGCSrc, + unsigned long mask, + GCPtr pGCDst) +{ + GC_UNWRAP (pGCDst); + (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst); + GC_WRAP (pGCDst); +} + +static void +VGAarbiterChangeClip ( + GCPtr pGC, + int type, + pointer pvalue, + int nrects ) +{ + GC_UNWRAP (pGC); + (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects); + GC_WRAP (pGC); +} + +static void +VGAarbiterCopyClip(GCPtr pgcDst, GCPtr pgcSrc) +{ + GC_UNWRAP (pgcDst); + (* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc); + GC_WRAP (pgcDst); +} + +static void +VGAarbiterDestroyClip(GCPtr pGC) +{ + GC_UNWRAP (pGC); + (* pGC->funcs->DestroyClip)(pGC); + GC_WRAP (pGC); +} + +/* GC Ops */ +static void +VGAarbiterFillSpans( + DrawablePtr pDraw, + GC *pGC, + int nInit, + DDXPointPtr pptInit, + int *pwidthInit, + int fSorted ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterSetSpans( + DrawablePtr pDraw, + GCPtr pGC, + char *pcharsrc, + register DDXPointPtr ppt, + int *pwidth, + int nspans, + int fSorted ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPutImage( + DrawablePtr pDraw, + GCPtr pGC, + int depth, + int x, int y, int w, int h, + int leftPad, + int format, + char *pImage ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h, + leftPad, format, pImage); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static RegionPtr +VGAarbiterCopyArea( + DrawablePtr pSrc, + DrawablePtr pDst, + GC *pGC, + int srcx, int srcy, + int width, int height, + int dstx, int dsty ) +{ + RegionPtr ret; + + GC_UNWRAP(pGC); + VGAGet_GC(); + ret = (*pGC->ops->CopyArea)(pSrc, pDst, + pGC, srcx, srcy, width, height, dstx, dsty); + VGAPut_GC(); + GC_WRAP(pGC); + return ret; +} + +static RegionPtr +VGAarbiterCopyPlane( + DrawablePtr pSrc, + DrawablePtr pDst, + GCPtr pGC, + int srcx, int srcy, + int width, int height, + int dstx, int dsty, + unsigned long bitPlane ) +{ + RegionPtr ret; + + GC_UNWRAP(pGC); + VGAGet_GC(); + ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, srcx, srcy, + width, height, dstx, dsty, bitPlane); + VGAPut_GC(); + GC_WRAP(pGC); + return ret; +} + +static void +VGAarbiterPolyPoint( + DrawablePtr pDraw, + GCPtr pGC, + int mode, + int npt, + xPoint *pptInit ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit); + VGAPut_GC(); + GC_WRAP(pGC); +} + + +static void +VGAarbiterPolylines( + DrawablePtr pDraw, + GCPtr pGC, + int mode, + int npt, + DDXPointPtr pptInit ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolySegment( + DrawablePtr pDraw, + GCPtr pGC, + int nseg, + xSegment *pSeg ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolyRectangle( + DrawablePtr pDraw, + GCPtr pGC, + int nRectsInit, + xRectangle *pRectsInit ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolyArc( + DrawablePtr pDraw, + GCPtr pGC, + int narcs, + xArc *parcs ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterFillPolygon( + DrawablePtr pDraw, + GCPtr pGC, + int shape, + int mode, + int count, + DDXPointPtr ptsIn ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolyFillRect( + DrawablePtr pDraw, + GCPtr pGC, + int nrectFill, + xRectangle *prectInit) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolyFillArc( + DrawablePtr pDraw, + GCPtr pGC, + int narcs, + xArc *parcs ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static int +VGAarbiterPolyText8( + DrawablePtr pDraw, + GCPtr pGC, + int x, + int y, + int count, + char *chars ) +{ + int ret; + + GC_UNWRAP(pGC); + VGAGet_GC(); + ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars); + VGAPut_GC(); + GC_WRAP(pGC); + return ret; +} + +static int +VGAarbiterPolyText16( + DrawablePtr pDraw, + GCPtr pGC, + int x, + int y, + int count, + unsigned short *chars ) +{ + int ret; + + GC_UNWRAP(pGC); + VGAGet_GC(); + ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars); + VGAPut_GC(); + GC_WRAP(pGC); + return ret; +} + +static void +VGAarbiterImageText8( + DrawablePtr pDraw, + GCPtr pGC, + int x, + int y, + int count, + char *chars ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterImageText16( + DrawablePtr pDraw, + GCPtr pGC, + int x, + int y, + int count, + unsigned short *chars ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars); + VGAPut_GC(); + GC_WRAP(pGC); +} + + +static void +VGAarbiterImageGlyphBlt( + DrawablePtr pDraw, + GCPtr pGC, + int xInit, int yInit, + unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit, + nglyph, ppci, pglyphBase); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPolyGlyphBlt( + DrawablePtr pDraw, + GCPtr pGC, + int xInit, int yInit, + unsigned int nglyph, + CharInfoPtr *ppci, + pointer pglyphBase ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit, + nglyph, ppci, pglyphBase); + VGAPut_GC(); + GC_WRAP(pGC); +} + +static void +VGAarbiterPushPixels( + GCPtr pGC, + PixmapPtr pBitMap, + DrawablePtr pDraw, + int dx, int dy, int xOrg, int yOrg ) +{ + GC_UNWRAP(pGC); + VGAGet_GC(); + (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg); + VGAPut_GC(); + GC_WRAP(pGC); +} + + +/* miSpriteFuncs */ +static Bool +VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur) +{ + Bool val; + SPRITE_PROLOG; + VGACursorGet(); + val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur); + VGACursorPut(); + SPRITE_EPILOG; + return val; +} + +static Bool +VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur) +{ + Bool val; + SPRITE_PROLOG; + VGACursorGet(); + val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur); + VGACursorPut(); + SPRITE_EPILOG; + return val; +} + +static void +VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur, int x, int y) +{ + SPRITE_PROLOG; + VGACursorGet(); + PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y); + VGACursorPut(); + SPRITE_EPILOG; +} + +static void +VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y) +{ + SPRITE_PROLOG; + VGACursorGet(); + PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y); + VGACursorPut(); + SPRITE_EPILOG; +} + +static Bool +VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen) +{ + Bool val; + SPRITE_PROLOG; + VGACursorGet(); + val = PointPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen); + VGACursorPut(); + SPRITE_EPILOG; + return val; +} + +static void +VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen) +{ + SPRITE_PROLOG; + VGACursorGet(); + PointPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen); + VGACursorPut(); + SPRITE_EPILOG; +} + +#ifdef RENDER +static void +VGAarbiterComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, + PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, + INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, + CARD16 height) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + + PICTURE_PROLOGUE(Composite); + + VGAGet(); + (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, + yDst, width, height); + VGAPut(); + PICTURE_EPILOGUE(Composite, VGAarbiterComposite); +} + +static void +VGAarbiterGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, + PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist, + GlyphListPtr list, GlyphPtr *glyphs) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + + PICTURE_PROLOGUE(Glyphs); + + VGAGet(); + (*ps->Glyphs)(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs); + VGAPut(); + PICTURE_EPILOGUE (Glyphs, VGAarbiterGlyphs); +} + +static void +VGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color, int nRect, + xRectangle *rects) +{ + ScreenPtr pScreen = pDst->pDrawable->pScreen; + PictureScreenPtr ps = GetPictureScreen(pScreen); + + PICTURE_PROLOGUE(CompositeRects); + + VGAGet(); + (*ps->CompositeRects)(op, pDst, color, nRect, rects); + VGAPut(); + PICTURE_EPILOGUE (CompositeRects, VGAarbiterCompositeRects); +} +#endif +#else +#include "xf86VGAarbiter.h" +/* dummy functions */ +void xf86VGAarbiterInit(void) {} +void xf86VGAarbiterFini(void) {} + +void xf86VGAarbiterLock(ScrnInfoPtr pScrn) {} +void xf86VGAarbiterUnlock(ScrnInfoPtr pScrn) {} +Bool xf86VGAarbiterAllowDRI(ScreenPtr pScreen) { return TRUE; } +void xf86VGAarbiterScrnInit(ScrnInfoPtr pScrn) {} +void xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn) {} +Bool xf86VGAarbiterWrapFunctions(void) { return FALSE; } + +#endif diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h new file mode 100644 index 0000000..904b6b0 --- /dev/null +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2009 Tiago Vignatti + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef __XF86VGAARBITER_H +#define __XF86VGAARBITER_H + +#include "screenint.h" +#include "misc.h" +#include "xf86.h" + +/* Functions */ +extern void xf86VGAarbiterInit(void); +extern void xf86VGAarbiterFini(void); +void xf86VGAarbiterScrnInit(ScrnInfoPtr pScrn); +extern Bool xf86VGAarbiterWrapFunctions(void); +extern void xf86VGAarbiterLock(ScrnInfoPtr pScrn); +extern void xf86VGAarbiterUnlock(ScrnInfoPtr pScrn); + +/* allow a driver to remove itself from arbiter - really should be + * done in the kernel though */ +extern _X_EXPORT void xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn); +/* DRI and arbiter are really not possible together, + * you really want to remove the card from arbitration if you can */ +extern _X_EXPORT Bool xf86VGAarbiterAllowDRI(ScreenPtr pScreen); + +#endif /* __XF86VGAARBITER_H */ diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86pciBus.c b/xorg-server-1.6.5/hw/xfree86/common/xf86pciBus.c index 18b9782..d09ac50 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86pciBus.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86pciBus.c @@ -371,6 +371,13 @@ xf86PciProbe(void) xf86PciVideoInfo[num - 1] = info; pci_device_probe(info); +#ifdef HAVE_PCI_DEVICE_IS_BOOT_VGA + if (pci_device_is_boot_vga(info)) { + primaryBus.type = BUS_PCI; + primaryBus.id.pci = info; + } +#endif + info->user_data = 0; } } diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86str.h b/xorg-server-1.6.5/hw/xfree86/common/xf86str.h index d870868..190dfbf 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86str.h +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86str.h @@ -532,7 +532,7 @@ typedef struct _confdrirec { /* These values should be adjusted when new fields are added to ScrnInfoRec */ #define NUM_RESERVED_INTS 16 -#define NUM_RESERVED_POINTERS 15 +#define NUM_RESERVED_POINTERS 14 #define NUM_RESERVED_FUNCS 11 typedef pointer (*funcPointer)(void); @@ -967,6 +967,7 @@ typedef struct _ScrnInfoRec { int reservedInt[NUM_RESERVED_INTS]; int * entityInstanceList; + struct pci_device *vgaDev; pointer reservedPtr[NUM_RESERVED_POINTERS]; /* diff --git a/xorg-server-1.6.5/hw/xfree86/dri/dri.c b/xorg-server-1.6.5/hw/xfree86/dri/dri.c index 3c56719..12a1b31 100644 --- a/xorg-server-1.6.5/hw/xfree86/dri/dri.c +++ b/xorg-server-1.6.5/hw/xfree86/dri/dri.c @@ -71,6 +71,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "mipointer.h" #include "xf86_OSproc.h" #include "inputstr.h" +#include "xf86VGAarbiter.h" #define PCI_BUS_NO_DOMAIN(bus) ((bus) & 0xffu) @@ -335,6 +336,12 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD) return FALSE; } + if (!xf86VGAarbiterAllowDRI(pScreen)) { + DRIDrvMsg(pScreen->myNum, X_WARNING, + "Direct rendering is not supported when VGA arb is necessary for the device\n"); + return FALSE; + } + /* * If Xinerama is on, don't allow DRI to initialise. It won't be usable * anyway. diff --git a/xorg-server-1.6.5/hw/xfree86/dri2/dri2.c b/xorg-server-1.6.5/hw/xfree86/dri2/dri2.c index 3e8a7d4..9196258 100644 --- a/xorg-server-1.6.5/hw/xfree86/dri2/dri2.c +++ b/xorg-server-1.6.5/hw/xfree86/dri2/dri2.c @@ -39,6 +39,7 @@ #include "scrnintstr.h" #include "windowstr.h" #include "dri2.h" +#include "xf86VGAarbiter.h" #include "xf86.h" @@ -510,6 +511,12 @@ DRI2ScreenInit(ScreenPtr pScreen, DRI2InfoPtr info) { DRI2ScreenPtr ds; + if (!xf86VGAarbiterAllowDRI(pScreen)) { + xf86DrvMsg(pScreen->myNum, X_WARNING, + "[DRI2] Direct rendering is not supported when VGA arb is necessary for the device\n"); + return FALSE; + } + ds = xalloc(sizeof *ds); if (!ds) return FALSE; diff --git a/xorg-server-1.6.5/hw/xfree86/loader/xf86sym.c b/xorg-server-1.6.5/hw/xfree86/loader/xf86sym.c index 294fa27..ca08dc5 100644 --- a/xorg-server-1.6.5/hw/xfree86/loader/xf86sym.c +++ b/xorg-server-1.6.5/hw/xfree86/loader/xf86sym.c @@ -99,6 +99,8 @@ #include "xf86RamDac.h" #include "BT.h" +#include "xf86VGAarbiter.h" + #ifndef HAS_GLIBC_SIGSETJMP #if defined(setjmp) && defined(__GNU_LIBRARY__) && \ (!defined(__GLIBC__) || (__GLIBC__ < 2) || \ @@ -978,4 +980,13 @@ _X_HIDDEN void *xfree86LookupTab[] = { SYMFUNC(TIramdac3030SetBpp) SYMFUNC(TIramdacHWCursorInit) SYMFUNC(TIramdacLoadPalette) + + /* common/xf86VGAArbiter.c */ + SYMFUNC(xf86VGAarbiterInit) + SYMFUNC(xf86VGAarbiterFini) + SYMFUNC(xf86VGAarbiterWrapFunctions) + SYMFUNC(xf86VGAarbiterLock) + SYMFUNC(xf86VGAarbiterUnlock) + SYMFUNC(xf86VGAarbiterDeviceDecodes) + SYMFUNC(xf86VGAarbiterAllowDRI) }; diff --git a/xorg-server-1.6.5/include/xorg-config.h.in b/xorg-server-1.6.5/include/xorg-config.h.in index f9b77d0..7061e40 100644 --- a/xorg-server-1.6.5/include/xorg-config.h.in +++ b/xorg-server-1.6.5/include/xorg-config.h.in @@ -115,9 +115,15 @@ /* Have pci_system_init_dev_mem() */ #undef HAVE_PCI_SYSTEM_INIT_DEV_MEM +/* Define to 1 if you have the `pci_device_is_boot_vga' function. */ +#undef HAVE_PCI_DEVICE_IS_BOOT_VGA + /* Have pci_enable_device */ #undef HAVE_PCI_DEVICE_ENABLE +/* Define to 1 if you have the `pci_device_vgaarb_init' function. */ +#undef HAVE_PCI_DEVICE_VGAARB_INIT + /* Path to text files containing PCI IDs */ #undef PCI_TXT_IDS_PATH diff --git a/xorg-server-1.6.5/hw/xfree86/x86emu/ops2.c b/xorg-server-1.6.5/hw/xfree86/x86emu/ops2.c index 39bd041..8bf3563 100644 --- a/xorg-server-1.6.5/hw/xfree86/x86emu/ops2.c +++ b/xorg-server-1.6.5/hw/xfree86/x86emu/ops2.c @@ -2581,36 +2581,45 @@ static void x86emuOp2_movsx_word_R_RM(u8 X86EMU_UNUSED(op2)) static void x86emuOp2_bswap(u8 X86EMU_UNUSED(op2)) { START_OF_INSTR(); - DECODE_PRINTF("BSWAP\n"); + DECODE_PRINTF("BSWAP\t"); TRACE_AND_STEP(); switch (op2) { case 0xc8: + DECODE_PRINTF("EAX\n"); M.x86.R_EAX = bswap_32(M.x86.R_EAX); break; case 0xc9: + DECODE_PRINTF("ECX\n"); M.x86.R_ECX = bswap_32(M.x86.R_ECX); break; case 0xca: + DECODE_PRINTF("EDX\n"); M.x86.R_EDX = bswap_32(M.x86.R_EDX); break; case 0xcb: + DECODE_PRINTF("EBX\n"); M.x86.R_EBX = bswap_32(M.x86.R_EBX); break; case 0xcc: + DECODE_PRINTF("ESP\n"); M.x86.R_ESP = bswap_32(M.x86.R_ESP); break; case 0xcd: + DECODE_PRINTF("EBP\n"); M.x86.R_EBP = bswap_32(M.x86.R_EBP); break; case 0xce: + DECODE_PRINTF("ESI\n"); M.x86.R_ESI = bswap_32(M.x86.R_ESI); break; case 0xcf: + DECODE_PRINTF("EDI\n"); M.x86.R_EDI = bswap_32(M.x86.R_EDI); break; default: /* can't happen */ + DECODE_PRINTF("\n"); break; } diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c index 9158b2d..1880ce1 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c @@ -443,11 +443,19 @@ xf86VGAarbiterScrnInit(ScrnInfoPtr pScrn) } void -xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn) +xf86VGAarbiterSetDeviceDecodes(ScrnInfoPtr pScrn, int new_decodes) { if (vga_no_arb) return; - pci_device_vgaarb_decodes(VGA_ARB_RSRC_LEGACY_MEM | VGA_ARB_RSRC_LEGACY_IO); + if (pci_device_vgaarb_set_target(pScrn->vgaDev) == 0) + pci_device_vgaarb_decodes(new_decodes); +} + +void +xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn) +{ + xf86VGAarbiterSetDeviceDecodes(pScrn, + VGA_ARB_RSRC_LEGACY_IO | VGA_ARB_RSRC_LEGACY_MEM); } Bool diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h index 904b6b0..9417ad1 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.h @@ -41,6 +41,7 @@ extern void xf86VGAarbiterUnlock(ScrnInfoPtr pScrn); /* allow a driver to remove itself from arbiter - really should be * done in the kernel though */ extern _X_EXPORT void xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn); +extern _X_EXPORT void xf86VGAarbiterSetDeviceDecodes(ScrnInfoPtr pScrn, int decodes); /* DRI and arbiter are really not possible together, * you really want to remove the card from arbitration if you can */ extern _X_EXPORT Bool xf86VGAarbiterAllowDRI(ScreenPtr pScreen); diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c index 1880ce1..aa1c020 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c @@ -194,6 +194,7 @@ typedef struct _VGAarbiterScreen { GetImageProcPtr GetImage; GetSpansProcPtr GetSpans; SourceValidateProcPtr SourceValidate; + ChangeWindowAttributesProcPtr ChangeWindowAttributes; CopyWindowProcPtr CopyWindow; ClearToBackgroundProcPtr ClearToBackground; CreatePixmapProcPtr CreatePixmap; @@ -211,6 +212,7 @@ typedef struct _VGAarbiterScreen { Bool (*EnterVT)(int, int); void (*LeaveVT)(int, int); void (*FreeScreen)(int, int); + void (*LoadPalette)(ScrnInfoPtr, int, int *, LOCO *, VisualPtr); miPointerSpriteFuncPtr miSprite; #ifdef RENDER CompositeProcPtr Composite; @@ -234,6 +236,8 @@ static void VGAarbiterGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart); static void VGAarbiterSourceValidate (DrawablePtr pDrawable, int x, int y, int width, int height); +static Bool VGAarbiterChangeWindowAttributes(WindowPtr pWin, + unsigned long mask); static void VGAarbiterCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); static void VGAarbiterClearToBackground (WindowPtr pWin, int x, int y, int w, @@ -259,7 +263,7 @@ static Bool VGAarbiterSwitchMode(int index, DisplayModePtr mode, int flags); static Bool VGAarbiterEnterVT(int index, int flags); static void VGAarbiterLeaveVT(int index, int flags); static void VGAarbiterFreeScreen(int index, int flags); - +static void VGAarbiterLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual); /* GC funcs */ static void VGAarbiterValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw); @@ -508,6 +512,7 @@ xf86VGAarbiterWrapFunctions(void) WRAP_SCREEN(GetImage, VGAarbiterGetImage); WRAP_SCREEN(GetSpans, VGAarbiterGetSpans); WRAP_SCREEN(SourceValidate, VGAarbiterSourceValidate); + WRAP_SCREEN(ChangeWindowAttributes, VGAarbiterChangeWindowAttributes); WRAP_SCREEN(CopyWindow, VGAarbiterCopyWindow); WRAP_SCREEN(ClearToBackground, VGAarbiterClearToBackground); WRAP_SCREEN(CreatePixmap, VGAarbiterCreatePixmap); @@ -527,6 +532,7 @@ xf86VGAarbiterWrapFunctions(void) WRAP_SCREEN_INFO(EnterVT, VGAarbiterEnterVT); WRAP_SCREEN_INFO(LeaveVT, VGAarbiterLeaveVT); WRAP_SCREEN_INFO(FreeScreen, VGAarbiterFreeScreen); + WRAP_SCREEN_INFO(LoadPalette, VGAarbiterLoadPalette); WRAP_SPRITE; } @@ -552,6 +558,7 @@ VGAarbiterCloseScreen (int i, ScreenPtr pScreen) UNWRAP_SCREEN(GetImage); UNWRAP_SCREEN(GetSpans); UNWRAP_SCREEN(SourceValidate); + UNWRAP_SCREEN(ChangeWindowAttributes); UNWRAP_SCREEN(CopyWindow); UNWRAP_SCREEN(ClearToBackground); UNWRAP_SCREEN(SaveScreen); @@ -571,6 +578,7 @@ VGAarbiterCloseScreen (int i, ScreenPtr pScreen) UNWRAP_SCREEN_INFO(EnterVT); UNWRAP_SCREEN_INFO(LeaveVT); UNWRAP_SCREEN_INFO(FreeScreen); + UNWRAP_SCREEN_INFO(LoadPalette); UNWRAP_SPRITE; xfree ((pointer) pScreenPriv); @@ -656,6 +664,23 @@ VGAarbiterSourceValidate ( SCREEN_EPILOG (SourceValidate, VGAarbiterSourceValidate); } +static Bool +VGAarbiterChangeWindowAttributes( + WindowPtr pWin, + unsigned long mask) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + Bool ret; + + SCREEN_PROLOG (ChangeWindowAttributes); + VGAGet(); + ret = (*pScreen->ChangeWindowAttributes) (pWin, mask); + VGAPut(); + SCREEN_EPILOG (ChangeWindowAttributes, VGAarbiterChangeWindowAttributes); + + return ret; +} + static void VGAarbiterCopyWindow( WindowPtr pWin, @@ -877,6 +902,18 @@ VGAarbiterFreeScreen(int index, int flags) VGAPut(); } +static void +VGAarbiterLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, LOCO *colors, VisualPtr pVisual) +{ + ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex]; + VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate( + &pScreen->devPrivates, VGAarbiterScreenKey); + + VGAGet(); + (*pScreenPriv->LoadPalette)(pScrn, numColors, indices, colors, pVisual); + VGAPut(); +} + static Bool VGAarbiterCreateGC(GCPtr pGC) { From: Egbert Eich Author: Egbert Eich Date: Mon, 29 Aug 2011 12:57:57 +0200 Patch-Mainline: "To be upstreamed" Subject: [PATCH] VGA arbiter: Properly restore configuration on VT switch/termination. Call VGAarbitrationFini() on VT switch to properly reenable default device. Signed-off-by: Egbert Eich --- xorg-server-1.6.5/hw/xfree86/common/xf86Events.c | 5 ++++- .../hw/xfree86/common/xf86VGAarbiter.c | 8 +++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86Events.c b/xorg-server-1.6.5/hw/xfree86/common/xf86Events.c index e177b0e..42da87c 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86Events.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86Events.c @@ -72,6 +72,7 @@ #include #include "inputstr.h" #include "xf86Xinput.h" +#include "xf86VGAarbiter.h" #include "mi.h" #include "mipointer.h" @@ -540,7 +541,7 @@ xf86VTSwitch() xf86AccessLeave(); /* We need this here, otherwise */ xf86AccessLeaveState(); /* console won't be restored */ - + xf86VGAarbiterFini(); if (!xf86VTSwitchAway()) { /* * switch failed @@ -550,6 +551,7 @@ xf86VTSwitch() ErrorF("xf86VTSwitch: Leave failed\n"); #endif prevSIGIO = xf86BlockSIGIO(); + xf86VGAarbiterInit(); xf86AccessEnter(); xf86EnterServerState(SETUP); for (i = 0; i < xf86NumScreens; i++) { @@ -623,6 +625,7 @@ xf86VTSwitch() if (xorgHWAccess) xf86EnableIO(); + xf86VGAarbiterInit(); xf86AccessEnter(); xf86EnterServerState(SETUP); for (i = 0; i < xf86NumScreens; i++) { diff --git a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c index aa1c020..48e0941 100644 --- a/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c +++ b/xorg-server-1.6.5/hw/xfree86/common/xf86VGAarbiter.c @@ -370,13 +370,14 @@ static DevPrivateKey VGAarbiterScreenKey = &VGAarbiterKeyIndex; static int VGAarbiterGCIndex; static DevPrivateKey VGAarbiterGCKey = &VGAarbiterGCIndex; -static int vga_no_arb = 0; +static int vga_no_arb = 1; static struct pci_device *currVgaLock = NULL; static int currVgaLockCnt = 0; void xf86VGAarbiterInit(void) { + vga_no_arb = 0; if (pci_device_vgaarb_init() != 0) { vga_no_arb = 1; xf86Msg(X_WARNING, "VGA arbiter: cannot open kernel arbiter, no multi-card support\n"); @@ -386,9 +387,14 @@ xf86VGAarbiterInit(void) void xf86VGAarbiterFini(void) { + int sigiostate; if (vga_no_arb) return; + + sigiostate = xf86BlockSIGIO(); pci_device_vgaarb_fini(); + xf86UnblockSIGIO(sigiostate); + vga_no_arb = 1; /* vgaarb has been deinitialized */ } void -- 1.7.3.4