xserver libX11 libxcb pixman mesa git update 20 Mar 2011

3 files changed, 2015 insertions, 2015 deletions

diff --git a/xorg-server/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
index c5ebb2780..0aa6f2cf4 100644
--- a/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
+++ b/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
@@ -1,1127 +1,1127 @@
-/*
- * 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.
- *
- */
-
-#include "xorg-config.h"
-
-#include "xf86VGAarbiter.h"
-
-#ifdef HAVE_PCI_DEVICE_VGAARB_INIT
-#include "xf86VGAarbiterPriv.h"
-#include "xf86Bus.h"
-#include "xf86Priv.h"
-#include "pciaccess.h"
-
-
-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,
-};
-
-static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = {
-    VGAarbiterSpriteRealizeCursor, VGAarbiterSpriteUnrealizeCursor,
-    VGAarbiterSpriteSetCursor, VGAarbiterSpriteMoveCursor,
-    VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup
-};
-
-static DevPrivateKeyRec VGAarbiterScreenKeyRec;
-#define VGAarbiterScreenKey (&VGAarbiterScreenKeyRec)
-static DevPrivateKeyRec VGAarbiterGCKeyRec;
-#define VGAarbiterGCKey (&VGAarbiterGCKeyRec)
-
-static int vga_no_arb = 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;
-    pci_device_vgaarb_set_target(pScrn->vgaDev);
-    pci_device_vgaarb_lock();
-}
-
-void
-xf86VGAarbiterUnlock(ScrnInfoPtr pScrn)
-{
-    if (vga_no_arb)
-	return;
-    pci_device_vgaarb_unlock();
-}
-
-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, int rsrc)
-{
-    if (vga_no_arb)
-	return;
-    pci_device_vgaarb_set_target(pScrn->vgaDev);
-    pci_device_vgaarb_decodes(rsrc);
-}
-
-Bool
-xf86VGAarbiterWrapFunctions(void)
-{
-    ScrnInfoPtr pScrn;
-    VGAarbiterScreenPtr pScreenPriv;
-    miPointerScreenPtr PointPriv;
-    PictureScreenPtr    ps;
-    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;
-        ps = GetPictureScreenIfSet(pScreen);
-        pScrn = xf86Screens[pScreen->myNum];
-        PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);
-
-        if (!dixRegisterPrivateKey(&VGAarbiterGCKeyRec, PRIVATE_GC, sizeof(VGAarbiterGCRec)))
-            return FALSE;
-
-	if (!dixRegisterPrivateKey(&VGAarbiterScreenKeyRec, PRIVATE_SCREEN, 0))
-	    return FALSE;
-
-        if (!(pScreenPriv = malloc(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);
-        WRAP_PICT(Composite,VGAarbiterComposite);
-        WRAP_PICT(Glyphs,VGAarbiterGlyphs);
-        WRAP_PICT(CompositeRects,VGAarbiterCompositeRects);
-        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);
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
-
-    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);
-    UNWRAP_PICT(Composite);
-    UNWRAP_PICT(Glyphs);
-    UNWRAP_PICT(CompositeRects);
-    UNWRAP_SCREEN_INFO(AdjustFrame);
-    UNWRAP_SCREEN_INFO(SwitchMode);
-    UNWRAP_SCREEN_INFO(EnterVT);
-    UNWRAP_SCREEN_INFO(LeaveVT);
-    UNWRAP_SCREEN_INFO(FreeScreen);
-    UNWRAP_SPRITE;
-
-    free((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);
-    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);
-    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);
-//    }
-    (*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);
-    (*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,
-    unsigned int subWindowMode )
-{
-    ScreenPtr   pScreen = pDrawable->pScreen;
-    SCREEN_PROLOG (SourceValidate);
-    VGAGet(pScreen);
-    if (pScreen->SourceValidate)
-    (*pScreen->SourceValidate) (pDrawable, x, y, width, height, subWindowMode);
-    VGAPut();
-    SCREEN_EPILOG (SourceValidate, VGAarbiterSourceValidate);
-}
-
-static void
-VGAarbiterCopyWindow(
-    WindowPtr pWin,
-    DDXPointRec ptOldOrg,
-    RegionPtr prgnSrc )
-{
-    ScreenPtr pScreen = pWin->drawable.pScreen;
-
-    SCREEN_PROLOG (CopyWindow);
-    VGAGet(pScreen);
-    (*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);
-    (*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 class)
-{
-    PixmapPtr pPix;
-
-    SCREEN_PROLOG ( CreatePixmap);
-    VGAGet(pScreen);
-    pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, class);
-    VGAPut();
-    SCREEN_EPILOG (CreatePixmap, VGAarbiterCreatePixmap);
-
-    return pPix;
-}
-
-static Bool
-VGAarbiterSaveScreen(ScreenPtr pScreen, Bool unblank)
-{
-    Bool val;
-
-    SCREEN_PROLOG (SaveScreen);
-    VGAGet(pScreen);
-    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);
-    (*pScreen->StoreColors) (pmap,ndef,pdefs);
-    VGAPut();
-    SCREEN_EPILOG ( StoreColors, VGAarbiterStoreColors);
-}
-
-static void
-VGAarbiterRecolorCursor (
-    DeviceIntPtr pDev,
-    ScreenPtr pScreen,
-    CursorPtr pCurs,
-    Bool displayed
-    )
-{
-    SCREEN_PROLOG (RecolorCursor);
-    VGAGet(pScreen);
-    (*pScreen->RecolorCursor) (pDev, pScreen, pCurs, displayed);
-    VGAPut();
-    SCREEN_EPILOG ( RecolorCursor, VGAarbiterRecolorCursor);
-}
-
-static Bool
-VGAarbiterRealizeCursor (
-    DeviceIntPtr pDev,
-    ScreenPtr   pScreen,
-    CursorPtr   pCursor
-    )
-{
-    Bool val;
-
-    SCREEN_PROLOG (RealizeCursor);
-    VGAGet(pScreen);
-    val = (*pScreen->RealizeCursor) (pDev, pScreen,pCursor);
-    VGAPut();
-    SCREEN_EPILOG ( RealizeCursor, VGAarbiterRealizeCursor);
-    return val;
-}
-
-static Bool
-VGAarbiterUnrealizeCursor (
-    DeviceIntPtr pDev,
-    ScreenPtr   pScreen,
-    CursorPtr   pCursor
-    )
-{
-    Bool val;
-
-    SCREEN_PROLOG (UnrealizeCursor);
-    VGAGet(pScreen);
-    val = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);
-    VGAPut();
-    SCREEN_EPILOG ( UnrealizeCursor, VGAarbiterUnrealizeCursor);
-    return val;
-}
-
-static Bool
-VGAarbiterDisplayCursor (
-    DeviceIntPtr pDev,
-    ScreenPtr   pScreen,
-    CursorPtr   pCursor
-    )
-{
-    Bool val;
-
-    SCREEN_PROLOG (DisplayCursor);
-    VGAGet(pScreen);
-    val = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);
-    VGAPut();
-    SCREEN_EPILOG ( DisplayCursor, VGAarbiterDisplayCursor);
-    return val;
-}
-
-static Bool
-VGAarbiterSetCursorPosition (
-    DeviceIntPtr pDev,
-    ScreenPtr   pScreen,
-    int x, int y,
-    Bool generateEvent)
-{
-    Bool val;
-
-    SCREEN_PROLOG (SetCursorPosition);
-    VGAGet(pScreen);
-    val = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);
-    VGAPut();
-    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(pScreen);
-    (*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(pScreen);
-    val = (*pScreenPriv->SwitchMode)(index, mode, flags);
-    VGAPut();
-    return val;
-}
-
-static Bool
-VGAarbiterEnterVT(int index, int flags)
-{
-    Bool val;
-    ScrnInfoPtr pScrn = xf86Screens[index];
-    ScreenPtr pScreen = screenInfo.screens[index];
-    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
-        &pScreen->devPrivates, VGAarbiterScreenKey);
-
-    VGAGet(pScreen);
-    pScrn->EnterVT = pScreenPriv->EnterVT;
-    val = (*pScrn->EnterVT)(index, flags);
-    pScreenPriv->EnterVT = pScrn->EnterVT;
-    pScrn->EnterVT = VGAarbiterEnterVT;
-    VGAPut();
-    return val;
-}
-
-static void
-VGAarbiterLeaveVT(int index, int flags)
-{
-    ScrnInfoPtr pScrn = xf86Screens[index];
-    ScreenPtr pScreen = screenInfo.screens[index];
-    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
-        &pScreen->devPrivates, VGAarbiterScreenKey);
-
-    VGAGet(pScreen);
-    pScrn->LeaveVT = pScreenPriv->LeaveVT;
-    (*pScreenPriv->LeaveVT)(index, flags);
-    pScreenPriv->LeaveVT = pScrn->LeaveVT;
-    pScrn->LeaveVT = VGAarbiterLeaveVT;
-    VGAPut();
-}
-
-static void
-VGAarbiterFreeScreen(int index, int flags)
-{
-    ScreenPtr pScreen = screenInfo.screens[index];
-    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(
-        &pScreen->devPrivates, VGAarbiterScreenKey);
-
-    VGAGet(pScreen);
-    (*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);
-    ret = (*pScreen->CreateGC)(pGC);
-    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 )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterSetSpans(
-    DrawablePtr     pDraw,
-    GCPtr       pGC,
-    char        *pcharsrc,
-    register DDXPointPtr ppt,
-    int         *pwidth,
-    int         nspans,
-    int         fSorted )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
-    VGAPut();
-    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 )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h,
-              leftPad, format, pImage);
-    VGAPut();
-    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;
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    ret = (*pGC->ops->CopyArea)(pSrc, pDst,
-                pGC, srcx, srcy, width, height, dstx, dsty);
-    VGAPut();
-    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;
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, srcx, srcy,
-                 width, height, dstx, dsty, bitPlane);
-    VGAPut();
-    GC_WRAP(pGC);
-    return ret;
-}
-
-static void
-VGAarbiterPolyPoint(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int mode,
-    int npt,
-    xPoint *pptInit )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-
-static void
-VGAarbiterPolylines(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     mode,
-    int     npt,
-    DDXPointPtr pptInit )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolySegment(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     nseg,
-    xSegment    *pSeg )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolyRectangle(
-    DrawablePtr  pDraw,
-    GCPtr        pGC,
-    int          nRectsInit,
-    xRectangle  *pRectsInit )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolyArc(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     narcs,
-    xArc    *parcs )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterFillPolygon(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     shape,
-    int     mode,
-    int     count,
-    DDXPointPtr ptsIn )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolyFillRect(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     nrectFill,
-    xRectangle  *prectInit)
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolyFillArc(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     narcs,
-    xArc    *parcs )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static int
-VGAarbiterPolyText8(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     x,
-    int     y,
-    int     count,
-    char    *chars )
-{
-    int ret;
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
-    VGAPut();
-    GC_WRAP(pGC);
-    return ret;
-}
-
-static int
-VGAarbiterPolyText16(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     x,
-    int     y,
-    int     count,
-    unsigned short *chars )
-{
-    int ret;
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
-    VGAPut();
-    GC_WRAP(pGC);
-    return ret;
-}
-
-static void
-VGAarbiterImageText8(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     x,
-    int     y,
-    int     count,
-    char    *chars )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterImageText16(
-    DrawablePtr pDraw,
-    GCPtr   pGC,
-    int     x,
-    int     y,
-    int     count,
-    unsigned short *chars )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-
-static void
-VGAarbiterImageGlyphBlt(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int xInit, int yInit,
-    unsigned int nglyph,
-    CharInfoPtr *ppci,
-    pointer pglyphBase )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit,
-                   nglyph, ppci, pglyphBase);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPolyGlyphBlt(
-    DrawablePtr pDraw,
-    GCPtr pGC,
-    int xInit, int yInit,
-    unsigned int nglyph,
-    CharInfoPtr *ppci,
-    pointer pglyphBase )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit,
-                  nglyph, ppci, pglyphBase);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-static void
-VGAarbiterPushPixels(
-    GCPtr   pGC,
-    PixmapPtr   pBitMap,
-    DrawablePtr pDraw,
-    int dx, int dy, int xOrg, int yOrg )
-{
-    ScreenPtr pScreen = pGC->pScreen;
-    GC_UNWRAP(pGC);
-    VGAGet(pScreen);
-    (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
-    VGAPut();
-    GC_WRAP(pGC);
-}
-
-
-/* miSpriteFuncs */
-static Bool
-VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)
-{
-    Bool val;
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur);
-    VGAPut();
-    SPRITE_EPILOG;
-    return val;
-}
-
-static Bool
-VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)
-{
-    Bool val;
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur);
-    VGAPut();
-    SPRITE_EPILOG;
-    return val;
-}
-
-static void
-VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur, int x, int y)
-{
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y);
-    VGAPut();
-    SPRITE_EPILOG;
-}
-
-static void
-VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
-{
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y);
-    VGAPut();
-    SPRITE_EPILOG;
-}
-
-static Bool
-VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
-{
-    Bool val;
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    val = PointPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);
-    VGAPut();
-    SPRITE_EPILOG;
-    return val;
-}
-
-static void
-VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
-{
-    SPRITE_PROLOG;
-    VGAGet(pScreen);
-    PointPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);
-    VGAPut();
-    SPRITE_EPILOG;
-}
-
-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(pScreen);
-    (*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(pScreen);
-    (*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(pScreen);
-    (*ps->CompositeRects)(op, pDst, color, nRect, rects);
-    VGAPut();
-    PICTURE_EPILOGUE (CompositeRects, VGAarbiterCompositeRects);
-}
-#else
-/* 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, int rsrc) {}
-Bool xf86VGAarbiterWrapFunctions(void) { return FALSE; }
-
-#endif
+/*

+ * 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.

+ *

+ */

+

+#include "xorg-config.h"

+

+#include "xf86VGAarbiter.h"

+

+#ifdef HAVE_PCI_DEVICE_VGAARB_INIT

+#include "xf86VGAarbiterPriv.h"

+#include "xf86Bus.h"

+#include "xf86Priv.h"

+#include "pciaccess.h"

+

+

+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,

+};

