hw/xfree86/common/xf86VGAarbiter.c

   1 /*
   2  * This code was stolen from RAC and adapted to control the legacy vga
   3  * interface.
   4  *
   5  *
   6  * Copyright (c) 2007 Paulo R. Zanoni, Tiago Vignatti
   7  *
   8  * Permission is hereby granted, free of charge, to any person
   9  * obtaining a copy of this software and associated documentation
  10  * files (the "Software"), to deal in the Software without
  11  * restriction, including without limitation the rights to use,
  12  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following
  15  * conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  22  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  24  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  25  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  26  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  27  * OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29  */
  30
  31 #include "xorg-config.h"
  32
  33 #include "xf86VGAarbiter.h"
  34 #include "xf86VGAarbiterPriv.h"
  35 #include "xf86Bus.h"
  36 #include "xf86Priv.h"
  37 #include "pciaccess.h"
  38
  39 static GCFuncs VGAarbiterGCFuncs = {
  40     VGAarbiterValidateGC, VGAarbiterChangeGC, VGAarbiterCopyGC,
  41     VGAarbiterDestroyGC, VGAarbiterChangeClip, VGAarbiterDestroyClip,
  42     VGAarbiterCopyClip
  43 };
  44
  45 static GCOps VGAarbiterGCOps = {
  46     VGAarbiterFillSpans, VGAarbiterSetSpans, VGAarbiterPutImage,
  47     VGAarbiterCopyArea, VGAarbiterCopyPlane, VGAarbiterPolyPoint,
  48     VGAarbiterPolylines, VGAarbiterPolySegment, VGAarbiterPolyRectangle,
  49     VGAarbiterPolyArc, VGAarbiterFillPolygon, VGAarbiterPolyFillRect,
  50     VGAarbiterPolyFillArc, VGAarbiterPolyText8, VGAarbiterPolyText16,
  51     VGAarbiterImageText8, VGAarbiterImageText16, VGAarbiterImageGlyphBlt,
  52     VGAarbiterPolyGlyphBlt, VGAarbiterPushPixels,
  53 };
  54
  55 static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = {
  56     VGAarbiterSpriteRealizeCursor, VGAarbiterSpriteUnrealizeCursor,
  57     VGAarbiterSpriteSetCursor, VGAarbiterSpriteMoveCursor,
  58     VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup
  59 };
  60
  61 static DevPrivateKeyRec VGAarbiterScreenKeyRec;
  62
  63 #define VGAarbiterScreenKey (&VGAarbiterScreenKeyRec)
  64 static DevPrivateKeyRec VGAarbiterGCKeyRec;
  65
  66 #define VGAarbiterGCKey (&VGAarbiterGCKeyRec)
  67
  68 static int vga_no_arb = 0;
  69 void
  70 xf86VGAarbiterInit(void)
  71 {
  72     if (pci_device_vgaarb_init() != 0) {
  73         vga_no_arb = 1;
  74         xf86Msg(X_WARNING,
  75                 "VGA arbiter: cannot open kernel arbiter, no multi-card support\n");
  76     }
  77 }
  78
  79 void
  80 xf86VGAarbiterFini(void)
  81 {
  82     if (vga_no_arb)
  83         return;
  84     pci_device_vgaarb_fini();
  85 }
  86
  87 void
  88 xf86VGAarbiterLock(ScrnInfoPtr pScrn)
  89 {
  90     if (vga_no_arb)
  91         return;
  92     pci_device_vgaarb_set_target(pScrn->vgaDev);
  93     pci_device_vgaarb_lock();
  94 }
  95
  96 void
  97 xf86VGAarbiterUnlock(ScrnInfoPtr pScrn)
  98 {
  99     if (vga_no_arb)
 100         return;
 101     pci_device_vgaarb_unlock();
 102 }
 103
 104 Bool
 105 xf86VGAarbiterAllowDRI(ScreenPtr pScreen)
 106 {
 107     int vga_count;
 108     int rsrc_decodes;
 109     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 110
 111     if (vga_no_arb)
 112         return TRUE;
 113
 114     pci_device_vgaarb_get_info(pScrn->vgaDev, &vga_count, &rsrc_decodes);
 115     if (vga_count > 1) {
 116         if (rsrc_decodes) {
 117             return FALSE;
 118         }
 119     }
 120     return TRUE;
 121 }
 122
 123 void
 124 xf86VGAarbiterScrnInit(ScrnInfoPtr pScrn)
 125 {
 126     struct pci_device *dev;
 127     EntityPtr pEnt;
 128
 129     if (vga_no_arb)
 130         return;
 131
 132     pEnt = xf86Entities[pScrn->entityList[0]];
 133     if (pEnt->bus.type != BUS_PCI)
 134         return;
 135
 136     dev = pEnt->bus.id.pci;
 137     pScrn->vgaDev = dev;
 138 }
 139
 140 void
 141 xf86VGAarbiterDeviceDecodes(ScrnInfoPtr pScrn, int rsrc)
 142 {
 143     if (vga_no_arb)
 144         return;
 145     pci_device_vgaarb_set_target(pScrn->vgaDev);
 146     pci_device_vgaarb_decodes(rsrc);
 147 }
 148
 149 Bool
 150 xf86VGAarbiterWrapFunctions(void)
 151 {
 152     ScrnInfoPtr pScrn;
 153     VGAarbiterScreenPtr pScreenPriv;
 154     miPointerScreenPtr PointPriv;
 155     PictureScreenPtr ps;
 156     ScreenPtr pScreen;
 157     int vga_count, i;
 158
 159     if (vga_no_arb)
 160         return FALSE;
 161
 162     /*
 163      * we need to wrap the arbiter if we have more than
 164      * one VGA card - hotplug cries.
 165      */
 166     pci_device_vgaarb_get_info(NULL, &vga_count, NULL);
 167     if (vga_count < 2 || !xf86Screens)
 168         return FALSE;
 169
 170     xf86Msg(X_INFO, "Found %d VGA devices: arbiter wrapping enabled\n",
 171             vga_count);
 172
 173     for (i = 0; i < xf86NumScreens; i++) {
 174         pScreen = xf86Screens[i]->pScreen;
 175         ps = GetPictureScreenIfSet(pScreen);
 176         pScrn = xf86Screens[pScreen->myNum];
 177         PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);
 178
 179         if (!dixRegisterPrivateKey
 180             (&VGAarbiterGCKeyRec, PRIVATE_GC, sizeof(VGAarbiterGCRec)))
 181             return FALSE;
 182
 183         if (!dixRegisterPrivateKey(&VGAarbiterScreenKeyRec, PRIVATE_SCREEN, 0))
 184             return FALSE;
 185
 186         if (!(pScreenPriv = malloc(sizeof(VGAarbiterScreenRec))))
 187             return FALSE;
 188
 189         dixSetPrivate(&pScreen->devPrivates, VGAarbiterScreenKey, pScreenPriv);
 190
 191         WRAP_SCREEN(CloseScreen, VGAarbiterCloseScreen);
 192         WRAP_SCREEN(SaveScreen, VGAarbiterSaveScreen);
 193         WRAP_SCREEN(WakeupHandler, VGAarbiterWakeupHandler);
 194         WRAP_SCREEN(BlockHandler, VGAarbiterBlockHandler);
 195         WRAP_SCREEN(CreateGC, VGAarbiterCreateGC);
 196         WRAP_SCREEN(GetImage, VGAarbiterGetImage);
 197         WRAP_SCREEN(GetSpans, VGAarbiterGetSpans);
 198         WRAP_SCREEN(SourceValidate, VGAarbiterSourceValidate);
 199         WRAP_SCREEN(CopyWindow, VGAarbiterCopyWindow);
 200         WRAP_SCREEN(ClearToBackground, VGAarbiterClearToBackground);
 201         WRAP_SCREEN(CreatePixmap, VGAarbiterCreatePixmap);
 202         WRAP_SCREEN(StoreColors, VGAarbiterStoreColors);
 203         WRAP_SCREEN(DisplayCursor, VGAarbiterDisplayCursor);
 204         WRAP_SCREEN(RealizeCursor, VGAarbiterRealizeCursor);
 205         WRAP_SCREEN(UnrealizeCursor, VGAarbiterUnrealizeCursor);
 206         WRAP_SCREEN(RecolorCursor, VGAarbiterRecolorCursor);
 207         WRAP_SCREEN(SetCursorPosition, VGAarbiterSetCursorPosition);
 208         WRAP_PICT(Composite, VGAarbiterComposite);
 209         WRAP_PICT(Glyphs, VGAarbiterGlyphs);
 210         WRAP_PICT(CompositeRects, VGAarbiterCompositeRects);
 211         WRAP_SCREEN_INFO(AdjustFrame, VGAarbiterAdjustFrame);
 212         WRAP_SCREEN_INFO(SwitchMode, VGAarbiterSwitchMode);
 213         WRAP_SCREEN_INFO(EnterVT, VGAarbiterEnterVT);
 214         WRAP_SCREEN_INFO(LeaveVT, VGAarbiterLeaveVT);
 215         WRAP_SCREEN_INFO(FreeScreen, VGAarbiterFreeScreen);
 216         WRAP_SPRITE;
 217     }
 218
 219     return TRUE;
 220 }
 221
 222 /* Screen funcs */
 223 static Bool
 224 VGAarbiterCloseScreen(int i, ScreenPtr pScreen)
 225 {
 226     Bool val;
 227     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 228     VGAarbiterScreenPtr pScreenPriv =
 229         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 230                                                VGAarbiterScreenKey);
 231     miPointerScreenPtr PointPriv =
 232         (miPointerScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 233                                               miPointerScreenKey);
 234     PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
 235
 236     UNWRAP_SCREEN(CreateGC);
 237     UNWRAP_SCREEN(CloseScreen);
 238     UNWRAP_SCREEN(GetImage);
 239     UNWRAP_SCREEN(GetSpans);
 240     UNWRAP_SCREEN(SourceValidate);
 241     UNWRAP_SCREEN(CopyWindow);
 242     UNWRAP_SCREEN(ClearToBackground);
 243     UNWRAP_SCREEN(SaveScreen);
 244     UNWRAP_SCREEN(StoreColors);
 245     UNWRAP_SCREEN(DisplayCursor);
 246     UNWRAP_SCREEN(RealizeCursor);
 247     UNWRAP_SCREEN(UnrealizeCursor);
 248     UNWRAP_SCREEN(RecolorCursor);
 249     UNWRAP_SCREEN(SetCursorPosition);
 250     UNWRAP_PICT(Composite);
 251     UNWRAP_PICT(Glyphs);
 252     UNWRAP_PICT(CompositeRects);
 253     UNWRAP_SCREEN_INFO(AdjustFrame);
 254     UNWRAP_SCREEN_INFO(SwitchMode);
 255     UNWRAP_SCREEN_INFO(EnterVT);
 256     UNWRAP_SCREEN_INFO(LeaveVT);
 257     UNWRAP_SCREEN_INFO(FreeScreen);
 258     UNWRAP_SPRITE;
 259
 260     free((pointer) pScreenPriv);
 261     xf86VGAarbiterLock(xf86Screens[i]);
 262     val = (*pScreen->CloseScreen) (i, pScreen);
 263     xf86VGAarbiterUnlock(xf86Screens[i]);
 264     return val;
 265 }
 266
 267 static void
 268 VGAarbiterBlockHandler(int i,
 269                        pointer blockData, pointer pTimeout, pointer pReadmask)
 270 {
 271     ScreenPtr pScreen = screenInfo.screens[i];
 272
 273     SCREEN_PROLOG(BlockHandler);
 274     VGAGet(pScreen);
 275     pScreen->BlockHandler(i, blockData, pTimeout, pReadmask);
 276     VGAPut();
 277     SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler);
 278 }
 279
 280 static void
 281 VGAarbiterWakeupHandler(int i, pointer blockData, unsigned long result,
 282                         pointer pReadmask)
 283 {
 284     ScreenPtr pScreen = screenInfo.screens[i];
 285
 286     SCREEN_PROLOG(WakeupHandler);
 287     VGAGet(pScreen);
 288     pScreen->WakeupHandler(i, blockData, result, pReadmask);
 289     VGAPut();
 290     SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler);
 291 }
 292
 293 static void
 294 VGAarbiterGetImage(DrawablePtr pDrawable,
 295                    int sx, int sy, int w, int h,
 296                    unsigned int format, unsigned long planemask, char *pdstLine)
 297 {
 298     ScreenPtr pScreen = pDrawable->pScreen;
 299
 300     SCREEN_PROLOG(GetImage);
 301 //    if (xf86Screens[pScreen->myNum]->vtSema) {
 302     VGAGet(pScreen);
 303 //    }
 304     (*pScreen->GetImage) (pDrawable, sx, sy, w, h, format, planemask, pdstLine);
 305     VGAPut();
 306     SCREEN_EPILOG(GetImage, VGAarbiterGetImage);
 307 }
 308
 309 static void
 310 VGAarbiterGetSpans(DrawablePtr pDrawable,
 311                    int wMax,
 312                    DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
 313 {
 314     ScreenPtr pScreen = pDrawable->pScreen;
 315
 316     SCREEN_PROLOG(GetSpans);
 317     VGAGet(pScreen);
 318     (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
 319     VGAPut();
 320     SCREEN_EPILOG(GetSpans, VGAarbiterGetSpans);
 321 }
 322
 323 static void
 324 VGAarbiterSourceValidate(DrawablePtr pDrawable,
 325                          int x, int y, int width, int height,
 326                          unsigned int subWindowMode)
 327 {
 328     ScreenPtr pScreen = pDrawable->pScreen;
 329
 330     SCREEN_PROLOG(SourceValidate);
 331     VGAGet(pScreen);
 332     if (pScreen->SourceValidate)
 333         (*pScreen->SourceValidate) (pDrawable, x, y, width, height,
 334                                     subWindowMode);
 335     VGAPut();
 336     SCREEN_EPILOG(SourceValidate, VGAarbiterSourceValidate);
 337 }
 338
 339 static void
 340 VGAarbiterCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 341 {
 342     ScreenPtr pScreen = pWin->drawable.pScreen;
 343
 344     SCREEN_PROLOG(CopyWindow);
 345     VGAGet(pScreen);
 346     (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
 347     VGAPut();
 348     SCREEN_EPILOG(CopyWindow, VGAarbiterCopyWindow);
 349 }
 350
 351 static void
 352 VGAarbiterClearToBackground(WindowPtr pWin,
 353                             int x, int y, int w, int h, Bool generateExposures)
 354 {
 355     ScreenPtr pScreen = pWin->drawable.pScreen;
 356
 357     SCREEN_PROLOG(ClearToBackground);
 358     VGAGet(pScreen);
 359     (*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures);
 360     VGAPut();
 361     SCREEN_EPILOG(ClearToBackground, VGAarbiterClearToBackground);
 362 }
 363
 364 static PixmapPtr
 365 VGAarbiterCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
 366                        unsigned usage_hint)
 367 {
 368     PixmapPtr pPix;
 369
 370     SCREEN_PROLOG(CreatePixmap);
 371     VGAGet(pScreen);
 372     pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint);
 373     VGAPut();
 374     SCREEN_EPILOG(CreatePixmap, VGAarbiterCreatePixmap);
 375
 376     return pPix;
 377 }
 378
 379 static Bool
 380 VGAarbiterSaveScreen(ScreenPtr pScreen, Bool unblank)
 381 {
 382     Bool val;
 383
 384     SCREEN_PROLOG(SaveScreen);
 385     VGAGet(pScreen);
 386     val = (*pScreen->SaveScreen) (pScreen, unblank);
 387     VGAPut();
 388     SCREEN_EPILOG(SaveScreen, VGAarbiterSaveScreen);
 389
 390     return val;
 391 }
 392
 393 static void
 394 VGAarbiterStoreColors(ColormapPtr pmap, int ndef, xColorItem * pdefs)
 395 {
 396     ScreenPtr pScreen = pmap->pScreen;
 397
 398     SCREEN_PROLOG(StoreColors);
 399     VGAGet(pScreen);
 400     (*pScreen->StoreColors) (pmap, ndef, pdefs);
 401     VGAPut();
 402     SCREEN_EPILOG(StoreColors, VGAarbiterStoreColors);
 403 }
 404
 405 static void
 406 VGAarbiterRecolorCursor(DeviceIntPtr pDev,
 407                         ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
 408 {
 409     SCREEN_PROLOG(RecolorCursor);
 410     VGAGet(pScreen);
 411     (*pScreen->RecolorCursor) (pDev, pScreen, pCurs, displayed);
 412     VGAPut();
 413     SCREEN_EPILOG(RecolorCursor, VGAarbiterRecolorCursor);
 414 }
 415
 416 static Bool
 417 VGAarbiterRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 418 {
 419     Bool val;
 420
 421     SCREEN_PROLOG(RealizeCursor);
 422     VGAGet(pScreen);
 423     val = (*pScreen->RealizeCursor) (pDev, pScreen, pCursor);
 424     VGAPut();
 425     SCREEN_EPILOG(RealizeCursor, VGAarbiterRealizeCursor);
 426     return val;
 427 }
 428
 429 static Bool
 430 VGAarbiterUnrealizeCursor(DeviceIntPtr pDev,
 431                           ScreenPtr pScreen, CursorPtr pCursor)
 432 {
 433     Bool val;
 434
 435     SCREEN_PROLOG(UnrealizeCursor);
 436     VGAGet(pScreen);
 437     val = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);
 438     VGAPut();
 439     SCREEN_EPILOG(UnrealizeCursor, VGAarbiterUnrealizeCursor);
 440     return val;
 441 }
 442
 443 static Bool
 444 VGAarbiterDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
 445 {
 446     Bool val;
 447
 448     SCREEN_PROLOG(DisplayCursor);
 449     VGAGet(pScreen);
 450     val = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
 451     VGAPut();
 452     SCREEN_EPILOG(DisplayCursor, VGAarbiterDisplayCursor);
 453     return val;
 454 }
 455
 456 static Bool
 457 VGAarbiterSetCursorPosition(DeviceIntPtr pDev,
 458                             ScreenPtr pScreen, int x, int y, Bool generateEvent)
 459 {
 460     Bool val;
 461
 462     SCREEN_PROLOG(SetCursorPosition);
 463     VGAGet(pScreen);
 464     val = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);
 465     VGAPut();
 466     SCREEN_EPILOG(SetCursorPosition, VGAarbiterSetCursorPosition);
 467     return val;
 468 }
 469
 470 static void
 471 VGAarbiterAdjustFrame(int index, int x, int y, int flags)
 472 {
 473     ScreenPtr pScreen = screenInfo.screens[index];
 474     VGAarbiterScreenPtr pScreenPriv =
 475         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 476                                                VGAarbiterScreenKey);
 477
 478     VGAGet(pScreen);
 479     (*pScreenPriv->AdjustFrame) (index, x, y, flags);
 480     VGAPut();
 481 }
 482
 483 static Bool
 484 VGAarbiterSwitchMode(int index, DisplayModePtr mode, int flags)
 485 {
 486     Bool val;
 487     ScreenPtr pScreen = screenInfo.screens[index];
 488     VGAarbiterScreenPtr pScreenPriv =
 489         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 490                                                VGAarbiterScreenKey);
 491
 492     VGAGet(pScreen);
 493     val = (*pScreenPriv->SwitchMode) (index, mode, flags);
 494     VGAPut();
 495     return val;
 496 }
 497
 498 static Bool
 499 VGAarbiterEnterVT(int index, int flags)
 500 {
 501     Bool val;
 502     ScrnInfoPtr pScrn = xf86Screens[index];
 503     ScreenPtr pScreen = screenInfo.screens[index];
 504     VGAarbiterScreenPtr pScreenPriv =
 505         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 506                                                VGAarbiterScreenKey);
 507
 508     VGAGet(pScreen);
 509     pScrn->EnterVT = pScreenPriv->EnterVT;
 510     val = (*pScrn->EnterVT) (index, flags);
 511     pScreenPriv->EnterVT = pScrn->EnterVT;
 512     pScrn->EnterVT = VGAarbiterEnterVT;
 513     VGAPut();
 514     return val;
 515 }
 516
 517 static void
 518 VGAarbiterLeaveVT(int index, int flags)
 519 {
 520     ScrnInfoPtr pScrn = xf86Screens[index];
 521     ScreenPtr pScreen = screenInfo.screens[index];
 522     VGAarbiterScreenPtr pScreenPriv =
 523         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 524                                                VGAarbiterScreenKey);
 525
 526     VGAGet(pScreen);
 527     pScrn->LeaveVT = pScreenPriv->LeaveVT;
 528     (*pScreenPriv->LeaveVT) (index, flags);
 529     pScreenPriv->LeaveVT = pScrn->LeaveVT;
 530     pScrn->LeaveVT = VGAarbiterLeaveVT;
 531     VGAPut();
 532 }
 533
 534 static void
 535 VGAarbiterFreeScreen(int index, int flags)
 536 {
 537     ScreenPtr pScreen = screenInfo.screens[index];
 538     VGAarbiterScreenPtr pScreenPriv =
 539         (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
 540                                                VGAarbiterScreenKey);
 541
 542     VGAGet(pScreen);
 543     (*pScreenPriv->FreeScreen) (index, flags);
 544     VGAPut();
 545 }
 546
 547 static Bool
 548 VGAarbiterCreateGC(GCPtr pGC)
 549 {
 550     ScreenPtr pScreen = pGC->pScreen;
 551     VGAarbiterGCPtr pGCPriv =
 552         (VGAarbiterGCPtr) dixLookupPrivate(&pGC->devPrivates, VGAarbiterGCKey);
 553     Bool ret;
 554
 555     SCREEN_PROLOG(CreateGC);
 556     ret = (*pScreen->CreateGC) (pGC);
 557     GC_WRAP(pGC);
 558     SCREEN_EPILOG(CreateGC, VGAarbiterCreateGC);
 559
 560     return ret;
 561 }
 562
 563 /* GC funcs */
 564 static void
 565 VGAarbiterValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
 566 {
 567     GC_UNWRAP(pGC);
 568     (*pGC->funcs->ValidateGC) (pGC, changes, pDraw);
 569     GC_WRAP(pGC);
 570 }
 571
 572 static void
 573 VGAarbiterDestroyGC(GCPtr pGC)
 574 {
 575     GC_UNWRAP(pGC);
 576     (*pGC->funcs->DestroyGC) (pGC);
 577     GC_WRAP(pGC);
 578 }
 579
 580 static void
 581 VGAarbiterChangeGC(GCPtr pGC, unsigned long mask)
 582 {
 583     GC_UNWRAP(pGC);
 584     (*pGC->funcs->ChangeGC) (pGC, mask);
 585     GC_WRAP(pGC);
 586 }
 587
 588 static void
 589 VGAarbiterCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
 590 {
 591     GC_UNWRAP(pGCDst);
 592     (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
 593     GC_WRAP(pGCDst);
 594 }
 595
 596 static void
 597 VGAarbiterChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
 598 {
 599     GC_UNWRAP(pGC);
 600     (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
 601     GC_WRAP(pGC);
 602 }
 603
 604 static void
 605 VGAarbiterCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
 606 {
 607     GC_UNWRAP(pgcDst);
 608     (*pgcDst->funcs->CopyClip) (pgcDst, pgcSrc);
 609     GC_WRAP(pgcDst);
 610 }
 611
 612 static void
 613 VGAarbiterDestroyClip(GCPtr pGC)
 614 {
 615     GC_UNWRAP(pGC);
 616     (*pGC->funcs->DestroyClip) (pGC);
 617     GC_WRAP(pGC);
 618 }
 619
 620 /* GC Ops */
 621 static void
 622 VGAarbiterFillSpans(DrawablePtr pDraw,
 623                     GC * pGC,
 624                     int nInit,
 625                     DDXPointPtr pptInit, int *pwidthInit, int fSorted)
 626 {
 627     ScreenPtr pScreen = pGC->pScreen;
 628
 629     GC_UNWRAP(pGC);
 630     VGAGet(pScreen);
 631     (*pGC->ops->FillSpans) (pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
 632     VGAPut();
 633     GC_WRAP(pGC);
 634 }
 635
 636 static void
 637 VGAarbiterSetSpans(DrawablePtr pDraw,
 638                    GCPtr pGC,
 639                    char *pcharsrc,
 640                    register DDXPointPtr ppt,
 641                    int *pwidth, int nspans, int fSorted)
 642 {
 643     ScreenPtr pScreen = pGC->pScreen;
 644
 645     GC_UNWRAP(pGC);
 646     VGAGet(pScreen);
 647     (*pGC->ops->SetSpans) (pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
 648     VGAPut();
 649     GC_WRAP(pGC);
 650 }
 651
 652 static void
 653 VGAarbiterPutImage(DrawablePtr pDraw,
 654                    GCPtr pGC,
 655                    int depth,
 656                    int x, int y, int w, int h,
 657                    int leftPad, int format, char *pImage)
 658 {
 659     ScreenPtr pScreen = pGC->pScreen;
 660
 661     GC_UNWRAP(pGC);
 662     VGAGet(pScreen);
 663     (*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
 664                            leftPad, format, pImage);
 665     VGAPut();
 666     GC_WRAP(pGC);
 667 }
 668
 669 static RegionPtr
 670 VGAarbiterCopyArea(DrawablePtr pSrc,
 671                    DrawablePtr pDst,
 672                    GC * pGC,
 673                    int srcx, int srcy,
 674                    int width, int height, int dstx, int dsty)
 675 {
 676     RegionPtr ret;
 677     ScreenPtr pScreen = pGC->pScreen;
 678
 679     GC_UNWRAP(pGC);
 680     VGAGet(pScreen);
 681     ret = (*pGC->ops->CopyArea) (pSrc, pDst,
 682                                  pGC, srcx, srcy, width, height, dstx, dsty);
 683     VGAPut();
 684     GC_WRAP(pGC);
 685     return ret;
 686 }
 687
 688 static RegionPtr
 689 VGAarbiterCopyPlane(DrawablePtr pSrc,
 690                     DrawablePtr pDst,
 691                     GCPtr pGC,
 692                     int srcx, int srcy,
 693                     int width, int height,
 694                     int dstx, int dsty, unsigned long bitPlane)
 695 {
 696     RegionPtr ret;
 697     ScreenPtr pScreen = pGC->pScreen;
 698
 699     GC_UNWRAP(pGC);
 700     VGAGet(pScreen);
 701     ret = (*pGC->ops->CopyPlane) (pSrc, pDst, pGC, srcx, srcy,
 702                                   width, height, dstx, dsty, bitPlane);
 703     VGAPut();
 704     GC_WRAP(pGC);
 705     return ret;
 706 }
 707
 708 static void
 709 VGAarbiterPolyPoint(DrawablePtr pDraw,
 710                     GCPtr pGC, int mode, int npt, xPoint * pptInit)
 711 {
 712     ScreenPtr pScreen = pGC->pScreen;
 713
 714     GC_UNWRAP(pGC);
 715     VGAGet(pScreen);
 716     (*pGC->ops->PolyPoint) (pDraw, pGC, mode, npt, pptInit);
 717     VGAPut();
 718     GC_WRAP(pGC);
 719 }
 720
 721 static void
 722 VGAarbiterPolylines(DrawablePtr pDraw,
 723                     GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
 724 {
 725     ScreenPtr pScreen = pGC->pScreen;
 726
 727     GC_UNWRAP(pGC);
 728     VGAGet(pScreen);
 729     (*pGC->ops->Polylines) (pDraw, pGC, mode, npt, pptInit);
 730     VGAPut();
 731     GC_WRAP(pGC);
 732 }
 733
 734 static void
 735 VGAarbiterPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment * pSeg)
 736 {
 737     ScreenPtr pScreen = pGC->pScreen;
 738
 739     GC_UNWRAP(pGC);
 740     VGAGet(pScreen);
 741     (*pGC->ops->PolySegment) (pDraw, pGC, nseg, pSeg);
 742     VGAPut();
 743     GC_WRAP(pGC);
 744 }
 745
 746 static void
 747 VGAarbiterPolyRectangle(DrawablePtr pDraw,
 748                         GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
 749 {
 750     ScreenPtr pScreen = pGC->pScreen;
 751
 752     GC_UNWRAP(pGC);
 753     VGAGet(pScreen);
 754     (*pGC->ops->PolyRectangle) (pDraw, pGC, nRectsInit, pRectsInit);
 755     VGAPut();
 756     GC_WRAP(pGC);
 757 }
 758
 759 static void
 760 VGAarbiterPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
 761 {
 762     ScreenPtr pScreen = pGC->pScreen;
 763
 764     GC_UNWRAP(pGC);
 765     VGAGet(pScreen);
 766     (*pGC->ops->PolyArc) (pDraw, pGC, narcs, parcs);
 767     VGAPut();
 768     GC_WRAP(pGC);
 769 }
 770
 771 static void
 772 VGAarbiterFillPolygon(DrawablePtr pDraw,
 773                       GCPtr pGC,
 774                       int shape, int mode, int count, DDXPointPtr ptsIn)
 775 {
 776     ScreenPtr pScreen = pGC->pScreen;
 777
 778     GC_UNWRAP(pGC);
 779     VGAGet(pScreen);
 780     (*pGC->ops->FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
 781     VGAPut();
 782     GC_WRAP(pGC);
 783 }
 784
 785 static void
 786 VGAarbiterPolyFillRect(DrawablePtr pDraw,
 787                        GCPtr pGC, int nrectFill, xRectangle *prectInit)
 788 {
 789     ScreenPtr pScreen = pGC->pScreen;
 790
 791     GC_UNWRAP(pGC);
 792     VGAGet(pScreen);
 793     (*pGC->ops->PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
 794     VGAPut();
 795     GC_WRAP(pGC);
 796 }
 797
 798 static void
 799 VGAarbiterPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
 800 {
 801     ScreenPtr pScreen = pGC->pScreen;
 802
 803     GC_UNWRAP(pGC);
 804     VGAGet(pScreen);
 805     (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, parcs);
 806     VGAPut();
 807     GC_WRAP(pGC);
 808 }
 809
 810 static int
 811 VGAarbiterPolyText8(DrawablePtr pDraw,
 812                     GCPtr pGC, int x, int y, int count, char *chars)
 813 {
 814     int ret;
 815     ScreenPtr pScreen = pGC->pScreen;
 816
 817     GC_UNWRAP(pGC);
 818     VGAGet(pScreen);
 819     ret = (*pGC->ops->PolyText8) (pDraw, pGC, x, y, count, chars);
 820     VGAPut();
 821     GC_WRAP(pGC);
 822     return ret;
 823 }
 824
 825 static int
 826 VGAarbiterPolyText16(DrawablePtr pDraw,
 827                      GCPtr pGC, int x, int y, int count, unsigned short *chars)
 828 {
 829     int ret;
 830     ScreenPtr pScreen = pGC->pScreen;
 831
 832     GC_UNWRAP(pGC);
 833     VGAGet(pScreen);
 834     ret = (*pGC->ops->PolyText16) (pDraw, pGC, x, y, count, chars);
 835     VGAPut();
 836     GC_WRAP(pGC);
 837     return ret;
 838 }
 839
 840 static void
 841 VGAarbiterImageText8(DrawablePtr pDraw,
 842                      GCPtr pGC, int x, int y, int count, char *chars)
 843 {
 844     ScreenPtr pScreen = pGC->pScreen;
 845
 846     GC_UNWRAP(pGC);
 847     VGAGet(pScreen);
 848     (*pGC->ops->ImageText8) (pDraw, pGC, x, y, count, chars);
 849     VGAPut();
 850     GC_WRAP(pGC);
 851 }
 852
 853 static void
 854 VGAarbiterImageText16(DrawablePtr pDraw,
 855                       GCPtr pGC, int x, int y, int count, unsigned short *chars)
 856 {
 857     ScreenPtr pScreen = pGC->pScreen;
 858
 859     GC_UNWRAP(pGC);
 860     VGAGet(pScreen);
 861     (*pGC->ops->ImageText16) (pDraw, pGC, x, y, count, chars);
 862     VGAPut();
 863     GC_WRAP(pGC);
 864 }
 865
 866 static void
 867 VGAarbiterImageGlyphBlt(DrawablePtr pDraw,
 868                         GCPtr pGC,
 869                         int xInit, int yInit,
 870                         unsigned int nglyph,
 871                         CharInfoPtr * ppci, pointer pglyphBase)
 872 {
 873     ScreenPtr pScreen = pGC->pScreen;
 874
 875     GC_UNWRAP(pGC);
 876     VGAGet(pScreen);
 877     (*pGC->ops->ImageGlyphBlt) (pDraw, pGC, xInit, yInit,
 878                                 nglyph, ppci, pglyphBase);
 879     VGAPut();
 880     GC_WRAP(pGC);
 881 }
 882
 883 static void
 884 VGAarbiterPolyGlyphBlt(DrawablePtr pDraw,
 885                        GCPtr pGC,
 886                        int xInit, int yInit,
 887                        unsigned int nglyph,
 888                        CharInfoPtr * ppci, pointer pglyphBase)
 889 {
 890     ScreenPtr pScreen = pGC->pScreen;
 891
 892     GC_UNWRAP(pGC);
 893     VGAGet(pScreen);
 894     (*pGC->ops->PolyGlyphBlt) (pDraw, pGC, xInit, yInit,
 895                                nglyph, ppci, pglyphBase);
 896     VGAPut();
 897     GC_WRAP(pGC);
 898 }
 899
 900 static void
 901 VGAarbiterPushPixels(GCPtr pGC,
 902                      PixmapPtr pBitMap,
 903                      DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
 904 {
 905     ScreenPtr pScreen = pGC->pScreen;
 906
 907     GC_UNWRAP(pGC);
 908     VGAGet(pScreen);
 909     (*pGC->ops->PushPixels) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
 910     VGAPut();
 911     GC_WRAP(pGC);
 912 }
 913
 914 /* miSpriteFuncs */
 915 static Bool
 916 VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
 917                               CursorPtr pCur)
 918 {
 919     Bool val;
 920
 921     SPRITE_PROLOG;
 922     VGAGet(pScreen);
 923     val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur);
 924     VGAPut();
 925     SPRITE_EPILOG;
 926     return val;
 927 }
 928
 929 static Bool
 930 VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
 931                                 CursorPtr pCur)
 932 {
 933     Bool val;
 934
 935     SPRITE_PROLOG;
 936     VGAGet(pScreen);
 937     val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur);
 938     VGAPut();
 939     SPRITE_EPILOG;
 940     return val;
 941 }
 942
 943 static void
 944 VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur,
 945                           int x, int y)
 946 {
 947     SPRITE_PROLOG;
 948     VGAGet(pScreen);
 949     PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y);
 950     VGAPut();
 951     SPRITE_EPILOG;
 952 }
 953
 954 static void
 955 VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
 956 {
 957     SPRITE_PROLOG;
 958     VGAGet(pScreen);
 959     PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y);
 960     VGAPut();
 961     SPRITE_EPILOG;
 962 }
 963
 964 static Bool
 965 VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
 966 {
 967     Bool val;
 968
 969     SPRITE_PROLOG;
 970     VGAGet(pScreen);
 971     val = PointPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
 972     VGAPut();
 973     SPRITE_EPILOG;
 974     return val;
 975 }
 976
 977 static void
 978 VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
 979 {
 980     SPRITE_PROLOG;
 981     VGAGet(pScreen);
 982     PointPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);
 983     VGAPut();
 984     SPRITE_EPILOG;
 985 }
 986
 987 static void
 988 VGAarbiterComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask,
 989                     PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask,
 990                     INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width,
 991                     CARD16 height)
 992 {
 993     ScreenPtr pScreen = pDst->pDrawable->pScreen;
 994     PictureScreenPtr ps = GetPictureScreen(pScreen);
 995
 996     PICTURE_PROLOGUE(Composite);
 997
 998     VGAGet(pScreen);
 999     (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst,
1000                       yDst, width, height);
1001     VGAPut();
1002     PICTURE_EPILOGUE(Composite, VGAarbiterComposite);
1003 }
1004
1005 static void
1006 VGAarbiterGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
1007                  PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist,
1008                  GlyphListPtr list, GlyphPtr * glyphs)
1009 {
1010     ScreenPtr pScreen = pDst->pDrawable->pScreen;
1011     PictureScreenPtr ps = GetPictureScreen(pScreen);
1012
1013     PICTURE_PROLOGUE(Glyphs);
1014
1015     VGAGet(pScreen);
1016     (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
1017     VGAPut();
1018     PICTURE_EPILOGUE(Glyphs, VGAarbiterGlyphs);
1019 }
1020
1021 static void
1022 VGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor * color,
1023                          int nRect, xRectangle *rects)
1024 {
1025     ScreenPtr pScreen = pDst->pDrawable->pScreen;
1026     PictureScreenPtr ps = GetPictureScreen(pScreen);
1027
1028     PICTURE_PROLOGUE(CompositeRects);
1029
1030     VGAGet(pScreen);
1031     (*ps->CompositeRects) (op, pDst, color, nRect, rects);
1032     VGAPut();
1033     PICTURE_EPILOGUE(CompositeRects, VGAarbiterCompositeRects);
1034 }