xf86VGAarbiter.c revision 35c4bbdf 
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
39static GCFuncs VGAarbiterGCFuncs = {
40    VGAarbiterValidateGC, VGAarbiterChangeGC, VGAarbiterCopyGC,
41    VGAarbiterDestroyGC, VGAarbiterChangeClip, VGAarbiterDestroyClip,
42    VGAarbiterCopyClip
43};
44
45static 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
55static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = {
56    VGAarbiterSpriteRealizeCursor, VGAarbiterSpriteUnrealizeCursor,
57    VGAarbiterSpriteSetCursor, VGAarbiterSpriteMoveCursor,
58    VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup
59};
60
61static DevPrivateKeyRec VGAarbiterScreenKeyRec;
62
63#define VGAarbiterScreenKey (&VGAarbiterScreenKeyRec)
64static DevPrivateKeyRec VGAarbiterGCKeyRec;
65
66#define VGAarbiterGCKey (&VGAarbiterGCKeyRec)
67
68static int vga_no_arb = 0;
69void
70xf86VGAarbiterInit(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
79void
80xf86VGAarbiterFini(void)
81{
82    if (vga_no_arb)
83        return;
84    pci_device_vgaarb_fini();
85}
86
87void
88xf86VGAarbiterLock(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
96void
97xf86VGAarbiterUnlock(ScrnInfoPtr pScrn)
98{
99    if (vga_no_arb)
100        return;
101    pci_device_vgaarb_unlock();
102}
103
104Bool
105xf86VGAarbiterAllowDRI(ScreenPtr pScreen)
106{
107    int vga_count;
108    int rsrc_decodes;
109    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
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
123void
124xf86VGAarbiterScrnInit(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
140void
141xf86VGAarbiterDeviceDecodes(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
149Bool
150xf86VGAarbiterWrapFunctions(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 = xf86ScreenToScrn(pScreen);
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 */
223static Bool
224VGAarbiterCloseScreen(ScreenPtr pScreen)
225{
226    Bool val;
227    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
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((void *) pScreenPriv);
261    xf86VGAarbiterLock(xf86ScreenToScrn(pScreen));
262    val = (*pScreen->CloseScreen) (pScreen);
263    xf86VGAarbiterUnlock(xf86ScreenToScrn(pScreen));
264    return val;
265}
266
267static void
268VGAarbiterBlockHandler(ScreenPtr pScreen,
269                       void *pTimeout, void *pReadmask)
270{
271    SCREEN_PROLOG(BlockHandler);
272    VGAGet(pScreen);
273    pScreen->BlockHandler(pScreen, pTimeout, pReadmask);
274    VGAPut();
275    SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler);
276}
277
278static void
279VGAarbiterWakeupHandler(ScreenPtr pScreen, unsigned long result,
280                        void *pReadmask)
281{
282    SCREEN_PROLOG(WakeupHandler);
283    VGAGet(pScreen);
284    pScreen->WakeupHandler(pScreen, result, pReadmask);
285    VGAPut();
286    SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler);
287}
288
289static void
290VGAarbiterGetImage(DrawablePtr pDrawable,
291                   int sx, int sy, int w, int h,
292                   unsigned int format, unsigned long planemask, char *pdstLine)
293{
294    ScreenPtr pScreen = pDrawable->pScreen;
295
296    SCREEN_PROLOG(GetImage);
297    VGAGet(pScreen);
298    (*pScreen->GetImage) (pDrawable, sx, sy, w, h, format, planemask, pdstLine);
299    VGAPut();
300    SCREEN_EPILOG(GetImage, VGAarbiterGetImage);
301}
302
303static void
304VGAarbiterGetSpans(DrawablePtr pDrawable,
305                   int wMax,
306                   DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
307{
308    ScreenPtr pScreen = pDrawable->pScreen;
309
310    SCREEN_PROLOG(GetSpans);
311    VGAGet(pScreen);
312    (*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
313    VGAPut();
314    SCREEN_EPILOG(GetSpans, VGAarbiterGetSpans);
315}
316
317static void
318VGAarbiterSourceValidate(DrawablePtr pDrawable,
319                         int x, int y, int width, int height,
320                         unsigned int subWindowMode)
321{
322    ScreenPtr pScreen = pDrawable->pScreen;
323
324    SCREEN_PROLOG(SourceValidate);
325    VGAGet(pScreen);
326    if (pScreen->SourceValidate)
327        (*pScreen->SourceValidate) (pDrawable, x, y, width, height,
328                                    subWindowMode);
329    VGAPut();
330    SCREEN_EPILOG(SourceValidate, VGAarbiterSourceValidate);
331}
332
333static void
334VGAarbiterCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
335{
336    ScreenPtr pScreen = pWin->drawable.pScreen;
337
338    SCREEN_PROLOG(CopyWindow);
339    VGAGet(pScreen);
340    (*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
341    VGAPut();
342    SCREEN_EPILOG(CopyWindow, VGAarbiterCopyWindow);
343}
344
345static void
346VGAarbiterClearToBackground(WindowPtr pWin,
347                            int x, int y, int w, int h, Bool generateExposures)
348{
349    ScreenPtr pScreen = pWin->drawable.pScreen;
350
351    SCREEN_PROLOG(ClearToBackground);
352    VGAGet(pScreen);
353    (*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures);
354    VGAPut();
355    SCREEN_EPILOG(ClearToBackground, VGAarbiterClearToBackground);
356}
357
358static PixmapPtr
359VGAarbiterCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
360                       unsigned usage_hint)
361{
362    PixmapPtr pPix;
363
364    SCREEN_PROLOG(CreatePixmap);
365    VGAGet(pScreen);
366    pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint);
367    VGAPut();
368    SCREEN_EPILOG(CreatePixmap, VGAarbiterCreatePixmap);
369
370    return pPix;
371}
372
373static Bool
374VGAarbiterSaveScreen(ScreenPtr pScreen, Bool unblank)
375{
376    Bool val;
377
378    SCREEN_PROLOG(SaveScreen);
379    VGAGet(pScreen);
380    val = (*pScreen->SaveScreen) (pScreen, unblank);
381    VGAPut();
382    SCREEN_EPILOG(SaveScreen, VGAarbiterSaveScreen);
383
384    return val;
385}
386
387static void
388VGAarbiterStoreColors(ColormapPtr pmap, int ndef, xColorItem * pdefs)
389{
390    ScreenPtr pScreen = pmap->pScreen;
391
392    SCREEN_PROLOG(StoreColors);
393    VGAGet(pScreen);
394    (*pScreen->StoreColors) (pmap, ndef, pdefs);
395    VGAPut();
396    SCREEN_EPILOG(StoreColors, VGAarbiterStoreColors);
397}
398
399static void
400VGAarbiterRecolorCursor(DeviceIntPtr pDev,
401                        ScreenPtr pScreen, CursorPtr pCurs, Bool displayed)
402{
403    SCREEN_PROLOG(RecolorCursor);
404    VGAGet(pScreen);
405    (*pScreen->RecolorCursor) (pDev, pScreen, pCurs, displayed);
406    VGAPut();
407    SCREEN_EPILOG(RecolorCursor, VGAarbiterRecolorCursor);
408}
409
410static Bool
411VGAarbiterRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
412{
413    Bool val;
414
415    SCREEN_PROLOG(RealizeCursor);
416    VGAGet(pScreen);
417    val = (*pScreen->RealizeCursor) (pDev, pScreen, pCursor);
418    VGAPut();
419    SCREEN_EPILOG(RealizeCursor, VGAarbiterRealizeCursor);
420    return val;
421}
422
423static Bool
424VGAarbiterUnrealizeCursor(DeviceIntPtr pDev,
425                          ScreenPtr pScreen, CursorPtr pCursor)
426{
427    Bool val;
428
429    SCREEN_PROLOG(UnrealizeCursor);
430    VGAGet(pScreen);
431    val = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);
432    VGAPut();
433    SCREEN_EPILOG(UnrealizeCursor, VGAarbiterUnrealizeCursor);
434    return val;
435}
436
437static Bool
438VGAarbiterDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
439{
440    Bool val;
441
442    SCREEN_PROLOG(DisplayCursor);
443    VGAGet(pScreen);
444    val = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
445    VGAPut();
446    SCREEN_EPILOG(DisplayCursor, VGAarbiterDisplayCursor);
447    return val;
448}
449
450static Bool
451VGAarbiterSetCursorPosition(DeviceIntPtr pDev,
452                            ScreenPtr pScreen, int x, int y, Bool generateEvent)
453{
454    Bool val;
455
456    SCREEN_PROLOG(SetCursorPosition);
457    VGAGet(pScreen);
458    val = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);
459    VGAPut();
460    SCREEN_EPILOG(SetCursorPosition, VGAarbiterSetCursorPosition);
461    return val;
462}
463
464static void
465VGAarbiterAdjustFrame(ScrnInfoPtr pScrn, int x, int y)
466{
467    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
468    VGAarbiterScreenPtr pScreenPriv =
469        (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
470                                               VGAarbiterScreenKey);
471
472    VGAGet(pScreen);
473    (*pScreenPriv->AdjustFrame) (pScrn, x, y);
474    VGAPut();
475}
476
477static Bool
478VGAarbiterSwitchMode(ScrnInfoPtr pScrn, DisplayModePtr mode)
479{
480    Bool val;
481    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
482    VGAarbiterScreenPtr pScreenPriv =
483        (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
484                                               VGAarbiterScreenKey);
485
486    VGAGet(pScreen);
487    val = (*pScreenPriv->SwitchMode) (pScrn, mode);
488    VGAPut();
489    return val;
490}
491
492static Bool
493VGAarbiterEnterVT(ScrnInfoPtr pScrn)
494{
495    Bool val;
496    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
497    VGAarbiterScreenPtr pScreenPriv =
498        (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
499                                               VGAarbiterScreenKey);
500
501    VGAGet(pScreen);
502    pScrn->EnterVT = pScreenPriv->EnterVT;
503    val = (*pScrn->EnterVT) (pScrn);
504    pScreenPriv->EnterVT = pScrn->EnterVT;
505    pScrn->EnterVT = VGAarbiterEnterVT;
506    VGAPut();
507    return val;
508}
509
510static void
511VGAarbiterLeaveVT(ScrnInfoPtr pScrn)
512{
513    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
514    VGAarbiterScreenPtr pScreenPriv =
515        (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
516                                               VGAarbiterScreenKey);
517
518    VGAGet(pScreen);
519    pScrn->LeaveVT = pScreenPriv->LeaveVT;
520    (*pScreenPriv->LeaveVT) (pScrn);
521    pScreenPriv->LeaveVT = pScrn->LeaveVT;
522    pScrn->LeaveVT = VGAarbiterLeaveVT;
523    VGAPut();
524}
525
526static void
527VGAarbiterFreeScreen(ScrnInfoPtr pScrn)
528{
529    ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
530    VGAarbiterScreenPtr pScreenPriv =
531        (VGAarbiterScreenPtr) dixLookupPrivate(&pScreen->devPrivates,
532                                               VGAarbiterScreenKey);
533
534    VGAGet(pScreen);
535    (*pScreenPriv->FreeScreen) (pScrn);
536    VGAPut();
537}
538
539static Bool
540VGAarbiterCreateGC(GCPtr pGC)
541{
542    ScreenPtr pScreen = pGC->pScreen;
543    VGAarbiterGCPtr pGCPriv =
544        (VGAarbiterGCPtr) dixLookupPrivate(&pGC->devPrivates, VGAarbiterGCKey);
545    Bool ret;
546
547    SCREEN_PROLOG(CreateGC);
548    ret = (*pScreen->CreateGC) (pGC);
549    GC_WRAP(pGC);
550    SCREEN_EPILOG(CreateGC, VGAarbiterCreateGC);
551
552    return ret;
553}
554
555/* GC funcs */
556static void
557VGAarbiterValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw)
558{
559    GC_UNWRAP(pGC);
560    (*pGC->funcs->ValidateGC) (pGC, changes, pDraw);
561    GC_WRAP(pGC);
562}
563
564static void
565VGAarbiterDestroyGC(GCPtr pGC)
566{
567    GC_UNWRAP(pGC);
568    (*pGC->funcs->DestroyGC) (pGC);
569    GC_WRAP(pGC);
570}
571
572static void
573VGAarbiterChangeGC(GCPtr pGC, unsigned long mask)
574{
575    GC_UNWRAP(pGC);
576    (*pGC->funcs->ChangeGC) (pGC, mask);
577    GC_WRAP(pGC);
578}
579
580static void
581VGAarbiterCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
582{
583    GC_UNWRAP(pGCDst);
584    (*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
585    GC_WRAP(pGCDst);
586}
587
588static void
589VGAarbiterChangeClip(GCPtr pGC, int type, void *pvalue, int nrects)
590{
591    GC_UNWRAP(pGC);
592    (*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
593    GC_WRAP(pGC);
594}
595
596static void
597VGAarbiterCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
598{
599    GC_UNWRAP(pgcDst);
600    (*pgcDst->funcs->CopyClip) (pgcDst, pgcSrc);
601    GC_WRAP(pgcDst);
602}
603
604static void
605VGAarbiterDestroyClip(GCPtr pGC)
606{
607    GC_UNWRAP(pGC);
608    (*pGC->funcs->DestroyClip) (pGC);
609    GC_WRAP(pGC);
610}
611
612/* GC Ops */
613static void
614VGAarbiterFillSpans(DrawablePtr pDraw,
615                    GC * pGC,
616                    int nInit,
617                    DDXPointPtr pptInit, int *pwidthInit, int fSorted)
618{
619    ScreenPtr pScreen = pGC->pScreen;
620
621    GC_UNWRAP(pGC);
622    VGAGet(pScreen);
623    (*pGC->ops->FillSpans) (pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
624    VGAPut();
625    GC_WRAP(pGC);
626}
627
628static void
629VGAarbiterSetSpans(DrawablePtr pDraw,
630                   GCPtr pGC,
631                   char *pcharsrc,
632                   register DDXPointPtr ppt,
633                   int *pwidth, int nspans, int fSorted)
634{
635    ScreenPtr pScreen = pGC->pScreen;
636
637    GC_UNWRAP(pGC);
638    VGAGet(pScreen);
639    (*pGC->ops->SetSpans) (pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
640    VGAPut();
641    GC_WRAP(pGC);
642}
643
644static void
645VGAarbiterPutImage(DrawablePtr pDraw,
646                   GCPtr pGC,
647                   int depth,
648                   int x, int y, int w, int h,
649                   int leftPad, int format, char *pImage)
650{
651    ScreenPtr pScreen = pGC->pScreen;
652
653    GC_UNWRAP(pGC);
654    VGAGet(pScreen);
655    (*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
656                           leftPad, format, pImage);
657    VGAPut();
658    GC_WRAP(pGC);
659}
660
661static RegionPtr
662VGAarbiterCopyArea(DrawablePtr pSrc,
663                   DrawablePtr pDst,
664                   GC * pGC,
665                   int srcx, int srcy,
666                   int width, int height, int dstx, int dsty)
667{
668    RegionPtr ret;
669    ScreenPtr pScreen = pGC->pScreen;
670
671    GC_UNWRAP(pGC);
672    VGAGet(pScreen);
673    ret = (*pGC->ops->CopyArea) (pSrc, pDst,
674                                 pGC, srcx, srcy, width, height, dstx, dsty);
675    VGAPut();
676    GC_WRAP(pGC);
677    return ret;
678}
679
680static RegionPtr
681VGAarbiterCopyPlane(DrawablePtr pSrc,
682                    DrawablePtr pDst,
683                    GCPtr pGC,
684                    int srcx, int srcy,
685                    int width, int height,
686                    int dstx, int dsty, unsigned long bitPlane)
687{
688    RegionPtr ret;
689    ScreenPtr pScreen = pGC->pScreen;
690
691    GC_UNWRAP(pGC);
692    VGAGet(pScreen);
693    ret = (*pGC->ops->CopyPlane) (pSrc, pDst, pGC, srcx, srcy,
694                                  width, height, dstx, dsty, bitPlane);
695    VGAPut();
696    GC_WRAP(pGC);
697    return ret;
698}
699
700static void
701VGAarbiterPolyPoint(DrawablePtr pDraw,
702                    GCPtr pGC, int mode, int npt, xPoint * pptInit)
703{
704    ScreenPtr pScreen = pGC->pScreen;
705
706    GC_UNWRAP(pGC);
707    VGAGet(pScreen);
708    (*pGC->ops->PolyPoint) (pDraw, pGC, mode, npt, pptInit);
709    VGAPut();
710    GC_WRAP(pGC);
711}
712
713static void
714VGAarbiterPolylines(DrawablePtr pDraw,
715                    GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
716{
717    ScreenPtr pScreen = pGC->pScreen;
718
719    GC_UNWRAP(pGC);
720    VGAGet(pScreen);
721    (*pGC->ops->Polylines) (pDraw, pGC, mode, npt, pptInit);
722    VGAPut();
723    GC_WRAP(pGC);
724}
725
726static void
727VGAarbiterPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg, xSegment * pSeg)
728{
729    ScreenPtr pScreen = pGC->pScreen;
730
731    GC_UNWRAP(pGC);
732    VGAGet(pScreen);
733    (*pGC->ops->PolySegment) (pDraw, pGC, nseg, pSeg);
734    VGAPut();
735    GC_WRAP(pGC);
736}
737
738static void
739VGAarbiterPolyRectangle(DrawablePtr pDraw,
740                        GCPtr pGC, int nRectsInit, xRectangle *pRectsInit)
741{
742    ScreenPtr pScreen = pGC->pScreen;
743
744    GC_UNWRAP(pGC);
745    VGAGet(pScreen);
746    (*pGC->ops->PolyRectangle) (pDraw, pGC, nRectsInit, pRectsInit);
747    VGAPut();
748    GC_WRAP(pGC);
749}
750
751static void
752VGAarbiterPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
753{
754    ScreenPtr pScreen = pGC->pScreen;
755
756    GC_UNWRAP(pGC);
757    VGAGet(pScreen);
758    (*pGC->ops->PolyArc) (pDraw, pGC, narcs, parcs);
759    VGAPut();
760    GC_WRAP(pGC);
761}
762
763static void
764VGAarbiterFillPolygon(DrawablePtr pDraw,
765                      GCPtr pGC,
766                      int shape, int mode, int count, DDXPointPtr ptsIn)
767{
768    ScreenPtr pScreen = pGC->pScreen;
769
770    GC_UNWRAP(pGC);
771    VGAGet(pScreen);
772    (*pGC->ops->FillPolygon) (pDraw, pGC, shape, mode, count, ptsIn);
773    VGAPut();
774    GC_WRAP(pGC);
775}
776
777static void
778VGAarbiterPolyFillRect(DrawablePtr pDraw,
779                       GCPtr pGC, int nrectFill, xRectangle *prectInit)
780{
781    ScreenPtr pScreen = pGC->pScreen;
782
783    GC_UNWRAP(pGC);
784    VGAGet(pScreen);
785    (*pGC->ops->PolyFillRect) (pDraw, pGC, nrectFill, prectInit);
786    VGAPut();
787    GC_WRAP(pGC);
788}
789
790static void
791VGAarbiterPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc * parcs)
792{
793    ScreenPtr pScreen = pGC->pScreen;
794
795    GC_UNWRAP(pGC);
796    VGAGet(pScreen);
797    (*pGC->ops->PolyFillArc) (pDraw, pGC, narcs, parcs);
798    VGAPut();
799    GC_WRAP(pGC);
800}
801
802static int
803VGAarbiterPolyText8(DrawablePtr pDraw,
804                    GCPtr pGC, int x, int y, int count, char *chars)
805{
806    int ret;
807    ScreenPtr pScreen = pGC->pScreen;
808
809    GC_UNWRAP(pGC);
810    VGAGet(pScreen);
811    ret = (*pGC->ops->PolyText8) (pDraw, pGC, x, y, count, chars);
812    VGAPut();
813    GC_WRAP(pGC);
814    return ret;
815}
816
817static int
818VGAarbiterPolyText16(DrawablePtr pDraw,
819                     GCPtr pGC, int x, int y, int count, unsigned short *chars)
820{
821    int ret;
822    ScreenPtr pScreen = pGC->pScreen;
823
824    GC_UNWRAP(pGC);
825    VGAGet(pScreen);
826    ret = (*pGC->ops->PolyText16) (pDraw, pGC, x, y, count, chars);
827    VGAPut();
828    GC_WRAP(pGC);
829    return ret;
830}
831
832static void
833VGAarbiterImageText8(DrawablePtr pDraw,
834                     GCPtr pGC, int x, int y, int count, char *chars)
835{
836    ScreenPtr pScreen = pGC->pScreen;
837
838    GC_UNWRAP(pGC);
839    VGAGet(pScreen);
840    (*pGC->ops->ImageText8) (pDraw, pGC, x, y, count, chars);
841    VGAPut();
842    GC_WRAP(pGC);
843}
844
845static void
846VGAarbiterImageText16(DrawablePtr pDraw,
847                      GCPtr pGC, int x, int y, int count, unsigned short *chars)
848{
849    ScreenPtr pScreen = pGC->pScreen;
850
851    GC_UNWRAP(pGC);
852    VGAGet(pScreen);
853    (*pGC->ops->ImageText16) (pDraw, pGC, x, y, count, chars);
854    VGAPut();
855    GC_WRAP(pGC);
856}
857
858static void
859VGAarbiterImageGlyphBlt(DrawablePtr pDraw,
860                        GCPtr pGC,
861                        int xInit, int yInit,
862                        unsigned int nglyph,
863                        CharInfoPtr * ppci, void *pglyphBase)
864{
865    ScreenPtr pScreen = pGC->pScreen;
866
867    GC_UNWRAP(pGC);
868    VGAGet(pScreen);
869    (*pGC->ops->ImageGlyphBlt) (pDraw, pGC, xInit, yInit,
870                                nglyph, ppci, pglyphBase);
871    VGAPut();
872    GC_WRAP(pGC);
873}
874
875static void
876VGAarbiterPolyGlyphBlt(DrawablePtr pDraw,
877                       GCPtr pGC,
878                       int xInit, int yInit,
879                       unsigned int nglyph,
880                       CharInfoPtr * ppci, void *pglyphBase)
881{
882    ScreenPtr pScreen = pGC->pScreen;
883
884    GC_UNWRAP(pGC);
885    VGAGet(pScreen);
886    (*pGC->ops->PolyGlyphBlt) (pDraw, pGC, xInit, yInit,
887                               nglyph, ppci, pglyphBase);
888    VGAPut();
889    GC_WRAP(pGC);
890}
891
892static void
893VGAarbiterPushPixels(GCPtr pGC,
894                     PixmapPtr pBitMap,
895                     DrawablePtr pDraw, int dx, int dy, int xOrg, int yOrg)
896{
897    ScreenPtr pScreen = pGC->pScreen;
898
899    GC_UNWRAP(pGC);
900    VGAGet(pScreen);
901    (*pGC->ops->PushPixels) (pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
902    VGAPut();
903    GC_WRAP(pGC);
904}
905
906/* miSpriteFuncs */
907static Bool
908VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
909                              CursorPtr pCur)
910{
911    Bool val;
912
913    SPRITE_PROLOG;
914    VGAGet(pScreen);
915    val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur);
916    VGAPut();
917    SPRITE_EPILOG;
918    return val;
919}
920
921static Bool
922VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
923                                CursorPtr pCur)
924{
925    Bool val;
926
927    SPRITE_PROLOG;
928    VGAGet(pScreen);
929    val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur);
930    VGAPut();
931    SPRITE_EPILOG;
932    return val;
933}
934
935static void
936VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur,
937                          int x, int y)
938{
939    SPRITE_PROLOG;
940    VGAGet(pScreen);
941    PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y);
942    VGAPut();
943    SPRITE_EPILOG;
944}
945
946static void
947VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
948{
949    SPRITE_PROLOG;
950    VGAGet(pScreen);
951    PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y);
952    VGAPut();
953    SPRITE_EPILOG;
954}
955
956static Bool
957VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
958{
959    Bool val;
960
961    SPRITE_PROLOG;
962    VGAGet(pScreen);
963    val = PointPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
964    VGAPut();
965    SPRITE_EPILOG;
966    return val;
967}
968
969static void
970VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
971{
972    SPRITE_PROLOG;
973    VGAGet(pScreen);
974    PointPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);
975    VGAPut();
976    SPRITE_EPILOG;
977}
978
979static void
980VGAarbiterComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask,
981                    PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask,
982                    INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width,
983                    CARD16 height)
984{
985    ScreenPtr pScreen = pDst->pDrawable->pScreen;
986    PictureScreenPtr ps = GetPictureScreen(pScreen);
987
988    PICTURE_PROLOGUE(Composite);
989
990    VGAGet(pScreen);
991    (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst,
992                      yDst, width, height);
993    VGAPut();
994    PICTURE_EPILOGUE(Composite, VGAarbiterComposite);
995}
996
997static void
998VGAarbiterGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
999                 PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist,
1000                 GlyphListPtr list, GlyphPtr * glyphs)
1001{
1002    ScreenPtr pScreen = pDst->pDrawable->pScreen;
1003    PictureScreenPtr ps = GetPictureScreen(pScreen);
1004
1005    PICTURE_PROLOGUE(Glyphs);
1006
1007    VGAGet(pScreen);
1008    (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
1009    VGAPut();
1010    PICTURE_EPILOGUE(Glyphs, VGAarbiterGlyphs);
1011}
1012
1013static void
1014VGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor * color,
1015                         int nRect, xRectangle *rects)
1016{
1017    ScreenPtr pScreen = pDst->pDrawable->pScreen;
1018    PictureScreenPtr ps = GetPictureScreen(pScreen);
1019
1020    PICTURE_PROLOGUE(CompositeRects);
1021
1022    VGAGet(pScreen);
1023    (*ps->CompositeRects) (op, pDst, color, nRect, rects);
1024    VGAPut();
1025    PICTURE_EPILOGUE(CompositeRects, VGAarbiterCompositeRects);
1026}
1027