+

+static miPointerSpriteFuncRec VGAarbiterSpriteFuncs = {

+    VGAarbiterSpriteRealizeCursor, VGAarbiterSpriteUnrealizeCursor,

+    VGAarbiterSpriteSetCursor, VGAarbiterSpriteMoveCursor,

+    VGAarbiterDeviceCursorInitialize, VGAarbiterDeviceCursorCleanup

+};

+

+static DevPrivateKeyRec VGAarbiterScreenKeyRec;

+#define VGAarbiterScreenKey (&VGAarbiterScreenKeyRec)

+static DevPrivateKeyRec VGAarbiterGCKeyRec;

+#define VGAarbiterGCKey (&VGAarbiterGCKeyRec)

+

+static int vga_no_arb = 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;

+    pci_device_vgaarb_set_target(pScrn->vgaDev);

+    pci_device_vgaarb_lock();

+}

+

+void

+xf86VGAarbiterUnlock(ScrnInfoPtr pScrn)

+{

+    if (vga_no_arb)

+	return;

+    pci_device_vgaarb_unlock();

+}

+

+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, int rsrc)

+{

+    if (vga_no_arb)

+	return;

+    pci_device_vgaarb_set_target(pScrn->vgaDev);

+    pci_device_vgaarb_decodes(rsrc);

+}

+

+Bool

+xf86VGAarbiterWrapFunctions(void)

+{

+    ScrnInfoPtr pScrn;

+    VGAarbiterScreenPtr pScreenPriv;

+    miPointerScreenPtr PointPriv;

+    PictureScreenPtr    ps;

+    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;

+        ps = GetPictureScreenIfSet(pScreen);

+        pScrn = xf86Screens[pScreen->myNum];

+        PointPriv = dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey);

+

+        if (!dixRegisterPrivateKey(&VGAarbiterGCKeyRec, PRIVATE_GC, sizeof(VGAarbiterGCRec)))

+            return FALSE;

+

+	if (!dixRegisterPrivateKey(&VGAarbiterScreenKeyRec, PRIVATE_SCREEN, 0))

+	    return FALSE;

+

+        if (!(pScreenPriv = malloc(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);

+        WRAP_PICT(Composite,VGAarbiterComposite);

+        WRAP_PICT(Glyphs,VGAarbiterGlyphs);

+        WRAP_PICT(CompositeRects,VGAarbiterCompositeRects);

+        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);

+    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);

+

+    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);

+    UNWRAP_PICT(Composite);

+    UNWRAP_PICT(Glyphs);

+    UNWRAP_PICT(CompositeRects);

+    UNWRAP_SCREEN_INFO(AdjustFrame);

+    UNWRAP_SCREEN_INFO(SwitchMode);

+    UNWRAP_SCREEN_INFO(EnterVT);

+    UNWRAP_SCREEN_INFO(LeaveVT);

+    UNWRAP_SCREEN_INFO(FreeScreen);

+    UNWRAP_SPRITE;

+

+    free((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);

+    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);

+    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);

+//    }

+    (*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);

+    (*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,

+    unsigned int subWindowMode )

+{

+    ScreenPtr   pScreen = pDrawable->pScreen;

+    SCREEN_PROLOG (SourceValidate);

+    VGAGet(pScreen);

+    if (pScreen->SourceValidate)

+    (*pScreen->SourceValidate) (pDrawable, x, y, width, height, subWindowMode);

+    VGAPut();

+    SCREEN_EPILOG (SourceValidate, VGAarbiterSourceValidate);

+}

+

+static void

+VGAarbiterCopyWindow(

+    WindowPtr pWin,

+    DDXPointRec ptOldOrg,

+    RegionPtr prgnSrc )

+{

+    ScreenPtr pScreen = pWin->drawable.pScreen;

+

+    SCREEN_PROLOG (CopyWindow);

+    VGAGet(pScreen);

+    (*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);

+    (*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(pScreen);

+    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(pScreen);

+    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);

+    (*pScreen->StoreColors) (pmap,ndef,pdefs);

+    VGAPut();

+    SCREEN_EPILOG ( StoreColors, VGAarbiterStoreColors);

+}

+

+static void

+VGAarbiterRecolorCursor (

+    DeviceIntPtr pDev,

+    ScreenPtr pScreen,

+    CursorPtr pCurs,

+    Bool displayed

+    )

+{

+    SCREEN_PROLOG (RecolorCursor);

+    VGAGet(pScreen);

+    (*pScreen->RecolorCursor) (pDev, pScreen, pCurs, displayed);

+    VGAPut();

+    SCREEN_EPILOG ( RecolorCursor, VGAarbiterRecolorCursor);

+}

+

+static Bool

+VGAarbiterRealizeCursor (

+    DeviceIntPtr pDev,

+    ScreenPtr   pScreen,

+    CursorPtr   pCursor

+    )

+{

+    Bool val;

+

+    SCREEN_PROLOG (RealizeCursor);

+    VGAGet(pScreen);

+    val = (*pScreen->RealizeCursor) (pDev, pScreen,pCursor);

+    VGAPut();

+    SCREEN_EPILOG ( RealizeCursor, VGAarbiterRealizeCursor);

+    return val;

+}

+

+static Bool

+VGAarbiterUnrealizeCursor (

+    DeviceIntPtr pDev,

+    ScreenPtr   pScreen,

+    CursorPtr   pCursor

+    )

+{

+    Bool val;

+

+    SCREEN_PROLOG (UnrealizeCursor);

+    VGAGet(pScreen);

+    val = (*pScreen->UnrealizeCursor) (pDev, pScreen, pCursor);

+    VGAPut();

+    SCREEN_EPILOG ( UnrealizeCursor, VGAarbiterUnrealizeCursor);

+    return val;

+}

+

+static Bool

+VGAarbiterDisplayCursor (

+    DeviceIntPtr pDev,

+    ScreenPtr   pScreen,

+    CursorPtr   pCursor

+    )

+{

+    Bool val;

+

+    SCREEN_PROLOG (DisplayCursor);

+    VGAGet(pScreen);

+    val = (*pScreen->DisplayCursor) (pDev, pScreen, pCursor);

+    VGAPut();

+    SCREEN_EPILOG ( DisplayCursor, VGAarbiterDisplayCursor);

+    return val;

+}

+

+static Bool

+VGAarbiterSetCursorPosition (

+    DeviceIntPtr pDev,

+    ScreenPtr   pScreen,

+    int x, int y,

+    Bool generateEvent)

+{

+    Bool val;

+

+    SCREEN_PROLOG (SetCursorPosition);

+    VGAGet(pScreen);

+    val = (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);

+    VGAPut();

+    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(pScreen);

+    (*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(pScreen);

+    val = (*pScreenPriv->SwitchMode)(index, mode, flags);

+    VGAPut();

+    return val;

+}

+

+static Bool

+VGAarbiterEnterVT(int index, int flags)

+{

+    Bool val;

+    ScrnInfoPtr pScrn = xf86Screens[index];

+    ScreenPtr pScreen = screenInfo.screens[index];

+    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(

+        &pScreen->devPrivates, VGAarbiterScreenKey);

+

+    VGAGet(pScreen);

+    pScrn->EnterVT = pScreenPriv->EnterVT;

+    val = (*pScrn->EnterVT)(index, flags);

+    pScreenPriv->EnterVT = pScrn->EnterVT;

+    pScrn->EnterVT = VGAarbiterEnterVT;

+    VGAPut();

+    return val;

+}

+

+static void

+VGAarbiterLeaveVT(int index, int flags)

+{

+    ScrnInfoPtr pScrn = xf86Screens[index];

+    ScreenPtr pScreen = screenInfo.screens[index];

+    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(

+        &pScreen->devPrivates, VGAarbiterScreenKey);

+

+    VGAGet(pScreen);

+    pScrn->LeaveVT = pScreenPriv->LeaveVT;

+    (*pScreenPriv->LeaveVT)(index, flags);

+    pScreenPriv->LeaveVT = pScrn->LeaveVT;

+    pScrn->LeaveVT = VGAarbiterLeaveVT;

+    VGAPut();

+}

+

+static void

+VGAarbiterFreeScreen(int index, int flags)

+{

+    ScreenPtr pScreen = screenInfo.screens[index];

+    VGAarbiterScreenPtr pScreenPriv = (VGAarbiterScreenPtr)dixLookupPrivate(

+        &pScreen->devPrivates, VGAarbiterScreenKey);

+

+    VGAGet(pScreen);

+    (*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);

+    ret = (*pScreen->CreateGC)(pGC);

+    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 )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterSetSpans(

+    DrawablePtr     pDraw,

+    GCPtr       pGC,

+    char        *pcharsrc,

+    register DDXPointPtr ppt,

+    int         *pwidth,

+    int         nspans,

+    int         fSorted )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);

+    VGAPut();

+    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 )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h,

+              leftPad, format, pImage);

+    VGAPut();

+    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;

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    ret = (*pGC->ops->CopyArea)(pSrc, pDst,

+                pGC, srcx, srcy, width, height, dstx, dsty);

+    VGAPut();

+    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;

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, srcx, srcy,

+                 width, height, dstx, dsty, bitPlane);

+    VGAPut();

+    GC_WRAP(pGC);

+    return ret;

+}

+

+static void

+VGAarbiterPolyPoint(

+    DrawablePtr pDraw,

+    GCPtr pGC,

+    int mode,

+    int npt,

+    xPoint *pptInit )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+

+static void

+VGAarbiterPolylines(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     mode,

+    int     npt,

+    DDXPointPtr pptInit )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolySegment(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     nseg,

+    xSegment    *pSeg )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolyRectangle(

+    DrawablePtr  pDraw,

+    GCPtr        pGC,

+    int          nRectsInit,

+    xRectangle  *pRectsInit )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolyArc(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     narcs,

+    xArc    *parcs )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterFillPolygon(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     shape,

+    int     mode,

+    int     count,

+    DDXPointPtr ptsIn )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolyFillRect(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     nrectFill,

+    xRectangle  *prectInit)

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolyFillArc(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     narcs,

+    xArc    *parcs )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static int

+VGAarbiterPolyText8(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     x,

+    int     y,

+    int     count,

+    char    *chars )

+{

+    int ret;

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);

+    VGAPut();

+    GC_WRAP(pGC);

+    return ret;

+}

+

+static int

+VGAarbiterPolyText16(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     x,

+    int     y,

+    int     count,

+    unsigned short *chars )

+{

+    int ret;

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);

+    VGAPut();

+    GC_WRAP(pGC);

+    return ret;

+}

+

+static void

+VGAarbiterImageText8(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     x,

+    int     y,

+    int     count,

+    char    *chars )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterImageText16(

+    DrawablePtr pDraw,

+    GCPtr   pGC,

+    int     x,

+    int     y,

+    int     count,

+    unsigned short *chars )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+

+static void

+VGAarbiterImageGlyphBlt(

+    DrawablePtr pDraw,

+    GCPtr pGC,

+    int xInit, int yInit,

+    unsigned int nglyph,

+    CharInfoPtr *ppci,

+    pointer pglyphBase )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit,

+                   nglyph, ppci, pglyphBase);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPolyGlyphBlt(

+    DrawablePtr pDraw,

+    GCPtr pGC,

+    int xInit, int yInit,

+    unsigned int nglyph,

+    CharInfoPtr *ppci,

+    pointer pglyphBase )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit,

+                  nglyph, ppci, pglyphBase);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+static void

+VGAarbiterPushPixels(

+    GCPtr   pGC,

+    PixmapPtr   pBitMap,

+    DrawablePtr pDraw,

+    int dx, int dy, int xOrg, int yOrg )

+{

+    ScreenPtr pScreen = pGC->pScreen;

+    GC_UNWRAP(pGC);

+    VGAGet(pScreen);

+    (*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);

+    VGAPut();

+    GC_WRAP(pGC);

+}

+

+

+/* miSpriteFuncs */

+static Bool

+VGAarbiterSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)

+{

+    Bool val;

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur);

+    VGAPut();

+    SPRITE_EPILOG;

+    return val;

+}

+

+static Bool

+VGAarbiterSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)

+{

+    Bool val;

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur);

+    VGAPut();

+    SPRITE_EPILOG;

+    return val;

+}

+

+static void

+VGAarbiterSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur, int x, int y)

+{

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y);

+    VGAPut();

+    SPRITE_EPILOG;

+}

+

+static void

+VGAarbiterSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

+{

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y);

+    VGAPut();

+    SPRITE_EPILOG;

+}

+

+static Bool

+VGAarbiterDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)

+{

+    Bool val;

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    val = PointPriv->spriteFuncs->DeviceCursorInitialize(pDev, pScreen);

+    VGAPut();

+    SPRITE_EPILOG;

+    return val;

+}

+

+static void

+VGAarbiterDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)

+{

+    SPRITE_PROLOG;

+    VGAGet(pScreen);

+    PointPriv->spriteFuncs->DeviceCursorCleanup(pDev, pScreen);

+    VGAPut();

+    SPRITE_EPILOG;

+}

+

+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(pScreen);

+    (*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(pScreen);

+    (*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(pScreen);

+    (*ps->CompositeRects)(op, pDst, color, nRect, rects);

+    VGAPut();

+    PICTURE_EPILOGUE (CompositeRects, VGAarbiterCompositeRects);

+}

+#else

+/* 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, int rsrc) {}

+Bool xf86VGAarbiterWrapFunctions(void) { return FALSE; }

+

+#endif

diff --git a/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h b/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h
index e1ac20f1f..13fde5e79 100644
--- a/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h
+++ b/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h
@@ -1,253 +1,253 @@
-/*
- * 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.
- *
- */
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-#include <X11/X.h>
-#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"
-# include "picturestr.h"
-
-
-#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;
-
-static inline void
-VGAGet(ScreenPtr pScreen) {
-    pci_device_vgaarb_set_target(xf86Screens[pScreen->myNum]->vgaDev);
-    pci_device_vgaarb_lock();
-}
-
-static inline void
-VGAPut(void) {
-    pci_device_vgaarb_unlock();
-}
-
-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;
-    CompositeProcPtr            Composite;
-    GlyphsProcPtr               Glyphs;
-    CompositeRectsProcPtr       CompositeRects;
-} 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, unsigned int subWindowMode);
-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 class);
-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);
-
-
-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);
+/*

+ * 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.

+ *

+ */

+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+#include <X11/X.h>

+#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"

+# include "picturestr.h"

+

+

+#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;

+

+static inline void

+VGAGet(ScreenPtr pScreen) {

+    pci_device_vgaarb_set_target(xf86Screens[pScreen->myNum]->vgaDev);

+    pci_device_vgaarb_lock();

+}

+

+static inline void

+VGAPut(void) {

+    pci_device_vgaarb_unlock();

+}

+

+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;

+    CompositeProcPtr            Composite;

+    GlyphsProcPtr               Glyphs;

+    CompositeRectsProcPtr       CompositeRects;

+} 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, unsigned int subWindowMode);

+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);

+

+

+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);

diff --git a/xorg-server/hw/xfree86/xaa/xaaInit.c b/xorg-server/hw/xfree86/xaa/xaaInit.c
index dcbd5aba0..ff1dd3d8b 100644
--- a/xorg-server/hw/xfree86/xaa/xaaInit.c
+++ b/xorg-server/hw/xfree86/xaa/xaaInit.c
@@ -1,635 +1,635 @@
-
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "windowstr.h"
-#include "xf86str.h"
-#include "mi.h"
-#include "miline.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "xaawrap.h"
-#include "xf86fbman.h"
-#include "servermd.h"
-#ifdef COMPOSITE
-#include "cw.h"
-#endif
-
-#define MAX_PREALLOC_MEM	65536	/* MUST be >= 1024 */
-
-#define MIN_OFFPIX_SIZE		(320*200)
-
-static Bool XAACloseScreen(int i, ScreenPtr pScreen);
-static void XAAGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
-			unsigned int format, unsigned long planemask,
-			char *pdstLine);
-static void XAAGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
-			int *pwidth, int nspans, char *pdstStart);
-static PixmapPtr XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
-				 unsigned class);
-static Bool XAADestroyPixmap(PixmapPtr pPixmap);
-static Bool XAAEnterVT (int index, int flags);
-static void XAALeaveVT (int index, int flags);
-static int  XAASetDGAMode(int index, int num, DGADevicePtr devRet);
-static void XAAEnableDisableFBAccess (int index, Bool enable);
-static Bool XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask);
-
-static DevPrivateKeyRec XAAScreenKeyRec;
-#define XAAScreenKey (&XAAScreenKeyRec)
-static DevPrivateKeyRec XAAGCKeyRec;
-#define XAAGCKey (&XAAGCKeyRec)
-static DevPrivateKeyRec XAAPixmapKeyRec;
-#define XAAPixmapKey (&XAAPixmapKeyRec)
-
-DevPrivateKey XAAGetScreenKey(void) {
-    return XAAScreenKey;
-}
-
-DevPrivateKey XAAGetGCKey(void) {
-    return XAAGCKey;
-}
-
-DevPrivateKey XAAGetPixmapKey(void) {
-    return XAAPixmapKey;
-}
-
-/* temp kludge */
-static Bool SwitchedOut = FALSE;
-
-XAAInfoRecPtr
-XAACreateInfoRec(void)
-{
-    XAAInfoRecPtr infoRec;
-
-    infoRec = calloc(1, sizeof(XAAInfoRec));
-    if(infoRec)
-	infoRec->CachePixelGranularity = -1;
-
-    return infoRec;
-}
-
-void
-XAADestroyInfoRec(XAAInfoRecPtr infoRec)
-{
-    if(!infoRec) return;
-
-    if(infoRec->ClosePixmapCache)
-	(*infoRec->ClosePixmapCache)(infoRec->pScrn->pScreen);
-   
-    free(infoRec->PreAllocMem);
-
-    free(infoRec->PixmapCachePrivate);
-
-    free(infoRec);
-}
-
-
-Bool
-XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec)
-{
-    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    XAAScreenPtr pScreenPriv;
-    int i;
-    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);
-
-    /* Return successfully if no acceleration wanted */
-    if (!infoRec)
-	return TRUE;
-    
-    if (!dixRegisterPrivateKey(&XAAGCKeyRec, PRIVATE_GC, sizeof(XAAGCRec)))
-	return FALSE;
-
-    if (!dixRegisterPrivateKey(&XAAPixmapKeyRec, PRIVATE_PIXMAP, sizeof(XAAPixmapRec)))
-	return FALSE;
-
-    if (!dixRegisterPrivateKey(&XAAScreenKeyRec, PRIVATE_SCREEN, 0))
-	return FALSE;
-
-    if (!(pScreenPriv = malloc(sizeof(XAAScreenRec))))
-	return FALSE;
-
-    dixSetPrivate(&pScreen->devPrivates, XAAScreenKey, pScreenPriv);
-
-    if(!xf86FBManagerRunning(pScreen))
-	infoRec->Flags &= ~(PIXMAP_CACHE | OFFSCREEN_PIXMAPS);
-    if(!(infoRec->Flags & LINEAR_FRAMEBUFFER))
-	infoRec->Flags &= ~OFFSCREEN_PIXMAPS;
-   
-    if(!infoRec->FullPlanemask) { /* for backwards compatibility */
-	infoRec->FullPlanemask =  (1 << pScrn->depth) - 1;
-	infoRec->FullPlanemasks[pScrn->depth - 1] = infoRec->FullPlanemask;
-    }
-
-    for(i = 0; i < 32; i++) {
-	if(!infoRec->FullPlanemasks[i]) /* keep any set by caller */
-	    infoRec->FullPlanemasks[i] = (1 << (i+1)) - 1;	
-    }
-
-    if(!XAAInitAccel(pScreen, infoRec)) return FALSE;
-    pScreenPriv->AccelInfoRec = infoRec;
-    infoRec->ScratchGC.pScreen = pScreen;
-
-    
-    if(!infoRec->GetImage)
-	infoRec->GetImage = XAAGetImage;
-    if(!infoRec->GetSpans)
-	infoRec->GetSpans = XAAGetSpans;
-    if(!infoRec->CopyWindow)
-	infoRec->CopyWindow = XAACopyWindow;
-
-    pScreenPriv->CreateGC = pScreen->CreateGC;
-    pScreen->CreateGC = XAACreateGC;
-    pScreenPriv->CloseScreen = pScreen->CloseScreen;
-    pScreen->CloseScreen = XAACloseScreen;
-    pScreenPriv->GetImage = pScreen->GetImage;
-    pScreen->GetImage = infoRec->GetImage;
-    pScreenPriv->GetSpans = pScreen->GetSpans;
-    pScreen->GetSpans = infoRec->GetSpans;
-    pScreenPriv->CopyWindow = pScreen->CopyWindow;
-    pScreen->CopyWindow = infoRec->CopyWindow;
-    pScreenPriv->CreatePixmap = pScreen->CreatePixmap;
-    pScreen->CreatePixmap = XAACreatePixmap;
-    pScreenPriv->DestroyPixmap = pScreen->DestroyPixmap;
-    pScreen->DestroyPixmap = XAADestroyPixmap;
-    pScreenPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
-    pScreen->ChangeWindowAttributes = XAAChangeWindowAttributes;
-
-    pScreenPriv->EnterVT = pScrn->EnterVT;
-    pScrn->EnterVT = XAAEnterVT; 
-    pScreenPriv->LeaveVT = pScrn->LeaveVT;
-    pScrn->LeaveVT = XAALeaveVT;
-    pScreenPriv->SetDGAMode = pScrn->SetDGAMode;
-    pScrn->SetDGAMode = XAASetDGAMode;
-    pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
-    pScrn->EnableDisableFBAccess = XAAEnableDisableFBAccess;
-
-    pScreenPriv->WindowExposures = pScreen->WindowExposures;
-    if (ps)
-    {
-	pScreenPriv->Composite = ps->Composite;
-	ps->Composite = XAAComposite;
-	pScreenPriv->Glyphs = ps->Glyphs;
-	ps->Glyphs = XAAGlyphs;
-    }
-    if(pScrn->overlayFlags & OVERLAY_8_32_PLANAR)
-        XAASetupOverlay8_32Planar(pScreen);
-
-    infoRec->PreAllocMem = malloc(MAX_PREALLOC_MEM);
-    if(infoRec->PreAllocMem)
-    	infoRec->PreAllocSize = MAX_PREALLOC_MEM;
-
-    if(infoRec->Flags & PIXMAP_CACHE) 
-	xf86RegisterFreeBoxCallback(pScreen, infoRec->InitPixmapCache,
-						(pointer)infoRec);
-
-    if(infoRec->Flags & MICROSOFT_ZERO_LINE_BIAS)
-	miSetZeroLineBias(pScreen, OCTANT1 | OCTANT2 | OCTANT3 | OCTANT4);
-
-#ifdef COMPOSITE
-    /* Initialize the composite wrapper.  This needs to happen after the
-     * wrapping above (so it comes before us), but before all other extensions,
-     * so it doesn't confuse them. (particularly damage).
-     */
-    miInitializeCompositeWrapper(pScreen);
-#endif
-
-    return TRUE;
-}
-
-
-
-static Bool
-XAACloseScreen (int i, ScreenPtr pScreen)
-{
-    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    XAAScreenPtr pScreenPriv = 
-	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    pScrn->EnterVT = pScreenPriv->EnterVT; 
-    pScrn->LeaveVT = pScreenPriv->LeaveVT; 
-    pScrn->EnableDisableFBAccess = pScreenPriv->EnableDisableFBAccess;
-   
-    pScreen->CreateGC = pScreenPriv->CreateGC;
-    pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    pScreen->GetImage = pScreenPriv->GetImage;
-    pScreen->GetSpans = pScreenPriv->GetSpans;
-    pScreen->CopyWindow = pScreenPriv->CopyWindow;
-    pScreen->WindowExposures = pScreenPriv->WindowExposures;
-    pScreen->CreatePixmap = pScreenPriv->CreatePixmap;
-    pScreen->DestroyPixmap = pScreenPriv->DestroyPixmap;
-    pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;
-
-    /* We leave it up to the client to free the XAAInfoRec */
-
-    free((pointer) pScreenPriv);
-
-    return (*pScreen->CloseScreen) (i, pScreen);
-}
-
-static void
-XAAGetImage (
-    DrawablePtr pDraw,
-    int	sx, int sy, int w, int h,
-    unsigned int    format,
-    unsigned long   planemask,
-    char	    *pdstLine 
-)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = infoRec->pScrn;
-
-    if(pScrn->vtSema && 
-	((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) 
-    {
-	if(infoRec->ReadPixmap && (format == ZPixmap) && 
-	   ((planemask & infoRec->FullPlanemasks[pDraw->depth - 1]) == 
-                           infoRec->FullPlanemasks[pDraw->depth - 1]) &&
-	   (pDraw->bitsPerPixel == BitsPerPixel(pDraw->depth)))
-	{
-	    (*infoRec->ReadPixmap)(pScrn, 
-		   sx + pDraw->x, sy + pDraw->y, w, h,
-		   (unsigned char *)pdstLine,
-		   PixmapBytePad(w, pDraw->depth), 
-		   pDraw->bitsPerPixel, pDraw->depth);
-	    return;
-	}
-	SYNC_CHECK(pDraw);
-    }
-
-    XAA_SCREEN_PROLOGUE (pScreen, GetImage);
-    (*pScreen->GetImage) (pDraw, sx, sy, w, h, format, planemask, pdstLine);
-    XAA_SCREEN_EPILOGUE (pScreen, GetImage, XAAGetImage);
-}
-
-static void
-XAAGetSpans (
-    DrawablePtr pDraw,
-    int		wMax,
-    DDXPointPtr	ppt,
-    int		*pwidth,
-    int		nspans,
-    char	*pdstStart
-)
-{
-    ScreenPtr pScreen = pDraw->pScreen;
-    XAA_SCREEN_PROLOGUE (pScreen, GetSpans);
-    if(xf86Screens[pScreen->myNum]->vtSema && 
-	((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) {
-	SYNC_CHECK(pDraw);
-    }
-    (*pScreen->GetSpans) (pDraw, wMax, ppt, pwidth, nspans, pdstStart);
-    XAA_SCREEN_EPILOGUE (pScreen, GetSpans, XAAGetSpans);
-}
-
-
-static int
-XAAPixmapBPP (ScreenPtr pScreen, int depth)
-{
-    PixmapPtr	pPix;
-    int		bpp;
-    DestroyPixmapProcPtr    destroyPixmap;
-    
-    XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);
-    pPix = (*pScreen->CreatePixmap) (pScreen, 1, 1, depth,
-				     CREATE_PIXMAP_USAGE_SCRATCH);
-    XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);
-    if (!pPix)
-	return 0;
-    bpp = pPix->drawable.bitsPerPixel;
-    destroyPixmap = pScreen->DestroyPixmap;
-    XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap);
-    (*pScreen->DestroyPixmap) (pPix);
-    XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, destroyPixmap);
-    return bpp;
-}
-
-static void
-XAAInitializeOffscreenDepths (ScreenPtr pScreen)
-{
-    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr	    pScrn = xf86Screens[pScreen->myNum];
-    int		    d, dep;
-    
-    infoRec->offscreenDepthsInitialized = TRUE;
-    infoRec->offscreenDepths = 0;
-    if (infoRec->Flags & OFFSCREEN_PIXMAPS) {
-	for (d = 0; d < pScreen->numDepths; d++) {
-	    dep = pScreen->allowedDepths[d].depth;
-	    if (XAAPixmapBPP (pScreen, dep) == pScrn->bitsPerPixel)
-		infoRec->offscreenDepths |= (1 << (dep - 1));
-	}
-    }
-}
-
-static PixmapPtr 
-XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned class)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
-    XAAPixmapPtr pPriv;
-    PixmapPtr pPix = NULL;
-    int size = w * h;
-
-    if (w > 32767 || h > 32767)
-	return NullPixmap;
-    
-    if (!infoRec->offscreenDepthsInitialized)
-	XAAInitializeOffscreenDepths (pScreen);
-
-    if(pScrn->vtSema &&
-	(class != CREATE_PIXMAP_USAGE_GLYPH_PICTURE) &&
-	(infoRec->offscreenDepths & (1 << (depth - 1))) &&
-	(size >= MIN_OFFPIX_SIZE) && !SwitchedOut &&
-	(!infoRec->maxOffPixWidth || (w <= infoRec->maxOffPixWidth)) &&
-	(!infoRec->maxOffPixHeight || (h <= infoRec->maxOffPixHeight)) )
-    {
-        PixmapLinkPtr pLink;
-	PixmapPtr pScreenPix;
-        FBAreaPtr area;
-        int gran = 0;
-
-	switch(pScrn->bitsPerPixel) {
-        case 24: 
-        case 8:  gran = 4;  break;
-        case 16: gran = 2;  break;
-        case 32: gran = 1;  break;
-        default: break;
-        }
-
-        if(BITMAP_SCANLINE_PAD == 64)
-           gran *= 2;
-
-        if(!(area = xf86AllocateOffscreenArea(pScreen, w, h, gran, 0,
-                                XAARemoveAreaCallback, NULL))) {
-	    goto BAILOUT;
-	}
-
-        if(!(pLink = malloc(sizeof(PixmapLink)))) {
-            xf86FreeOffscreenArea(area);
-	    goto BAILOUT;
-	}
-
-	XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);
-	pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, depth, class);
-	XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);
-
-	if (!pPix) {
-	    free(pLink);
-            xf86FreeOffscreenArea(area);
-	    goto BAILOUT;
-	}
-	
-	pScreenPix = (*pScreen->GetScreenPixmap)(pScreen);
-
-	pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-	pPix->drawable.x = area->box.x1;
-	pPix->drawable.y = area->box.y1;
-	pPix->drawable.width = w;
-	pPix->drawable.height = h;
-	pPix->drawable.bitsPerPixel = pScrn->bitsPerPixel;
-	pPix->devKind = pScreenPix->devKind;
-	pPix->devPrivate.ptr = pScreenPix->devPrivate.ptr;
-	area->devPrivate.ptr = pPix;
-
-	pPriv->flags = OFFSCREEN;
-	pPriv->offscreenArea = area;
- 	pPriv->freeData = FALSE;
-	    
-	pLink->next = infoRec->OffscreenPixmaps;
-	pLink->pPix = pPix;
-	infoRec->OffscreenPixmaps = pLink;
-	return pPix;
-    }
-BAILOUT:
-    XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);
-    pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, class);
-    XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);
-
-    if(pPix) {
-       pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-       pPriv->flags = 0;
-       pPriv->offscreenArea = NULL;
-       pPriv->freeData = FALSE;
-       if(!w || !h) /* either scratch or shared memory */
-	    pPriv->flags |= SHARED_PIXMAP;
-    }
-
-    return pPix;
-}
-
-static Bool 
-XAADestroyPixmap(PixmapPtr pPix)
-{
-    ScreenPtr pScreen = pPix->drawable.pScreen;
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);
-    Bool ret;
-
-    if(pPix->refcnt == 1) {
-        if(pPriv->flags & OFFSCREEN) {
-	    if(pPriv->flags & DGA_PIXMAP)
-	        free(pPriv->offscreenArea);
-            else {
-	        FBAreaPtr area = pPriv->offscreenArea;
-		PixmapLinkPtr pLink = infoRec->OffscreenPixmaps;
-	        PixmapLinkPtr prev = NULL;
-
-		while(pLink->pPix != pPix) {
-		    prev = pLink;
-		    pLink = pLink->next;
-		}
-
-	        if(prev) prev->next = pLink->next;
-		else infoRec->OffscreenPixmaps = pLink->next;
-
-	        if(!area) area = pLink->area;
-
-	        xf86FreeOffscreenArea(area);
-	        pPriv->offscreenArea = NULL;
-	        free(pLink);
-	    } 
-        }
-
-        if(pPriv->freeData) { /* pixmaps that were once in video ram */
-	    free(pPix->devPrivate.ptr);
-	    pPix->devPrivate.ptr = NULL;
-	}
-    }
-    
-    XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap);
-    ret = (*pScreen->DestroyPixmap) (pPix);
-    XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, XAADestroyPixmap);
- 
-    return ret;
-}
-
-static Bool
-XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask)
-{
-   ScreenPtr pScreen = pWin->drawable.pScreen;
-   Bool ret;
-
-   XAA_SCREEN_PROLOGUE (pScreen, ChangeWindowAttributes);
-   ret = (*pScreen->ChangeWindowAttributes) (pWin, mask);
-   XAA_SCREEN_EPILOGUE (pScreen, ChangeWindowAttributes, XAAChangeWindowAttributes);
-
-   /* we have to assume that shared memory pixmaps are dirty
-      because we can't wrap operations on them */
-
-   if((mask & CWBackPixmap) && (pWin->backgroundState == BackgroundPixmap) &&
-      PIXMAP_IS_SHARED(pWin->background.pixmap))
-   {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->background.pixmap);
-	pPixPriv->flags |= DIRTY;
-   }
-   if((mask & CWBorderPixmap) && !(pWin->borderIsPixel) &&
-      PIXMAP_IS_SHARED(pWin->border.pixmap))
-   {
-        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->border.pixmap);
-        pPixPriv->flags |= DIRTY;
-   }
-
-   return ret;
-}
-
-
-
-/*  These two aren't really needed for anything */
-
-static Bool 
-XAAEnterVT(int index, int flags)
-{
-    ScrnInfoPtr pScrn = xf86Screens[index];
-    Bool ret;
-    ScreenPtr pScreen = screenInfo.screens[index];
-    XAAScreenPtr pScreenPriv = 
-	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    pScrn->EnterVT = pScreenPriv->EnterVT;
-    ret = ((*pScreenPriv->EnterVT)(index, flags));
-    pScreenPriv->EnterVT = pScrn->EnterVT;
-    pScrn->EnterVT = XAAEnterVT;
-    return ret;
-}
-
-static void 
-XAALeaveVT(int index, int flags)
-{
-    ScrnInfoPtr pScrn = xf86Screens[index];
-    ScreenPtr pScreen = screenInfo.screens[index];
-    XAAScreenPtr pScreenPriv = 
-	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-    XAAInfoRecPtr infoRec = pScreenPriv->AccelInfoRec;
-
-    if(infoRec->NeedToSync) {
-        (*infoRec->Sync)(infoRec->pScrn);
-        infoRec->NeedToSync = FALSE;
-    }
-
-    pScrn->LeaveVT = pScreenPriv->LeaveVT;
-    (*pScreenPriv->LeaveVT)(index, flags);
-    pScreenPriv->LeaveVT = pScrn->LeaveVT;
-    pScrn->LeaveVT = XAALeaveVT;
-}
-
-typedef struct {
-   Bool UsingPixmapCache;
-   Bool CanDoColor8x8;
-   Bool CanDoMono8x8;
-} SavedCacheState, *SavedCacheStatePtr;
-
-static int  
-XAASetDGAMode(int index, int num, DGADevicePtr devRet)
-{
-    ScreenPtr pScreen = screenInfo.screens[index];
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAScreenPtr pScreenPriv = 
-	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-    int ret;
-
-    if (!num && infoRec->dgaSaves) { /* restore old pixmap cache state */
-	SavedCacheStatePtr state = (SavedCacheStatePtr)infoRec->dgaSaves;
-	
-	infoRec->UsingPixmapCache = state->UsingPixmapCache;	
-	infoRec->CanDoColor8x8 = state->CanDoColor8x8;	
-	infoRec->CanDoMono8x8 = state->CanDoMono8x8;
-	free(infoRec->dgaSaves);
-	infoRec->dgaSaves = NULL;
-    }
-
-    ret = (*pScreenPriv->SetDGAMode)(index, num, devRet);
-    if(ret != Success) return ret;
-
-    if(num && devRet->pPix) {  /* accelerate this pixmap */
-	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(devRet->pPix);
-	FBAreaPtr area;
-
-	if((area = malloc(sizeof(FBArea)))) {
-	    area->pScreen = pScreen;
-	    area->box.x1 = 0;
-	    area->box.x2 = 0;
-	    area->box.y1 = devRet->mode->pixmapWidth;
-	    area->box.y2 = devRet->mode->pixmapHeight;
-	    area->granularity = 0;
-	    area->MoveAreaCallback = 0;
-	    area->RemoveAreaCallback = 0;
-	    area->devPrivate.ptr = 0;	
-
-	    pixPriv->flags |= OFFSCREEN | DGA_PIXMAP;
-	    pixPriv->offscreenArea = area;
-
-	    if(!infoRec->dgaSaves) { /* save pixmap cache state */
-		SavedCacheStatePtr state = malloc(sizeof(SavedCacheState));
-	
-		state->UsingPixmapCache = infoRec->UsingPixmapCache;	
-		state->CanDoColor8x8 = infoRec->CanDoColor8x8;	
-		state->CanDoMono8x8 = infoRec->CanDoMono8x8;	
-		infoRec->dgaSaves = (char*)state;
-
-		infoRec->UsingPixmapCache = FALSE;
-		if(infoRec->PixmapCacheFlags & CACHE_MONO_8x8)
-		    infoRec->CanDoMono8x8 = FALSE;
-		if(infoRec->PixmapCacheFlags & CACHE_COLOR_8x8)
-		    infoRec->CanDoColor8x8 = FALSE;
-	    }
-	}
-    }
-
-    return ret;
-}
-
-
-
-static void
-XAAEnableDisableFBAccess (int index, Bool enable)
-{
-    ScreenPtr pScreen = screenInfo.screens[index];
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);
-    XAAScreenPtr pScreenPriv = 
-	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);
-
-    if(!enable) {
-	if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))
-	    XAAMoveOutOffscreenPixmaps(pScreen);
-	if(infoRec->Flags & PIXMAP_CACHE)
-	    XAAInvalidatePixmapCache(pScreen);
-	SwitchedOut = TRUE;
-    }
-
-    (*pScreenPriv->EnableDisableFBAccess)(index, enable);
-
-    if(enable) {
-	if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))
-	    XAAMoveInOffscreenPixmaps(pScreen);
-	SwitchedOut = FALSE;
-    }
-}
+

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "windowstr.h"

+#include "xf86str.h"

+#include "mi.h"

+#include "miline.h"

+#include "xaa.h"

+#include "xaalocal.h"

+#include "xaawrap.h"

+#include "xf86fbman.h"

+#include "servermd.h"

+#ifdef COMPOSITE

+#include "cw.h"

+#endif

+

+#define MAX_PREALLOC_MEM	65536	/* MUST be >= 1024 */

+

+#define MIN_OFFPIX_SIZE		(320*200)

+

+static Bool XAACloseScreen(int i, ScreenPtr pScreen);

+static void XAAGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,

+			unsigned int format, unsigned long planemask,

+			char *pdstLine);

+static void XAAGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,

+			int *pwidth, int nspans, char *pdstStart);

+static PixmapPtr XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth,

+				 unsigned usage_hint);

+static Bool XAADestroyPixmap(PixmapPtr pPixmap);

+static Bool XAAEnterVT (int index, int flags);

+static void XAALeaveVT (int index, int flags);

+static int  XAASetDGAMode(int index, int num, DGADevicePtr devRet);

+static void XAAEnableDisableFBAccess (int index, Bool enable);

+static Bool XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask);

+

+static DevPrivateKeyRec XAAScreenKeyRec;

+#define XAAScreenKey (&XAAScreenKeyRec)

+static DevPrivateKeyRec XAAGCKeyRec;

+#define XAAGCKey (&XAAGCKeyRec)

+static DevPrivateKeyRec XAAPixmapKeyRec;

+#define XAAPixmapKey (&XAAPixmapKeyRec)

+

+DevPrivateKey XAAGetScreenKey(void) {

+    return XAAScreenKey;

+}

+

+DevPrivateKey XAAGetGCKey(void) {

+    return XAAGCKey;

+}

+

+DevPrivateKey XAAGetPixmapKey(void) {

+    return XAAPixmapKey;

+}

+

+/* temp kludge */

+static Bool SwitchedOut = FALSE;

+

+XAAInfoRecPtr

+XAACreateInfoRec(void)

+{

+    XAAInfoRecPtr infoRec;

+

+    infoRec = calloc(1, sizeof(XAAInfoRec));

+    if(infoRec)

+	infoRec->CachePixelGranularity = -1;

+

+    return infoRec;

+}

+

+void

+XAADestroyInfoRec(XAAInfoRecPtr infoRec)

+{

+    if(!infoRec) return;

+

+    if(infoRec->ClosePixmapCache)

+	(*infoRec->ClosePixmapCache)(infoRec->pScrn->pScreen);

+   

+    free(infoRec->PreAllocMem);

+

+    free(infoRec->PixmapCachePrivate);

+

+    free(infoRec);

+}

+

+

+Bool

+XAAInit(ScreenPtr pScreen, XAAInfoRecPtr infoRec)

+{

+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

+    XAAScreenPtr pScreenPriv;

+    int i;

+    PictureScreenPtr    ps = GetPictureScreenIfSet(pScreen);

+

+    /* Return successfully if no acceleration wanted */

+    if (!infoRec)

+	return TRUE;

+    

+    if (!dixRegisterPrivateKey(&XAAGCKeyRec, PRIVATE_GC, sizeof(XAAGCRec)))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&XAAPixmapKeyRec, PRIVATE_PIXMAP, sizeof(XAAPixmapRec)))

+	return FALSE;

+

+    if (!dixRegisterPrivateKey(&XAAScreenKeyRec, PRIVATE_SCREEN, 0))

+	return FALSE;

+

+    if (!(pScreenPriv = malloc(sizeof(XAAScreenRec))))

+	return FALSE;

+

+    dixSetPrivate(&pScreen->devPrivates, XAAScreenKey, pScreenPriv);

+

+    if(!xf86FBManagerRunning(pScreen))

+	infoRec->Flags &= ~(PIXMAP_CACHE | OFFSCREEN_PIXMAPS);

+    if(!(infoRec->Flags & LINEAR_FRAMEBUFFER))

+	infoRec->Flags &= ~OFFSCREEN_PIXMAPS;

+   

+    if(!infoRec->FullPlanemask) { /* for backwards compatibility */

+	infoRec->FullPlanemask =  (1 << pScrn->depth) - 1;

+	infoRec->FullPlanemasks[pScrn->depth - 1] = infoRec->FullPlanemask;

+    }

+

+    for(i = 0; i < 32; i++) {

+	if(!infoRec->FullPlanemasks[i]) /* keep any set by caller */

+	    infoRec->FullPlanemasks[i] = (1 << (i+1)) - 1;	

+    }

+

+    if(!XAAInitAccel(pScreen, infoRec)) return FALSE;

+    pScreenPriv->AccelInfoRec = infoRec;

+    infoRec->ScratchGC.pScreen = pScreen;

+

+    

+    if(!infoRec->GetImage)

+	infoRec->GetImage = XAAGetImage;

+    if(!infoRec->GetSpans)

+	infoRec->GetSpans = XAAGetSpans;

+    if(!infoRec->CopyWindow)

+	infoRec->CopyWindow = XAACopyWindow;

+

+    pScreenPriv->CreateGC = pScreen->CreateGC;

+    pScreen->CreateGC = XAACreateGC;

+    pScreenPriv->CloseScreen = pScreen->CloseScreen;

+    pScreen->CloseScreen = XAACloseScreen;

+    pScreenPriv->GetImage = pScreen->GetImage;

+    pScreen->GetImage = infoRec->GetImage;

+    pScreenPriv->GetSpans = pScreen->GetSpans;

+    pScreen->GetSpans = infoRec->GetSpans;

+    pScreenPriv->CopyWindow = pScreen->CopyWindow;

+    pScreen->CopyWindow = infoRec->CopyWindow;

+    pScreenPriv->CreatePixmap = pScreen->CreatePixmap;

+    pScreen->CreatePixmap = XAACreatePixmap;

+    pScreenPriv->DestroyPixmap = pScreen->DestroyPixmap;

+    pScreen->DestroyPixmap = XAADestroyPixmap;

+    pScreenPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;

+    pScreen->ChangeWindowAttributes = XAAChangeWindowAttributes;

+

+    pScreenPriv->EnterVT = pScrn->EnterVT;

+    pScrn->EnterVT = XAAEnterVT; 

+    pScreenPriv->LeaveVT = pScrn->LeaveVT;

+    pScrn->LeaveVT = XAALeaveVT;

+    pScreenPriv->SetDGAMode = pScrn->SetDGAMode;

+    pScrn->SetDGAMode = XAASetDGAMode;

+    pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;

+    pScrn->EnableDisableFBAccess = XAAEnableDisableFBAccess;

+

+    pScreenPriv->WindowExposures = pScreen->WindowExposures;

+    if (ps)

+    {

+	pScreenPriv->Composite = ps->Composite;

+	ps->Composite = XAAComposite;

+	pScreenPriv->Glyphs = ps->Glyphs;

+	ps->Glyphs = XAAGlyphs;

+    }

+    if(pScrn->overlayFlags & OVERLAY_8_32_PLANAR)

+        XAASetupOverlay8_32Planar(pScreen);

+

+    infoRec->PreAllocMem = malloc(MAX_PREALLOC_MEM);

+    if(infoRec->PreAllocMem)

+    	infoRec->PreAllocSize = MAX_PREALLOC_MEM;

+

+    if(infoRec->Flags & PIXMAP_CACHE) 

+	xf86RegisterFreeBoxCallback(pScreen, infoRec->InitPixmapCache,

+						(pointer)infoRec);

+

+    if(infoRec->Flags & MICROSOFT_ZERO_LINE_BIAS)

+	miSetZeroLineBias(pScreen, OCTANT1 | OCTANT2 | OCTANT3 | OCTANT4);

+

+#ifdef COMPOSITE

+    /* Initialize the composite wrapper.  This needs to happen after the

+     * wrapping above (so it comes before us), but before all other extensions,

+     * so it doesn't confuse them. (particularly damage).

+     */

+    miInitializeCompositeWrapper(pScreen);

+#endif

+

+    return TRUE;

+}

+

+

+

+static Bool

+XAACloseScreen (int i, ScreenPtr pScreen)

+{

+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

+    XAAScreenPtr pScreenPriv = 

+	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);

+

+    pScrn->EnterVT = pScreenPriv->EnterVT; 

+    pScrn->LeaveVT = pScreenPriv->LeaveVT; 

+    pScrn->EnableDisableFBAccess = pScreenPriv->EnableDisableFBAccess;

+   

+    pScreen->CreateGC = pScreenPriv->CreateGC;

+    pScreen->CloseScreen = pScreenPriv->CloseScreen;

+    pScreen->GetImage = pScreenPriv->GetImage;

+    pScreen->GetSpans = pScreenPriv->GetSpans;

+    pScreen->CopyWindow = pScreenPriv->CopyWindow;

+    pScreen->WindowExposures = pScreenPriv->WindowExposures;

+    pScreen->CreatePixmap = pScreenPriv->CreatePixmap;

+    pScreen->DestroyPixmap = pScreenPriv->DestroyPixmap;

+    pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;

+

+    /* We leave it up to the client to free the XAAInfoRec */

+

+    free((pointer) pScreenPriv);

+

+    return (*pScreen->CloseScreen) (i, pScreen);

+}

+

+static void

+XAAGetImage (

+    DrawablePtr pDraw,

+    int	sx, int sy, int w, int h,

+    unsigned int    format,

+    unsigned long   planemask,

+    char	    *pdstLine 

+)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    ScrnInfoPtr pScrn = infoRec->pScrn;

+

+    if(pScrn->vtSema && 

+	((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) 

+    {

+	if(infoRec->ReadPixmap && (format == ZPixmap) && 

+	   ((planemask & infoRec->FullPlanemasks[pDraw->depth - 1]) == 

+                           infoRec->FullPlanemasks[pDraw->depth - 1]) &&

+	   (pDraw->bitsPerPixel == BitsPerPixel(pDraw->depth)))

+	{

+	    (*infoRec->ReadPixmap)(pScrn, 

+		   sx + pDraw->x, sy + pDraw->y, w, h,

+		   (unsigned char *)pdstLine,

+		   PixmapBytePad(w, pDraw->depth), 

+		   pDraw->bitsPerPixel, pDraw->depth);

+	    return;

+	}

+	SYNC_CHECK(pDraw);

+    }

+

+    XAA_SCREEN_PROLOGUE (pScreen, GetImage);

+    (*pScreen->GetImage) (pDraw, sx, sy, w, h, format, planemask, pdstLine);

+    XAA_SCREEN_EPILOGUE (pScreen, GetImage, XAAGetImage);

+}

+

+static void

+XAAGetSpans (

+    DrawablePtr pDraw,

+    int		wMax,

+    DDXPointPtr	ppt,

+    int		*pwidth,

+    int		nspans,

+    char	*pdstStart

+)

+{

+    ScreenPtr pScreen = pDraw->pScreen;

+    XAA_SCREEN_PROLOGUE (pScreen, GetSpans);

+    if(xf86Screens[pScreen->myNum]->vtSema && 

+	((pDraw->type == DRAWABLE_WINDOW) || IS_OFFSCREEN_PIXMAP(pDraw))) {

+	SYNC_CHECK(pDraw);

+    }

+    (*pScreen->GetSpans) (pDraw, wMax, ppt, pwidth, nspans, pdstStart);

+    XAA_SCREEN_EPILOGUE (pScreen, GetSpans, XAAGetSpans);

+}

+

+

+static int

+XAAPixmapBPP (ScreenPtr pScreen, int depth)

+{

+    PixmapPtr	pPix;

+    int		bpp;

+    DestroyPixmapProcPtr    destroyPixmap;

+    

+    XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);

+    pPix = (*pScreen->CreatePixmap) (pScreen, 1, 1, depth,

+				     CREATE_PIXMAP_USAGE_SCRATCH);

+    XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);

+    if (!pPix)

+	return 0;

+    bpp = pPix->drawable.bitsPerPixel;

+    destroyPixmap = pScreen->DestroyPixmap;

+    XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap);

+    (*pScreen->DestroyPixmap) (pPix);

+    XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, destroyPixmap);

+    return bpp;

+}

+

+static void

+XAAInitializeOffscreenDepths (ScreenPtr pScreen)

+{

+    XAAInfoRecPtr   infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    ScrnInfoPtr	    pScrn = xf86Screens[pScreen->myNum];

+    int		    d, dep;

+    

+    infoRec->offscreenDepthsInitialized = TRUE;

+    infoRec->offscreenDepths = 0;

+    if (infoRec->Flags & OFFSCREEN_PIXMAPS) {

+	for (d = 0; d < pScreen->numDepths; d++) {

+	    dep = pScreen->allowedDepths[d].depth;

+	    if (XAAPixmapBPP (pScreen, dep) == pScrn->bitsPerPixel)

+		infoRec->offscreenDepths |= (1 << (dep - 1));

+	}

+    }

+}

+

+static PixmapPtr 

+XAACreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned usage_hint)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];

+    XAAPixmapPtr pPriv;

+    PixmapPtr pPix = NULL;

+    int size = w * h;

+

+    if (w > 32767 || h > 32767)

+	return NullPixmap;

+    

+    if (!infoRec->offscreenDepthsInitialized)

+	XAAInitializeOffscreenDepths (pScreen);

+

+    if(pScrn->vtSema &&

+	(usage_hint != CREATE_PIXMAP_USAGE_GLYPH_PICTURE) &&

+	(infoRec->offscreenDepths & (1 << (depth - 1))) &&

+	(size >= MIN_OFFPIX_SIZE) && !SwitchedOut &&

+	(!infoRec->maxOffPixWidth || (w <= infoRec->maxOffPixWidth)) &&

+	(!infoRec->maxOffPixHeight || (h <= infoRec->maxOffPixHeight)) )

+    {

+        PixmapLinkPtr pLink;

+	PixmapPtr pScreenPix;

+        FBAreaPtr area;

+        int gran = 0;

+

+	switch(pScrn->bitsPerPixel) {

+        case 24: 

+        case 8:  gran = 4;  break;

+        case 16: gran = 2;  break;

+        case 32: gran = 1;  break;

+        default: break;

+        }

+

+        if(BITMAP_SCANLINE_PAD == 64)

+           gran *= 2;

+

+        if(!(area = xf86AllocateOffscreenArea(pScreen, w, h, gran, 0,

+                                XAARemoveAreaCallback, NULL))) {

+	    goto BAILOUT;

+	}

+

+        if(!(pLink = malloc(sizeof(PixmapLink)))) {

+            xf86FreeOffscreenArea(area);

+	    goto BAILOUT;

+	}

+

+	XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);

+	pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, depth, usage_hint);

+	XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);

+

+	if (!pPix) {

+	    free(pLink);

+            xf86FreeOffscreenArea(area);

+	    goto BAILOUT;

+	}

+	

+	pScreenPix = (*pScreen->GetScreenPixmap)(pScreen);

+

+	pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);

+	pPix->drawable.x = area->box.x1;

+	pPix->drawable.y = area->box.y1;

+	pPix->drawable.width = w;

+	pPix->drawable.height = h;

+	pPix->drawable.bitsPerPixel = pScrn->bitsPerPixel;

+	pPix->devKind = pScreenPix->devKind;

+	pPix->devPrivate.ptr = pScreenPix->devPrivate.ptr;

+	area->devPrivate.ptr = pPix;

+

+	pPriv->flags = OFFSCREEN;

+	pPriv->offscreenArea = area;

+ 	pPriv->freeData = FALSE;

+	    

+	pLink->next = infoRec->OffscreenPixmaps;

+	pLink->pPix = pPix;

+	infoRec->OffscreenPixmaps = pLink;

+	return pPix;

+    }

+BAILOUT:

+    XAA_SCREEN_PROLOGUE (pScreen, CreatePixmap);

+    pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint);

+    XAA_SCREEN_EPILOGUE (pScreen, CreatePixmap, XAACreatePixmap);

+

+    if(pPix) {

+       pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);

+       pPriv->flags = 0;

+       pPriv->offscreenArea = NULL;

+       pPriv->freeData = FALSE;

+       if(!w || !h) /* either scratch or shared memory */

+	    pPriv->flags |= SHARED_PIXMAP;

+    }

+

+    return pPix;

+}

+

+static Bool 

+XAADestroyPixmap(PixmapPtr pPix)

+{

+    ScreenPtr pScreen = pPix->drawable.pScreen;

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pPix);

+    Bool ret;

+

+    if(pPix->refcnt == 1) {

+        if(pPriv->flags & OFFSCREEN) {

+	    if(pPriv->flags & DGA_PIXMAP)

+	        free(pPriv->offscreenArea);

+            else {

+	        FBAreaPtr area = pPriv->offscreenArea;

+		PixmapLinkPtr pLink = infoRec->OffscreenPixmaps;

+	        PixmapLinkPtr prev = NULL;

+

+		while(pLink->pPix != pPix) {

+		    prev = pLink;

+		    pLink = pLink->next;

+		}

+

+	        if(prev) prev->next = pLink->next;

+		else infoRec->OffscreenPixmaps = pLink->next;

+

+	        if(!area) area = pLink->area;

+

+	        xf86FreeOffscreenArea(area);

+	        pPriv->offscreenArea = NULL;

+	        free(pLink);

+	    } 

+        }

+

+        if(pPriv->freeData) { /* pixmaps that were once in video ram */

+	    free(pPix->devPrivate.ptr);

+	    pPix->devPrivate.ptr = NULL;

+	}

+    }

+    

+    XAA_SCREEN_PROLOGUE (pScreen, DestroyPixmap);

+    ret = (*pScreen->DestroyPixmap) (pPix);

+    XAA_SCREEN_EPILOGUE (pScreen, DestroyPixmap, XAADestroyPixmap);

+ 

+    return ret;

+}

+

+static Bool

+XAAChangeWindowAttributes (WindowPtr pWin, unsigned long mask)

+{

+   ScreenPtr pScreen = pWin->drawable.pScreen;

+   Bool ret;

+

+   XAA_SCREEN_PROLOGUE (pScreen, ChangeWindowAttributes);

+   ret = (*pScreen->ChangeWindowAttributes) (pWin, mask);

+   XAA_SCREEN_EPILOGUE (pScreen, ChangeWindowAttributes, XAAChangeWindowAttributes);

+

+   /* we have to assume that shared memory pixmaps are dirty

+      because we can't wrap operations on them */

+

+   if((mask & CWBackPixmap) && (pWin->backgroundState == BackgroundPixmap) &&

+      PIXMAP_IS_SHARED(pWin->background.pixmap))

+   {

+        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->background.pixmap);

+	pPixPriv->flags |= DIRTY;

+   }

+   if((mask & CWBorderPixmap) && !(pWin->borderIsPixel) &&

+      PIXMAP_IS_SHARED(pWin->border.pixmap))

+   {

+        XAAPixmapPtr pPixPriv = XAA_GET_PIXMAP_PRIVATE(pWin->border.pixmap);

+        pPixPriv->flags |= DIRTY;

+   }

+

+   return ret;

+}

+

+

+

+/*  These two aren't really needed for anything */

+

+static Bool 

+XAAEnterVT(int index, int flags)

+{

+    ScrnInfoPtr pScrn = xf86Screens[index];

+    Bool ret;

+    ScreenPtr pScreen = screenInfo.screens[index];

+    XAAScreenPtr pScreenPriv = 

+	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);

+

+    pScrn->EnterVT = pScreenPriv->EnterVT;

+    ret = ((*pScreenPriv->EnterVT)(index, flags));

+    pScreenPriv->EnterVT = pScrn->EnterVT;

+    pScrn->EnterVT = XAAEnterVT;

+    return ret;

+}

+

+static void 

+XAALeaveVT(int index, int flags)

+{

+    ScrnInfoPtr pScrn = xf86Screens[index];

+    ScreenPtr pScreen = screenInfo.screens[index];

+    XAAScreenPtr pScreenPriv = 

+	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);

+    XAAInfoRecPtr infoRec = pScreenPriv->AccelInfoRec;

+

+    if(infoRec->NeedToSync) {

+        (*infoRec->Sync)(infoRec->pScrn);

+        infoRec->NeedToSync = FALSE;

+    }

+

+    pScrn->LeaveVT = pScreenPriv->LeaveVT;

+    (*pScreenPriv->LeaveVT)(index, flags);

+    pScreenPriv->LeaveVT = pScrn->LeaveVT;

+    pScrn->LeaveVT = XAALeaveVT;

+}

+

+typedef struct {

+   Bool UsingPixmapCache;

+   Bool CanDoColor8x8;

+   Bool CanDoMono8x8;

+} SavedCacheState, *SavedCacheStatePtr;

+

+static int  

+XAASetDGAMode(int index, int num, DGADevicePtr devRet)

+{

+    ScreenPtr pScreen = screenInfo.screens[index];

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    XAAScreenPtr pScreenPriv = 

+	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);

+    int ret;

+

+    if (!num && infoRec->dgaSaves) { /* restore old pixmap cache state */

+	SavedCacheStatePtr state = (SavedCacheStatePtr)infoRec->dgaSaves;

+	

+	infoRec->UsingPixmapCache = state->UsingPixmapCache;	

+	infoRec->CanDoColor8x8 = state->CanDoColor8x8;	

+	infoRec->CanDoMono8x8 = state->CanDoMono8x8;

+	free(infoRec->dgaSaves);

+	infoRec->dgaSaves = NULL;

+    }

+

+    ret = (*pScreenPriv->SetDGAMode)(index, num, devRet);

+    if(ret != Success) return ret;

+

+    if(num && devRet->pPix) {  /* accelerate this pixmap */

+	XAAPixmapPtr pixPriv = XAA_GET_PIXMAP_PRIVATE(devRet->pPix);

+	FBAreaPtr area;

+

+	if((area = malloc(sizeof(FBArea)))) {

+	    area->pScreen = pScreen;

+	    area->box.x1 = 0;

+	    area->box.x2 = 0;

+	    area->box.y1 = devRet->mode->pixmapWidth;

+	    area->box.y2 = devRet->mode->pixmapHeight;

+	    area->granularity = 0;

+	    area->MoveAreaCallback = 0;

+	    area->RemoveAreaCallback = 0;

+	    area->devPrivate.ptr = 0;	

+

+	    pixPriv->flags |= OFFSCREEN | DGA_PIXMAP;

+	    pixPriv->offscreenArea = area;

+

+	    if(!infoRec->dgaSaves) { /* save pixmap cache state */

+		SavedCacheStatePtr state = malloc(sizeof(SavedCacheState));

+	

+		state->UsingPixmapCache = infoRec->UsingPixmapCache;	

+		state->CanDoColor8x8 = infoRec->CanDoColor8x8;	

+		state->CanDoMono8x8 = infoRec->CanDoMono8x8;	

+		infoRec->dgaSaves = (char*)state;

+

+		infoRec->UsingPixmapCache = FALSE;

+		if(infoRec->PixmapCacheFlags & CACHE_MONO_8x8)

+		    infoRec->CanDoMono8x8 = FALSE;

+		if(infoRec->PixmapCacheFlags & CACHE_COLOR_8x8)

+		    infoRec->CanDoColor8x8 = FALSE;

+	    }

+	}

+    }

+

+    return ret;

+}

+

+

+

+static void

+XAAEnableDisableFBAccess (int index, Bool enable)

+{

+    ScreenPtr pScreen = screenInfo.screens[index];

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCREEN(pScreen);

+    XAAScreenPtr pScreenPriv = 

+	(XAAScreenPtr)dixLookupPrivate(&pScreen->devPrivates, XAAScreenKey);

+

+    if(!enable) {

+	if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))

+	    XAAMoveOutOffscreenPixmaps(pScreen);

+	if(infoRec->Flags & PIXMAP_CACHE)

+	    XAAInvalidatePixmapCache(pScreen);

+	SwitchedOut = TRUE;

+    }

+

+    (*pScreenPriv->EnableDisableFBAccess)(index, enable);

+

+    if(enable) {

+	if((infoRec->Flags & OFFSCREEN_PIXMAPS) && (infoRec->OffscreenPixmaps))

+	    XAAMoveInOffscreenPixmaps(pScreen);

+	SwitchedOut = FALSE;

+    }

+}