xserver mesa git update 10 Mar 2011

5 files changed, 3107 insertions, 3105 deletions

diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index 9602e899f..5312ca60d 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -1787,9 +1787,11 @@ configScreen(confScreenPtr screenp, XF86ConfScreenPtr conf_screen, int scrnum,
     XF86ConfDisplayPtr dispptr;
     XF86ConfAdaptorLinkPtr conf_adaptor;
     Bool defaultMonitor = FALSE;
+    XF86ConfScreenRec local_conf_screen;
 
     if (!conf_screen) {
-        conf_screen = xnfcalloc(1, sizeof(XF86ConfScreenRec));
+        memset(&local_conf_screen, 0, sizeof(local_conf_screen));
+        conf_screen = &local_conf_screen;
         conf_screen->scrn_identifier = "Default Screen Section";
         xf86Msg(X_DEFAULT, "No screen section available. Using defaults.\n");
     }
diff --git a/xorg-server/hw/xfree86/common/xf86VGAarbiter.c b/xorg-server/hw/xfree86/common/xf86VGAarbiter.c
index 0aa6f2cf4..c5ebb2780 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 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

+/*
+ * 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
diff --git a/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h b/xorg-server/hw/xfree86/common/xf86VGAarbiterPriv.h
index 13fde5e79..e1ac20f1f 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 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);

+/*
+ * 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);
diff --git a/xorg-server/hw/xfree86/vbe/vbe.c b/xorg-server/hw/xfree86/vbe/vbe.c
index 5120b3199..04132d956 100644
--- a/xorg-server/hw/xfree86/vbe/vbe.c
+++ b/xorg-server/hw/xfree86/vbe/vbe.c
@@ -1,1089 +1,1089 @@
-

-/*

- *                   XFree86 vbe module

- *               Copyright 2000 Egbert Eich

- *

- * The mode query/save/set/restore functions from the vesa driver 

- * have been moved here.

- * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)

- * Authors: Paulo César Pereira de Andrade <pcpa@conectiva.com.br> 

- */

-

-#ifdef HAVE_XORG_CONFIG_H

-#include <xorg-config.h>

-#endif

-

-#include <string.h>

-

-#include "xf86.h"

-#include "vbe.h"

-#include <X11/extensions/dpmsconst.h>

-

-#define VERSION(x) VBE_VERSION_MAJOR(x),VBE_VERSION_MINOR(x)

-

-#if X_BYTE_ORDER == X_LITTLE_ENDIAN

-#define B_O16(x)  (x) 

-#define B_O32(x)  (x)

-#else

-#define B_O16(x)  ((((x) & 0xff) << 8) | (((x) & 0xff) >> 8))

-#define B_O32(x)  ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) \

-                  | (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))

-#endif

-#define L_ADD(x)  (B_O32(x) & 0xffff) + ((B_O32(x) >> 12) & 0xffff00)

-

-#define FARP(p)		(((unsigned)(p & 0xffff0000) >> 12) | (p & 0xffff))

-#define R16(v)		((v) & 0xffff)

-

-static unsigned char * vbeReadEDID(vbeInfoPtr pVbe);

-static Bool vbeProbeDDC(vbeInfoPtr pVbe);

-

-static const char vbeVersionString[] = "VBE2";

-

-vbeInfoPtr

-VBEInit(xf86Int10InfoPtr pInt, int entityIndex)

-{

-    return VBEExtendedInit(pInt, entityIndex, 0);

-}

-

-vbeInfoPtr

-VBEExtendedInit(xf86Int10InfoPtr pInt, int entityIndex, int Flags)

-{

-    int RealOff;

-    pointer page = NULL;

-    ScrnInfoPtr pScrn = xf86FindScreenForEntity(entityIndex);

-    vbeControllerInfoPtr vbe = NULL;

-    Bool init_int10 = FALSE;

-    vbeInfoPtr vip = NULL;

-    int screen;

-

-    if (!pScrn) return NULL;

-    screen = pScrn->scrnIndex;

-    

-    if (!pInt) {

-	if (!xf86LoadSubModule(pScrn, "int10"))

-	    goto error;

-

-	xf86DrvMsg(screen,X_INFO,"initializing int10\n");

-	pInt = xf86ExtendedInitInt10(entityIndex,Flags);

-	if (!pInt)

-	    goto error;

-	init_int10 = TRUE;

-    }

-    

-    page = xf86Int10AllocPages(pInt,1,&RealOff);

-    if (!page) goto error;

-    vbe = (vbeControllerInfoPtr) page;    

-    memcpy(vbe->VbeSignature,vbeVersionString,4);

-

-    pInt->ax = 0x4F00;

-    pInt->es = SEG_ADDR(RealOff);

-    pInt->di = SEG_OFF(RealOff);

-    pInt->num = 0x10;

-    

-    xf86ExecX86int10(pInt);

-

-    if ((pInt->ax & 0xff) != 0x4f) {

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA BIOS not detected\n");

-	goto error;

-    }

-    

-    switch (pInt->ax & 0xff00) {

-    case 0:

-	xf86DrvMsg(screen,X_INFO,"VESA BIOS detected\n");

-	break;

-    case 0x100:

-	xf86DrvMsg(screen,X_INFO,"VESA BIOS function failed\n");

-	goto error;

-    case 0x200:

-	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported\n");

-	goto error;

-    case 0x300:

-	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported in current mode\n");

-	goto error;

-    default:

-	xf86DrvMsg(screen,X_INFO,"Invalid\n");

-	goto error;

-    }

-    

-    xf86DrvMsgVerb(screen, X_INFO, 4,

-		"VbeVersion is %d, OemStringPtr is 0x%08lx,\n"

-		"\tOemVendorNamePtr is 0x%08lx, OemProductNamePtr is 0x%08lx,\n"

-		"\tOemProductRevPtr is 0x%08lx\n",

-		vbe->VbeVersion, (unsigned long)vbe->OemStringPtr,

-		(unsigned long)vbe->OemVendorNamePtr,

-		(unsigned long)vbe->OemProductNamePtr,

-		(unsigned long)vbe->OemProductRevPtr);

-

-    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Version %i.%i\n",

-		   VERSION(vbe->VbeVersion));

-    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Total Mem: %i kB\n",

-		   vbe->TotalMem * 64);

-    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM: %s\n",

-		   (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemStringPtr)));

-    

-    if (B_O16(vbe->VbeVersion) >= 0x200) {

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Software Rev: %i.%i\n",

-		    VERSION(vbe->OemSoftwareRev));

-	if (vbe->OemVendorNamePtr)

-	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Vendor: %s\n",

-		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemVendorNamePtr)));

-	if (vbe->OemProductNamePtr)

-	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product: %s\n",

-		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductNamePtr)));

-	if (vbe->OemProductRevPtr)

-	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product Rev: %s\n",

-		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductRevPtr)));

-    }

-    vip = (vbeInfoPtr)xnfalloc(sizeof(vbeInfoRec));

-    vip->version = B_O16(vbe->VbeVersion);

-    vip->pInt10 = pInt;

-    vip->ddc = DDC_UNCHECKED;

-    vip->memory = page;

-    vip->real_mode_base = RealOff;

-    vip->num_pages = 1;

-    vip->init_int10 = init_int10;

-

-    return vip;

-

- error:

-    if (page)

-	xf86Int10FreePages(pInt, page, 1);

-    if (init_int10)

-	xf86FreeInt10(pInt);

-    return NULL;

-}

-

-void

-vbeFree(vbeInfoPtr pVbe)

-{

-    if (!pVbe)

-	return;

-

-    xf86Int10FreePages(pVbe->pInt10,pVbe->memory,pVbe->num_pages);

-    /* If we have initalized int10 we ought to free it, too */

-    if (pVbe->init_int10) 

-	xf86FreeInt10(pVbe->pInt10);

-    free(pVbe);

-    return;

-}

-

-static Bool

-vbeProbeDDC(vbeInfoPtr pVbe)

-{

-    char *ddc_level;

-    int screen = pVbe->pInt10->scrnIndex;

-    

-    if (pVbe->ddc == DDC_NONE)

-	return FALSE;

-    if (pVbe->ddc != DDC_UNCHECKED)

-	return TRUE;

-

-    pVbe->pInt10->ax = 0x4F15;

-    pVbe->pInt10->bx = 0;

-    pVbe->pInt10->cx = 0;

-    pVbe->pInt10->es = 0;

-    pVbe->pInt10->di = 0;

-    pVbe->pInt10->num = 0x10;

-

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {

-        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC not supported\n");

-	pVbe->ddc = DDC_NONE;

-	return FALSE;

-    }

-

-    switch ((pVbe->pInt10->ax >> 8) & 0xff) {

-    case 0:

-	xf86DrvMsg(screen,X_INFO,"VESA VBE DDC supported\n");

-	switch (pVbe->pInt10->bx & 0x3) {

-	case 0:

-  	    ddc_level = " none"; 

-	    pVbe->ddc = DDC_NONE;

-	    break;

-	case 1:

-  	    ddc_level = " 1";

-	    pVbe->ddc = DDC_1;

-	    break;

-	case 2:

-  	    ddc_level = " 2"; 

-	    pVbe->ddc = DDC_2;

-	    break;

-	case 3:

-  	    ddc_level = " 1 + 2"; 

-	    pVbe->ddc = DDC_1_2;

-	    break;

-	default:

- 	    ddc_level = "";

-	    pVbe->ddc = DDC_NONE;

-	    break;

-	}

-  	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Level%s\n",ddc_level); 

-  	if (pVbe->pInt10->bx & 0x4) {

-    	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Screen blanked" 

-    			"for data transfer\n"); 

-    	    pVbe->ddc_blank = TRUE;

-    	}  else

-    	    pVbe->ddc_blank = FALSE;

-	    

-  	xf86DrvMsgVerb(screen,X_INFO,3,

-		       "VESA VBE DDC transfer in appr. %x sec.\n", 

-		       (pVbe->pInt10->bx >> 8) & 0xff); 

-    }

-    

-    return TRUE; 

-}

-

-typedef enum {

-  VBEOPT_NOVBE,

-    VBEOPT_NODDC

-} VBEOpts;

-

-static const OptionInfoRec VBEOptions[] = {

-    { VBEOPT_NOVBE,	"NoVBE",	OPTV_BOOLEAN,	{0},	FALSE },

-    { VBEOPT_NODDC,	"NoDDC",	OPTV_BOOLEAN,	{0},	FALSE },

-    { -1,		NULL,		OPTV_NONE,	{0},	FALSE },

-};

-

-static unsigned char *

-vbeReadEDID(vbeInfoPtr pVbe)

-{

-    int RealOff = pVbe->real_mode_base;

-    pointer page = pVbe->memory;

-    unsigned char *tmp = NULL;

-    Bool novbe = FALSE;

-    Bool noddc = FALSE;

-    int screen = pVbe->pInt10->scrnIndex;

-    OptionInfoPtr options;

-

-    if (!page) return NULL;

-

-    options = xnfalloc(sizeof(VBEOptions));

-    (void)memcpy(options, VBEOptions, sizeof(VBEOptions));

-    xf86ProcessOptions(screen, xf86Screens[screen]->options, options);

-    xf86GetOptValBool(options, VBEOPT_NOVBE, &novbe);

-    xf86GetOptValBool(options, VBEOPT_NODDC, &noddc);

-    free(options);

-    if (novbe || noddc) return NULL;

-    

-    if (!vbeProbeDDC(pVbe)) goto error;

-

-    memset(page,0,sizeof(vbeInfoPtr));

-    strcpy(page,vbeVersionString);

-

-    pVbe->pInt10->ax = 0x4F15;

-    pVbe->pInt10->bx = 0x01;

-    pVbe->pInt10->cx = 0;

-    pVbe->pInt10->dx = 0;

-    pVbe->pInt10->es = SEG_ADDR(RealOff);

-    pVbe->pInt10->di = SEG_OFF(RealOff);

-    pVbe->pInt10->num = 0x10;

-

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {

-        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC invalid\n");

-	goto error;

-    }

-    switch (pVbe->pInt10->ax & 0xff00) {

-    case 0x0:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read successfully\n");

-  	tmp = (unsigned char *)xnfalloc(128); 

-  	memcpy(tmp,page,128); 

-	break;

-    case 0x100:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read failed\n");	

-	break;

-    default:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC unkown failure %i\n",

-		       pVbe->pInt10->ax & 0xff00);

-	break;

-    }

-    

- error:

-    return tmp;

-}

-

-xf86MonPtr

-vbeDoEDID(vbeInfoPtr pVbe, pointer pDDCModule)

-{

-    xf86MonPtr    pMonitor;

-    pointer       pModule;

-    unsigned char *DDC_data = NULL;

-    

-    if (!pVbe) return NULL;

-    if (pVbe->version < 0x200)

-	return NULL;

-

-    if (!(pModule = pDDCModule)) {

-	pModule =

-	    xf86LoadSubModule(xf86Screens[pVbe->pInt10->scrnIndex], "ddc");

-	if (!pModule)

-	    return NULL;

-    }

-        

-    DDC_data = vbeReadEDID(pVbe);

-

-    if (!DDC_data) 

-	return NULL;

-    

-    pMonitor = xf86InterpretEDID(pVbe->pInt10->scrnIndex, DDC_data);

-

-    if (!pDDCModule)

-        xf86UnloadSubModule(pModule);

-    return pMonitor;

-}

-

-#define GET_UNALIGNED2(x) \

-            ((*(CARD16*)(x)) | (*(((CARD16*)(x) + 1))) << 16)

-

-VbeInfoBlock *

-VBEGetVBEInfo(vbeInfoPtr pVbe)

-{

-    VbeInfoBlock *block = NULL;

-    int i, pStr, pModes;

-    char *str;

-    CARD16 major, *modes;

-

-    memset(pVbe->memory, 0, sizeof(VbeInfoBlock));

-

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 00h	Return Super VGA information

-	ES:DI := Pointer to buffer

-

-    Output:

-	AX    := status

-	(All other registers are preserved)

-     */

-

-    ((char*)pVbe->memory)[0] = 'V';

-    ((char*)pVbe->memory)[1] = 'B';

-    ((char*)pVbe->memory)[2] = 'E';

-    ((char*)pVbe->memory)[3] = '2';

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f00;

-    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

-    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return NULL;

-

-    block = calloc(sizeof(VbeInfoBlock), 1);

-    block->VESASignature[0] = ((char*)pVbe->memory)[0];

-    block->VESASignature[1] = ((char*)pVbe->memory)[1];

-    block->VESASignature[2] = ((char*)pVbe->memory)[2];

-    block->VESASignature[3] = ((char*)pVbe->memory)[3];

-

-    block->VESAVersion = *(CARD16*)(((char*)pVbe->memory) + 4);

-    major = (unsigned)block->VESAVersion >> 8;

-

-    pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 6));

-    str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

-    block->OEMStringPtr = strdup(str);

-

-    block->Capabilities[0] = ((char*)pVbe->memory)[10];

-    block->Capabilities[1] = ((char*)pVbe->memory)[11];

-    block->Capabilities[2] = ((char*)pVbe->memory)[12];

-    block->Capabilities[3] = ((char*)pVbe->memory)[13];

-

-    pModes = GET_UNALIGNED2((((char*)pVbe->memory) + 14));

-    modes = xf86int10Addr(pVbe->pInt10, FARP(pModes));

-    i = 0;

-    while (modes[i] != 0xffff)

-	i++;

-    block->VideoModePtr = malloc(sizeof(CARD16) * i + 1);

-    memcpy(block->VideoModePtr, modes, sizeof(CARD16) * i);

-    block->VideoModePtr[i] = 0xffff;

-

-    block->TotalMemory = *(CARD16*)(((char*)pVbe->memory) + 18);

-

-    if (major < 2)

-	memcpy(&block->OemSoftwareRev, ((char*)pVbe->memory) + 20, 236);

-    else {

-	block->OemSoftwareRev = *(CARD16*)(((char*)pVbe->memory) + 20);

-	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 22));

-	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

-	block->OemVendorNamePtr = strdup(str);

-	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 26));

-	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

-	block->OemProductNamePtr = strdup(str);

-	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 30));

-	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

-	block->OemProductRevPtr = strdup(str);

-	memcpy(&block->Reserved, ((char*)pVbe->memory) + 34, 222);

-	memcpy(&block->OemData, ((char*)pVbe->memory) + 256, 256);

-    }

-

-    return block;

-}

-

-void

-VBEFreeVBEInfo(VbeInfoBlock *block)

-{

-    free(block->OEMStringPtr);

-    free(block->VideoModePtr);

-    if (((unsigned)block->VESAVersion >> 8) >= 2) {

-	free(block->OemVendorNamePtr);

-	free(block->OemProductNamePtr);

-	free(block->OemProductRevPtr);

-    }

-    free(block);

-}

-

-Bool

-VBESetVBEMode(vbeInfoPtr pVbe, int mode, VbeCRTCInfoBlock *block)

-{

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 02h	Set Super VGA video mode

-	BX    := Video mode

-	    D0-D8  := Mode number

-	    D9-D10 := Reserved (must be 0)

-	    D11    := 0 Use current default refresh rate

-		   := 1 Use user specified CRTC values for refresh rate

-	    D12-13	Reserved for VBE/AF (must be 0)

-	    D14    := 0 Use windowed frame buffer model

-		   := 1 Use linear/flat frame buffer model

-	    D15    := 0 Clear video memory

-		   := 1 Don't clear video memory

-	ES:DI := Pointer to VbeCRTCInfoBlock structure

-

-    Output: AX = Status

-	(All other registers are preserved)

-    */

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f02;

-    pVbe->pInt10->bx = mode;

-    if (block) {

-	pVbe->pInt10->bx |= 1 << 11;

-	memcpy(pVbe->memory, block, sizeof(VbeCRTCInfoBlock));

-	pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

-	pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

-    } else

-	pVbe->pInt10->bx &= ~(1 << 11);

-

-    xf86ExecX86int10(pVbe->pInt10);

-

-    return (R16(pVbe->pInt10->ax) == 0x4f);

-}

-

-Bool

-VBEGetVBEMode(vbeInfoPtr pVbe, int *mode)

-{

-    /*

-    Input:

-	AH := 4Fh	Super VGA support

-	AL := 03h	Return current video mode

-

-    Output:

-	AX := Status

-	BX := Current video mode

-	(All other registers are preserved)

-    */

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f03;

-

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) == 0x4f) {

-	*mode = R16(pVbe->pInt10->bx);

-

-	return TRUE;

-    }

-

-    return FALSE;

-}

-

-VbeModeInfoBlock *

-VBEGetModeInfo(vbeInfoPtr pVbe, int mode)

-{

-    VbeModeInfoBlock *block = NULL;

-

-    memset(pVbe->memory, 0, sizeof(VbeModeInfoBlock));

-

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 01h	Return Super VGA mode information

-	CX    := 	Super VGA video mode

-			(mode number must be one of those returned by Function 0)

-	ES:DI := Pointer to buffer

-

-    Output:

-	AX    := status

-	(All other registers are preserved)

-     */

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f01;

-    pVbe->pInt10->cx = mode;

-    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

-    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

-    xf86ExecX86int10(pVbe->pInt10);

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return NULL;

-

-    block = malloc(sizeof(VbeModeInfoBlock));

-    if (block)

-	memcpy(block, pVbe->memory, sizeof(*block));

-

-    return block;

-}

-

-void

-VBEFreeModeInfo(VbeModeInfoBlock *block)

-{

-    free(block);

-}

-

-Bool

-VBESaveRestore(vbeInfoPtr pVbe, vbeSaveRestoreFunction function, 

-	       pointer *memory, int *size, int *real_mode_pages)

-{

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 04h	Save/restore Super VGA video state

-	DL    := 00h	Return save/restore state buffer size

-	CX    := Requested states

-		D0 = Save/restore video hardware state

-		D1 = Save/restore video BIOS data state

-		D2 = Save/restore video DAC state

-		D3 = Save/restore Super VGA state

-

-    Output:

-	AX = Status

-	BX = Number of 64-byte blocks to hold the state buffer

-	(All other registers are preserved)

-

-

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 04h	Save/restore Super VGA video state

-	DL    := 01h	Save Super VGA video state

-	CX    := Requested states (see above)

-	ES:BX := Pointer to buffer

-

-    Output:

-	AX    := Status

-	(All other registers are preserved)

-

-

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 04h	Save/restore Super VGA video state

-	DL    := 02h	Restore Super VGA video state

-	CX    := Requested states (see above)

-	ES:BX := Pointer to buffer

-

-    Output:

-	AX     := Status

-	(All other registers are preserved)

-     */

-

-    if ((pVbe->version & 0xff00) > 0x100) {

-        int screen = pVbe->pInt10->scrnIndex;

-        if (function == MODE_QUERY ||

-	    (function == MODE_SAVE && !*memory)) {

-	    /* Query amount of memory to save state */

-

-	    pVbe->pInt10->num = 0x10;

-	    pVbe->pInt10->ax = 0x4f04;

-	    pVbe->pInt10->dx = 0;

-	    pVbe->pInt10->cx = 0x000f;

-	    xf86ExecX86int10(pVbe->pInt10);

-	    if (R16(pVbe->pInt10->ax) != 0x4f)

-	        return FALSE;

-

-	    if (function == MODE_SAVE) {

-	        int npages = (R16(pVbe->pInt10->bx) * 64) / 4096 + 1;

-		if ((*memory = xf86Int10AllocPages(pVbe->pInt10, npages,

-						   real_mode_pages)) == NULL) {

-		    xf86DrvMsg(screen, X_ERROR,

-			       "Cannot allocate memory to save SVGA state.\n");

-		    return FALSE;

-		}

-	    }

-	    *size = pVbe->pInt10->bx * 64;

-	}

-

-	/* Save/Restore Super VGA state */

-	if (function != MODE_QUERY) {

-	    

-	    if (!*memory) return FALSE;

-	    pVbe->pInt10->num = 0x10;

-	    pVbe->pInt10->ax = 0x4f04;

-	    switch (function) {

-	    case MODE_SAVE:

-	      pVbe->pInt10->dx = 1;

-	      break;

-	    case MODE_RESTORE:

-	      pVbe->pInt10->dx = 2;

-	      break;

-	    case MODE_QUERY:

-	      return FALSE;

-	    }

-	    pVbe->pInt10->cx = 0x000f;

-	    

-	    pVbe->pInt10->es = SEG_ADDR(*real_mode_pages);

-	    pVbe->pInt10->bx = SEG_OFF(*real_mode_pages);

-	    xf86ExecX86int10(pVbe->pInt10);

-	    return (R16(pVbe->pInt10->ax) == 0x4f);

-

-	}

-    }

-    return TRUE;

-}

-

-Bool

-VBEBankSwitch(vbeInfoPtr pVbe, unsigned int iBank, int window)

-{

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 05h

-

-    Output:

-     */

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f05;

-    pVbe->pInt10->bx = window;

-    pVbe->pInt10->dx = iBank;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return FALSE;

-

-    return TRUE;

-}

-

-Bool

-VBESetGetLogicalScanlineLength(vbeInfoPtr pVbe, vbeScanwidthCommand command,

-				int width, int *pixels, int *bytes, int *max)

-{

-    if (command < SCANWID_SET || command > SCANWID_GET_MAX)

-	return FALSE;

-

-    /*

-    Input:

-	AX := 4F06h VBE Set/Get Logical Scan Line Length

-	BL := 00h Set Scan Line Length in Pixels

-	   := 01h Get Scan Line Length

-	   := 02h Set Scan Line Length in Bytes

-	   := 03h Get Maximum Scan Line Length

-	CX := If BL=00h Desired Width in Pixels

-	      If BL=02h Desired Width in Bytes

-	      (Ignored for Get Functions)

-

-    Output:

-	AX := VBE Return Status

-	BX := Bytes Per Scan Line

-	CX := Actual Pixels Per Scan Line

-	      (truncated to nearest complete pixel)

-	DX := Maximum Number of Scan Lines

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f06;

-    pVbe->pInt10->bx = command;

-    if (command == SCANWID_SET || command == SCANWID_SET_BYTES)

-	pVbe->pInt10->cx = width;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return FALSE;

-

-    if (command == SCANWID_GET || command == SCANWID_GET_MAX) {

-	if (pixels)

-	    *pixels = R16(pVbe->pInt10->cx);

-	if (bytes)

-	    *bytes = R16(pVbe->pInt10->bx);

-	if (max)

-	    *max = R16(pVbe->pInt10->dx);

-    }

-

-    return TRUE;

-}

-

-Bool

-VBESetDisplayStart(vbeInfoPtr pVbe, int x, int y, Bool wait_retrace)

-{

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f07;

-    pVbe->pInt10->bx = wait_retrace ? 0x80 : 0x00;

-    pVbe->pInt10->cx = x;

-    pVbe->pInt10->dx = y;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return FALSE;

-

-    return TRUE;

-}

-

-Bool

-VBEGetDisplayStart(vbeInfoPtr pVbe, int *x, int *y)

-{

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f07;

-    pVbe->pInt10->bx = 0x01;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return FALSE;

-

-    *x = pVbe->pInt10->cx;

-    *y = pVbe->pInt10->dx;

-

-    return TRUE;

-}

-

-int

-VBESetGetDACPaletteFormat(vbeInfoPtr pVbe, int bits)

-{

-    /*

-    Input:

-	AX := 4F08h VBE Set/Get Palette Format

-	BL := 00h Set DAC Palette Format

-	   := 01h Get DAC Palette Format

-	BH := Desired bits of color per primary

-	      (Set DAC Palette Format only)

-

-    Output:

-	AX := VBE Return Status

-	BH := Current number of bits of color per primary

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f08;

-    if (!bits)

-	pVbe->pInt10->bx = 0x01;

-    else 

-	pVbe->pInt10->bx = (bits & 0x00ff) << 8;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return 0;

-

-    return (bits != 0 ? bits : (pVbe->pInt10->bx >> 8) & 0x00ff);

-}

-

-CARD32 *

-VBESetGetPaletteData(vbeInfoPtr pVbe, Bool set, int first, int num,

-		      CARD32 *data, Bool secondary, Bool wait_retrace)

-{

-    /*

-    Input:

-    (16-bit)

-	AX    := 4F09h VBE Load/Unload Palette Data

-	BL    := 00h Set Palette Data

-	      := 01h Get Palette Data

-	      := 02h Set Secondary Palette Data

-	      := 03h Get Secondary Palette Data

-	      := 80h Set Palette Data during Vertical Retrace

-	CX    := Number of palette registers to update (to a maximum of 256)

-	DX    := First of the palette registers to update (start)

-	ES:DI := Table of palette values (see below for format)

-

-    Output:

-	AX    := VBE Return Status

-

-

-    Input:

-    (32-bit)

-	BL     := 00h Set Palette Data

-	       := 80h Set Palette Data during Vertical Retrace

-	CX     := Number of palette registers to update (to a maximum of 256)

-	DX     := First of the palette registers to update (start)

-	ES:EDI := Table of palette values (see below for format)

-	DS     := Selector for memory mapped registers

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f09;

-    if (!secondary)

-	pVbe->pInt10->bx = set && wait_retrace ? 0x80 : set ? 0 : 1;

-    else

-	pVbe->pInt10->bx = set ? 2 : 3;

-    pVbe->pInt10->cx = num;

-    pVbe->pInt10->dx = first;

-    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

-    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

-    if (set)

-	memcpy(pVbe->memory, data, num * sizeof(CARD32));

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return NULL;

-

-    if (set)

-	return data;

-

-    data = malloc(num * sizeof(CARD32));

-    memcpy(data, pVbe->memory, num * sizeof(CARD32));

-

-    return data;

-}

-

-VBEpmi *

-VBEGetVBEpmi(vbeInfoPtr pVbe)

-{

-    VBEpmi *pmi;

-

-    /*

-    Input:

-	AH    := 4Fh	Super VGA support

-	AL    := 0Ah	Protected Mode Interface

-	BL    := 00h	Return Protected Mode Table

-

-    Output:

-	AX    := Status

-	ES    := Real Mode Segment of Table

-	DI    := Offset of Table

-	CX    := Lenght of Table including protected mode code in bytes (for copying purposes)

-	(All other registers are preserved)

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f0a;

-    pVbe->pInt10->bx = 0;

-    pVbe->pInt10->di = 0;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return NULL;

-

-    pmi = malloc(sizeof(VBEpmi));

-    pmi->seg_tbl = R16(pVbe->pInt10->es);

-    pmi->tbl_off = R16(pVbe->pInt10->di);

-    pmi->tbl_len = R16(pVbe->pInt10->cx);

-

-    return pmi;

-}

-

-#if 0

-vbeModeInfoPtr

-VBEBuildVbeModeList(vbeInfoPtr pVbe, VbeInfoBlock *vbe)

-{

-    vbeModeInfoPtr ModeList = NULL;

-

-    int i = 0;

-    while (vbe->VideoModePtr[i] != 0xffff) {

-	vbeModeInfoPtr m;

-	VbeModeInfoBlock *mode;

-	int id = vbe->VideoModePtr[i++];

-	int bpp;

-

-	if ((mode = VBEGetModeInfo(pVbe, id)) == NULL)

-	    continue;

-

- 	bpp = mode->BitsPerPixel;

-

-	m = xnfcalloc(sizeof(vbeModeInfoRec),1);

-	m->width = mode->XResolution;

-	m->height = mode->YResolution;

-	m->bpp = bpp;

-	m->n = id;

-	m->next = ModeList;

-

-	xf86DrvMsgVerb(pVbe->pInt10->scrnIndex, X_PROBED, 3,

-		       "BIOS reported VESA mode 0x%x: x:%i y:%i bpp:%i\n",

-		       m->n, m->width, m->height, m->bpp);

-

-	ModeList = m;

-

-	VBEFreeModeInfo(mode);

-    }

-    return ModeList;

-}

-

-unsigned short 

-VBECalcVbeModeIndex(vbeModeInfoPtr m, DisplayModePtr mode, int bpp)

-{

-    while (m) {

-	if (bpp == m->bpp 

-	    && mode->HDisplay == m->width 

-	    && mode->VDisplay == m->height)

-	    return m->n;

-	m = m->next;

-    }

-    return 0;

-}

-#endif

-

-void

-VBEVesaSaveRestore(vbeInfoPtr pVbe, vbeSaveRestorePtr vbe_sr,

-		  vbeSaveRestoreFunction function)

-{

-    Bool SaveSucc = FALSE;

-

-    if (VBE_VERSION_MAJOR(pVbe->version) > 1

-	&& (function == MODE_SAVE || vbe_sr->pstate)) {

-	if (function == MODE_RESTORE)

-	    memcpy(vbe_sr->state, vbe_sr->pstate, vbe_sr->stateSize);

-	ErrorF("VBESaveRestore\n");

-	if ((VBESaveRestore(pVbe,function,

-			    (pointer)&vbe_sr->state,

-			    &vbe_sr->stateSize,&vbe_sr->statePage))) {

-	    if (function == MODE_SAVE) {

-		SaveSucc = TRUE;

-		vbe_sr->stateMode = -1; /* invalidate */

-		/* don't rely on the memory not being touched */

-		if (vbe_sr->pstate == NULL)

-		    vbe_sr->pstate = malloc(vbe_sr->stateSize);

-		memcpy(vbe_sr->pstate, vbe_sr->state, vbe_sr->stateSize);

-	    }

-	    ErrorF("VBESaveRestore done with success\n");

-	    return;

-	}

-	ErrorF("VBESaveRestore done\n");

-    } 

-    

-    if (function == MODE_SAVE && !SaveSucc)

-	    (void)VBEGetVBEMode(pVbe, &vbe_sr->stateMode);

-	

-    if (function == MODE_RESTORE && vbe_sr->stateMode != -1)

-	    VBESetVBEMode(pVbe, vbe_sr->stateMode, NULL);

-

-}

-

-int

-VBEGetPixelClock(vbeInfoPtr pVbe, int mode, int clock)

-{

-    /*

-    Input:

-	AX := 4F0Bh VBE Get Pixel Clock

-	BL := 00h Get Pixel Clock

-	ECX := pixel clock in units of Hz

-        DX := mode number

-     

-    Output:

-	AX := VBE Return Status

-	ECX := Closest pixel clock

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f0b;

-    pVbe->pInt10->bx = 0x00;

-    pVbe->pInt10->cx = clock;

-    pVbe->pInt10->dx = mode;

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if (R16(pVbe->pInt10->ax) != 0x4f)

-	return 0;

-

-    return pVbe->pInt10->cx;

-}

-

-Bool

-VBEDPMSSet(vbeInfoPtr pVbe, int mode)

-{

-    /*

-    Input:

-	AX := 4F10h DPMS

-	BL := 01h Set Display Power State

-	BH := requested power state

-     

-    Output:

-	AX := VBE Return Status

-     */

-

-    pVbe->pInt10->num = 0x10;

-    pVbe->pInt10->ax = 0x4f10;

-    pVbe->pInt10->bx = 0x01;

-    switch (mode) {

-    case DPMSModeOn:

-	break;

-    case DPMSModeStandby:

-	pVbe->pInt10->bx |= 0x100;

-	break;

-    case DPMSModeSuspend:

-	pVbe->pInt10->bx |= 0x200;

-	break;

-    case DPMSModeOff:

-	pVbe->pInt10->bx |= 0x400;

-	break;

-    }

-    xf86ExecX86int10(pVbe->pInt10);

-    return (R16(pVbe->pInt10->ax) == 0x4f);

-}

-

-void

-VBEInterpretPanelID(int scrnIndex, struct vbePanelID *data)

-{

-    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];

-    DisplayModePtr mode;

-    const float PANEL_HZ = 60.0;

-

-    if (!data)

-	return;

-

-    xf86DrvMsg(scrnIndex, X_INFO, "PanelID returned panel resolution %dx%d\n",

-	    data->hsize, data->vsize);

-

-    if (pScrn->monitor->nHsync || pScrn->monitor->nVrefresh)

-	return;

-

-    if (data->hsize < 320 || data->vsize < 240) {

-	xf86DrvMsg(scrnIndex, X_INFO, "...which I refuse to believe\n");

-	return;

-    }

-

-    mode = xf86CVTMode(data->hsize, data->vsize, PANEL_HZ, 1, 0);

-

-    pScrn->monitor->nHsync = 1;

-    pScrn->monitor->hsync[0].lo = 31.5;

-    pScrn->monitor->hsync[0].hi = (float)mode->Clock / (float)mode->HTotal;

-    pScrn->monitor->nVrefresh = 1;

-    pScrn->monitor->vrefresh[0].lo = 56.0;

-    pScrn->monitor->vrefresh[0].hi =

-	(float)mode->Clock*1000.0 / (float)mode->HTotal / (float)mode->VTotal;

-

-    free(mode);

-}

-

-struct vbePanelID *

-VBEReadPanelID(vbeInfoPtr pVbe)

-{

-    int RealOff = pVbe->real_mode_base;

-    pointer page = pVbe->memory;

-    void *tmp = NULL;

-    int screen = pVbe->pInt10->scrnIndex;

-

-    pVbe->pInt10->ax = 0x4F11;

-    pVbe->pInt10->bx = 0x01;

-    pVbe->pInt10->cx = 0;

-    pVbe->pInt10->dx = 0;

-    pVbe->pInt10->es = SEG_ADDR(RealOff);

-    pVbe->pInt10->di = SEG_OFF(RealOff);

-    pVbe->pInt10->num = 0x10;

-

-    xf86ExecX86int10(pVbe->pInt10);

-

-    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID invalid\n");

-	goto error;

-    }

-

-    switch (pVbe->pInt10->ax & 0xff00) {

-    case 0x0:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID read successfully\n");

-	tmp = xnfalloc(32); 

-	memcpy(tmp, page, 32); 

-	break;

-    case 0x100:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID read failed\n");       

-	break;

-    default:

-	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID unknown failure %i\n",

-		       pVbe->pInt10->ax & 0xff00);

-	break;

-    }

-

-error:

-    return tmp;

-}

+
+/*
+ *                   XFree86 vbe module
+ *               Copyright 2000 Egbert Eich
+ *
+ * The mode query/save/set/restore functions from the vesa driver 
+ * have been moved here.
+ * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
+ * Authors: Paulo César Pereira de Andrade <pcpa@conectiva.com.br> 
+ */
+
+#ifdef HAVE_XORG_CONFIG_H
+#include <xorg-config.h>
+#endif
+
+#include <string.h>
+
+#include "xf86.h"
+#include "vbe.h"
+#include <X11/extensions/dpmsconst.h>
+
+#define VERSION(x) VBE_VERSION_MAJOR(x),VBE_VERSION_MINOR(x)
+
+#if X_BYTE_ORDER == X_LITTLE_ENDIAN
+#define B_O16(x)  (x) 
+#define B_O32(x)  (x)
+#else
+#define B_O16(x)  ((((x) & 0xff) << 8) | (((x) & 0xff) >> 8))
+#define B_O32(x)  ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) \
+                  | (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))
+#endif
+#define L_ADD(x)  (B_O32(x) & 0xffff) + ((B_O32(x) >> 12) & 0xffff00)
+
+#define FARP(p)		(((unsigned)(p & 0xffff0000) >> 12) | (p & 0xffff))
+#define R16(v)		((v) & 0xffff)
+
+static unsigned char * vbeReadEDID(vbeInfoPtr pVbe);
+static Bool vbeProbeDDC(vbeInfoPtr pVbe);
+
+static const char vbeVersionString[] = "VBE2";
+
+vbeInfoPtr
+VBEInit(xf86Int10InfoPtr pInt, int entityIndex)
+{
+    return VBEExtendedInit(pInt, entityIndex, 0);
+}
+
+vbeInfoPtr
+VBEExtendedInit(xf86Int10InfoPtr pInt, int entityIndex, int Flags)
+{
+    int RealOff;
+    pointer page = NULL;
+    ScrnInfoPtr pScrn = xf86FindScreenForEntity(entityIndex);
+    vbeControllerInfoPtr vbe = NULL;
+    Bool init_int10 = FALSE;
+    vbeInfoPtr vip = NULL;
+    int screen;
+
+    if (!pScrn) return NULL;
+    screen = pScrn->scrnIndex;
+    
+    if (!pInt) {
+	if (!xf86LoadSubModule(pScrn, "int10"))
+	    goto error;
+
+	xf86DrvMsg(screen,X_INFO,"initializing int10\n");
+	pInt = xf86ExtendedInitInt10(entityIndex,Flags);
+	if (!pInt)
+	    goto error;
+	init_int10 = TRUE;
+    }
+    
+    page = xf86Int10AllocPages(pInt,1,&RealOff);
+    if (!page) goto error;
+    vbe = (vbeControllerInfoPtr) page;    
+    memcpy(vbe->VbeSignature,vbeVersionString,4);
+
+    pInt->ax = 0x4F00;
+    pInt->es = SEG_ADDR(RealOff);
+    pInt->di = SEG_OFF(RealOff);
+    pInt->num = 0x10;
+    
+    xf86ExecX86int10(pInt);
+
+    if ((pInt->ax & 0xff) != 0x4f) {
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA BIOS not detected\n");
+	goto error;
+    }
+    
+    switch (pInt->ax & 0xff00) {
+    case 0:
+	xf86DrvMsg(screen,X_INFO,"VESA BIOS detected\n");
+	break;
+    case 0x100:
+	xf86DrvMsg(screen,X_INFO,"VESA BIOS function failed\n");
+	goto error;
+    case 0x200:
+	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported\n");
+	goto error;
+    case 0x300:
+	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported in current mode\n");
+	goto error;
+    default:
+	xf86DrvMsg(screen,X_INFO,"Invalid\n");
+	goto error;
+    }
+    
+    xf86DrvMsgVerb(screen, X_INFO, 4,
+		"VbeVersion is %d, OemStringPtr is 0x%08lx,\n"
+		"\tOemVendorNamePtr is 0x%08lx, OemProductNamePtr is 0x%08lx,\n"
+		"\tOemProductRevPtr is 0x%08lx\n",
+		vbe->VbeVersion, (unsigned long)vbe->OemStringPtr,
+		(unsigned long)vbe->OemVendorNamePtr,
+		(unsigned long)vbe->OemProductNamePtr,
+		(unsigned long)vbe->OemProductRevPtr);
+
+    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Version %i.%i\n",
+		   VERSION(vbe->VbeVersion));
+    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Total Mem: %i kB\n",
+		   vbe->TotalMem * 64);
+    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM: %s\n",
+		   (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemStringPtr)));
+    
+    if (B_O16(vbe->VbeVersion) >= 0x200) {
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Software Rev: %i.%i\n",
+		    VERSION(vbe->OemSoftwareRev));
+	if (vbe->OemVendorNamePtr)
+	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Vendor: %s\n",
+		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemVendorNamePtr)));
+	if (vbe->OemProductNamePtr)
+	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product: %s\n",
+		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductNamePtr)));
+	if (vbe->OemProductRevPtr)
+	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product Rev: %s\n",
+		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductRevPtr)));
+    }
+    vip = (vbeInfoPtr)xnfalloc(sizeof(vbeInfoRec));
+    vip->version = B_O16(vbe->VbeVersion);
+    vip->pInt10 = pInt;
+    vip->ddc = DDC_UNCHECKED;
+    vip->memory = page;
+    vip->real_mode_base = RealOff;
+    vip->num_pages = 1;
+    vip->init_int10 = init_int10;
+
+    return vip;
+
+ error:
+    if (page)
+	xf86Int10FreePages(pInt, page, 1);
+    if (init_int10)
+	xf86FreeInt10(pInt);
+    return NULL;
+}
+
+void
+vbeFree(vbeInfoPtr pVbe)
+{
+    if (!pVbe)
+	return;
+
+    xf86Int10FreePages(pVbe->pInt10,pVbe->memory,pVbe->num_pages);
+    /* If we have initalized int10 we ought to free it, too */
+    if (pVbe->init_int10) 
+	xf86FreeInt10(pVbe->pInt10);
+    free(pVbe);
+    return;
+}
+
+static Bool
+vbeProbeDDC(vbeInfoPtr pVbe)
+{
+    char *ddc_level;
+    int screen = pVbe->pInt10->scrnIndex;
+    
+    if (pVbe->ddc == DDC_NONE)
+	return FALSE;
+    if (pVbe->ddc != DDC_UNCHECKED)
+	return TRUE;
+
+    pVbe->pInt10->ax = 0x4F15;
+    pVbe->pInt10->bx = 0;
+    pVbe->pInt10->cx = 0;
+    pVbe->pInt10->es = 0;
+    pVbe->pInt10->di = 0;
+    pVbe->pInt10->num = 0x10;
+
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {
+        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC not supported\n");
+	pVbe->ddc = DDC_NONE;
+	return FALSE;
+    }
+
+    switch ((pVbe->pInt10->ax >> 8) & 0xff) {
+    case 0:
+	xf86DrvMsg(screen,X_INFO,"VESA VBE DDC supported\n");
+	switch (pVbe->pInt10->bx & 0x3) {
+	case 0:
+  	    ddc_level = " none"; 
+	    pVbe->ddc = DDC_NONE;
+	    break;
+	case 1:
+  	    ddc_level = " 1";
+	    pVbe->ddc = DDC_1;
+	    break;
+	case 2:
+  	    ddc_level = " 2"; 
+	    pVbe->ddc = DDC_2;
+	    break;
+	case 3:
+  	    ddc_level = " 1 + 2"; 
+	    pVbe->ddc = DDC_1_2;
+	    break;
+	default:
+ 	    ddc_level = "";
+	    pVbe->ddc = DDC_NONE;
+	    break;
+	}
+  	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Level%s\n",ddc_level); 
+  	if (pVbe->pInt10->bx & 0x4) {
+    	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Screen blanked" 
+    			"for data transfer\n"); 
+    	    pVbe->ddc_blank = TRUE;
+    	}  else
+    	    pVbe->ddc_blank = FALSE;
+	    
+  	xf86DrvMsgVerb(screen,X_INFO,3,
+		       "VESA VBE DDC transfer in appr. %x sec.\n", 
+		       (pVbe->pInt10->bx >> 8) & 0xff); 
+    }
+    
+    return TRUE; 
+}
+
+typedef enum {
+  VBEOPT_NOVBE,
+    VBEOPT_NODDC
+} VBEOpts;
+
+static const OptionInfoRec VBEOptions[] = {
+    { VBEOPT_NOVBE,	"NoVBE",	OPTV_BOOLEAN,	{0},	FALSE },
+    { VBEOPT_NODDC,	"NoDDC",	OPTV_BOOLEAN,	{0},	FALSE },
+    { -1,		NULL,		OPTV_NONE,	{0},	FALSE },
+};
+
+static unsigned char *
+vbeReadEDID(vbeInfoPtr pVbe)
+{
+    int RealOff = pVbe->real_mode_base;
+    pointer page = pVbe->memory;
+    unsigned char *tmp = NULL;
+    Bool novbe = FALSE;
+    Bool noddc = FALSE;
+    int screen = pVbe->pInt10->scrnIndex;
+    OptionInfoPtr options;
+
+    if (!page) return NULL;
+
+    options = xnfalloc(sizeof(VBEOptions));
+    (void)memcpy(options, VBEOptions, sizeof(VBEOptions));
+    xf86ProcessOptions(screen, xf86Screens[screen]->options, options);
+    xf86GetOptValBool(options, VBEOPT_NOVBE, &novbe);
+    xf86GetOptValBool(options, VBEOPT_NODDC, &noddc);
+    free(options);
+    if (novbe || noddc) return NULL;
+    
+    if (!vbeProbeDDC(pVbe)) goto error;
+
+    memset(page,0,sizeof(vbeInfoPtr));
+    strcpy(page,vbeVersionString);
+
+    pVbe->pInt10->ax = 0x4F15;
+    pVbe->pInt10->bx = 0x01;
+    pVbe->pInt10->cx = 0;
+    pVbe->pInt10->dx = 0;
+    pVbe->pInt10->es = SEG_ADDR(RealOff);
+    pVbe->pInt10->di = SEG_OFF(RealOff);
+    pVbe->pInt10->num = 0x10;
+
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {
+        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC invalid\n");
+	goto error;
+    }
+    switch (pVbe->pInt10->ax & 0xff00) {
+    case 0x0:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read successfully\n");
+  	tmp = (unsigned char *)xnfalloc(128); 
+  	memcpy(tmp,page,128); 
+	break;
+    case 0x100:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read failed\n");	
+	break;
+    default:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC unkown failure %i\n",
+		       pVbe->pInt10->ax & 0xff00);
+	break;
+    }
+    
+ error:
+    return tmp;
+}
+
+xf86MonPtr
+vbeDoEDID(vbeInfoPtr pVbe, pointer pDDCModule)
+{
+    xf86MonPtr    pMonitor;
+    pointer       pModule;
+    unsigned char *DDC_data = NULL;
+    
+    if (!pVbe) return NULL;
+    if (pVbe->version < 0x200)
+	return NULL;
+
+    if (!(pModule = pDDCModule)) {
+	pModule =
+	    xf86LoadSubModule(xf86Screens[pVbe->pInt10->scrnIndex], "ddc");
+	if (!pModule)
+	    return NULL;
+    }
+        
+    DDC_data = vbeReadEDID(pVbe);
+
+    if (!DDC_data) 
+	return NULL;
+    
+    pMonitor = xf86InterpretEDID(pVbe->pInt10->scrnIndex, DDC_data);
+
+    if (!pDDCModule)
+        xf86UnloadSubModule(pModule);
+    return pMonitor;
+}
+
+#define GET_UNALIGNED2(x) \
+            ((*(CARD16*)(x)) | (*(((CARD16*)(x) + 1))) << 16)
+
+VbeInfoBlock *
+VBEGetVBEInfo(vbeInfoPtr pVbe)
+{
+    VbeInfoBlock *block = NULL;
+    int i, pStr, pModes;
+    char *str;
+    CARD16 major, *modes;
+
+    memset(pVbe->memory, 0, sizeof(VbeInfoBlock));
+
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 00h	Return Super VGA information
+	ES:DI := Pointer to buffer
+
+    Output:
+	AX    := status
+	(All other registers are preserved)
+     */
+
+    ((char*)pVbe->memory)[0] = 'V';
+    ((char*)pVbe->memory)[1] = 'B';
+    ((char*)pVbe->memory)[2] = 'E';
+    ((char*)pVbe->memory)[3] = '2';
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f00;
+    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);
+    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return NULL;
+
+    block = calloc(sizeof(VbeInfoBlock), 1);
+    block->VESASignature[0] = ((char*)pVbe->memory)[0];
+    block->VESASignature[1] = ((char*)pVbe->memory)[1];
+    block->VESASignature[2] = ((char*)pVbe->memory)[2];
+    block->VESASignature[3] = ((char*)pVbe->memory)[3];
+
+    block->VESAVersion = *(CARD16*)(((char*)pVbe->memory) + 4);
+    major = (unsigned)block->VESAVersion >> 8;
+
+    pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 6));
+    str = xf86int10Addr(pVbe->pInt10, FARP(pStr));
+    block->OEMStringPtr = strdup(str);
+
+    block->Capabilities[0] = ((char*)pVbe->memory)[10];
+    block->Capabilities[1] = ((char*)pVbe->memory)[11];
+    block->Capabilities[2] = ((char*)pVbe->memory)[12];
+    block->Capabilities[3] = ((char*)pVbe->memory)[13];
+
+    pModes = GET_UNALIGNED2((((char*)pVbe->memory) + 14));
+    modes = xf86int10Addr(pVbe->pInt10, FARP(pModes));
+    i = 0;
+    while (modes[i] != 0xffff)
+	i++;
+    block->VideoModePtr = malloc(sizeof(CARD16) * (i + 1));
+    memcpy(block->VideoModePtr, modes, sizeof(CARD16) * i);
+    block->VideoModePtr[i] = 0xffff;
+
+    block->TotalMemory = *(CARD16*)(((char*)pVbe->memory) + 18);
+
+    if (major < 2)
+	memcpy(&block->OemSoftwareRev, ((char*)pVbe->memory) + 20, 236);
+    else {
+	block->OemSoftwareRev = *(CARD16*)(((char*)pVbe->memory) + 20);
+	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 22));
+	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));
+	block->OemVendorNamePtr = strdup(str);
+	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 26));
+	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));
+	block->OemProductNamePtr = strdup(str);
+	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 30));
+	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));
+	block->OemProductRevPtr = strdup(str);
+	memcpy(&block->Reserved, ((char*)pVbe->memory) + 34, 222);
+	memcpy(&block->OemData, ((char*)pVbe->memory) + 256, 256);
+    }
+
+    return block;
+}
+
+void
+VBEFreeVBEInfo(VbeInfoBlock *block)
+{
+    free(block->OEMStringPtr);
+    free(block->VideoModePtr);
+    if (((unsigned)block->VESAVersion >> 8) >= 2) {
+	free(block->OemVendorNamePtr);
+	free(block->OemProductNamePtr);
+	free(block->OemProductRevPtr);
+    }
+    free(block);
+}
+
+Bool
+VBESetVBEMode(vbeInfoPtr pVbe, int mode, VbeCRTCInfoBlock *block)
+{
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 02h	Set Super VGA video mode
+	BX    := Video mode
+	    D0-D8  := Mode number
+	    D9-D10 := Reserved (must be 0)
+	    D11    := 0 Use current default refresh rate
+		   := 1 Use user specified CRTC values for refresh rate
+	    D12-13	Reserved for VBE/AF (must be 0)
+	    D14    := 0 Use windowed frame buffer model
+		   := 1 Use linear/flat frame buffer model
+	    D15    := 0 Clear video memory
+		   := 1 Don't clear video memory
+	ES:DI := Pointer to VbeCRTCInfoBlock structure
+
+    Output: AX = Status
+	(All other registers are preserved)
+    */
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f02;
+    pVbe->pInt10->bx = mode;
+    if (block) {
+	pVbe->pInt10->bx |= 1 << 11;
+	memcpy(pVbe->memory, block, sizeof(VbeCRTCInfoBlock));
+	pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);
+	pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);
+    } else
+	pVbe->pInt10->bx &= ~(1 << 11);
+
+    xf86ExecX86int10(pVbe->pInt10);
+
+    return (R16(pVbe->pInt10->ax) == 0x4f);
+}
+
+Bool
+VBEGetVBEMode(vbeInfoPtr pVbe, int *mode)
+{
+    /*
+    Input:
+	AH := 4Fh	Super VGA support
+	AL := 03h	Return current video mode
+
+    Output:
+	AX := Status
+	BX := Current video mode
+	(All other registers are preserved)
+    */
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f03;
+
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) == 0x4f) {
+	*mode = R16(pVbe->pInt10->bx);
+
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+VbeModeInfoBlock *
+VBEGetModeInfo(vbeInfoPtr pVbe, int mode)
+{
+    VbeModeInfoBlock *block = NULL;
+
+    memset(pVbe->memory, 0, sizeof(VbeModeInfoBlock));
+
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 01h	Return Super VGA mode information
+	CX    := 	Super VGA video mode
+			(mode number must be one of those returned by Function 0)
+	ES:DI := Pointer to buffer
+
+    Output:
+	AX    := status
+	(All other registers are preserved)
+     */
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f01;
+    pVbe->pInt10->cx = mode;
+    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);
+    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);
+    xf86ExecX86int10(pVbe->pInt10);
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return NULL;
+
+    block = malloc(sizeof(VbeModeInfoBlock));
+    if (block)
+	memcpy(block, pVbe->memory, sizeof(*block));
+
+    return block;
+}
+
+void
+VBEFreeModeInfo(VbeModeInfoBlock *block)
+{
+    free(block);
+}
+
+Bool
+VBESaveRestore(vbeInfoPtr pVbe, vbeSaveRestoreFunction function, 
+	       pointer *memory, int *size, int *real_mode_pages)
+{
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 04h	Save/restore Super VGA video state
+	DL    := 00h	Return save/restore state buffer size
+	CX    := Requested states
+		D0 = Save/restore video hardware state
+		D1 = Save/restore video BIOS data state
+		D2 = Save/restore video DAC state
+		D3 = Save/restore Super VGA state
+
+    Output:
+	AX = Status
+	BX = Number of 64-byte blocks to hold the state buffer
+	(All other registers are preserved)
+
+
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 04h	Save/restore Super VGA video state
+	DL    := 01h	Save Super VGA video state
+	CX    := Requested states (see above)
+	ES:BX := Pointer to buffer
+
+    Output:
+	AX    := Status
+	(All other registers are preserved)
+
+
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 04h	Save/restore Super VGA video state
+	DL    := 02h	Restore Super VGA video state
+	CX    := Requested states (see above)
+	ES:BX := Pointer to buffer
+
+    Output:
+	AX     := Status
+	(All other registers are preserved)
+     */
+
+    if ((pVbe->version & 0xff00) > 0x100) {
+        int screen = pVbe->pInt10->scrnIndex;
+        if (function == MODE_QUERY ||
+	    (function == MODE_SAVE && !*memory)) {
+	    /* Query amount of memory to save state */
+
+	    pVbe->pInt10->num = 0x10;
+	    pVbe->pInt10->ax = 0x4f04;
+	    pVbe->pInt10->dx = 0;
+	    pVbe->pInt10->cx = 0x000f;
+	    xf86ExecX86int10(pVbe->pInt10);
+	    if (R16(pVbe->pInt10->ax) != 0x4f)
+	        return FALSE;
+
+	    if (function == MODE_SAVE) {
+	        int npages = (R16(pVbe->pInt10->bx) * 64) / 4096 + 1;
+		if ((*memory = xf86Int10AllocPages(pVbe->pInt10, npages,
+						   real_mode_pages)) == NULL) {
+		    xf86DrvMsg(screen, X_ERROR,
+			       "Cannot allocate memory to save SVGA state.\n");
+		    return FALSE;
+		}
+	    }
+	    *size = pVbe->pInt10->bx * 64;
+	}
+
+	/* Save/Restore Super VGA state */
+	if (function != MODE_QUERY) {
+	    
+	    if (!*memory) return FALSE;
+	    pVbe->pInt10->num = 0x10;
+	    pVbe->pInt10->ax = 0x4f04;
+	    switch (function) {
+	    case MODE_SAVE:
+	      pVbe->pInt10->dx = 1;
+	      break;
+	    case MODE_RESTORE:
+	      pVbe->pInt10->dx = 2;
+	      break;
+	    case MODE_QUERY:
+	      return FALSE;
+	    }
+	    pVbe->pInt10->cx = 0x000f;
+	    
+	    pVbe->pInt10->es = SEG_ADDR(*real_mode_pages);
+	    pVbe->pInt10->bx = SEG_OFF(*real_mode_pages);
+	    xf86ExecX86int10(pVbe->pInt10);
+	    return (R16(pVbe->pInt10->ax) == 0x4f);
+
+	}
+    }
+    return TRUE;
+}
+
+Bool
+VBEBankSwitch(vbeInfoPtr pVbe, unsigned int iBank, int window)
+{
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 05h
+
+    Output:
+     */
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f05;
+    pVbe->pInt10->bx = window;
+    pVbe->pInt10->dx = iBank;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return FALSE;
+
+    return TRUE;
+}
+
+Bool
+VBESetGetLogicalScanlineLength(vbeInfoPtr pVbe, vbeScanwidthCommand command,
+				int width, int *pixels, int *bytes, int *max)
+{
+    if (command < SCANWID_SET || command > SCANWID_GET_MAX)
+	return FALSE;
+
+    /*
+    Input:
+	AX := 4F06h VBE Set/Get Logical Scan Line Length
+	BL := 00h Set Scan Line Length in Pixels
+	   := 01h Get Scan Line Length
+	   := 02h Set Scan Line Length in Bytes
+	   := 03h Get Maximum Scan Line Length
+	CX := If BL=00h Desired Width in Pixels
+	      If BL=02h Desired Width in Bytes
+	      (Ignored for Get Functions)
+
+    Output:
+	AX := VBE Return Status
+	BX := Bytes Per Scan Line
+	CX := Actual Pixels Per Scan Line
+	      (truncated to nearest complete pixel)
+	DX := Maximum Number of Scan Lines
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f06;
+    pVbe->pInt10->bx = command;
+    if (command == SCANWID_SET || command == SCANWID_SET_BYTES)
+	pVbe->pInt10->cx = width;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return FALSE;
+
+    if (command == SCANWID_GET || command == SCANWID_GET_MAX) {
+	if (pixels)
+	    *pixels = R16(pVbe->pInt10->cx);
+	if (bytes)
+	    *bytes = R16(pVbe->pInt10->bx);
+	if (max)
+	    *max = R16(pVbe->pInt10->dx);
+    }
+
+    return TRUE;
+}
+
+Bool
+VBESetDisplayStart(vbeInfoPtr pVbe, int x, int y, Bool wait_retrace)
+{
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f07;
+    pVbe->pInt10->bx = wait_retrace ? 0x80 : 0x00;
+    pVbe->pInt10->cx = x;
+    pVbe->pInt10->dx = y;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return FALSE;
+
+    return TRUE;
+}
+
+Bool
+VBEGetDisplayStart(vbeInfoPtr pVbe, int *x, int *y)
+{
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f07;
+    pVbe->pInt10->bx = 0x01;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return FALSE;
+
+    *x = pVbe->pInt10->cx;
+    *y = pVbe->pInt10->dx;
+
+    return TRUE;
+}
+
+int
+VBESetGetDACPaletteFormat(vbeInfoPtr pVbe, int bits)
+{
+    /*
+    Input:
+	AX := 4F08h VBE Set/Get Palette Format
+	BL := 00h Set DAC Palette Format
+	   := 01h Get DAC Palette Format
+	BH := Desired bits of color per primary
+	      (Set DAC Palette Format only)
+
+    Output:
+	AX := VBE Return Status
+	BH := Current number of bits of color per primary
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f08;
+    if (!bits)
+	pVbe->pInt10->bx = 0x01;
+    else 
+	pVbe->pInt10->bx = (bits & 0x00ff) << 8;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return 0;
+
+    return (bits != 0 ? bits : (pVbe->pInt10->bx >> 8) & 0x00ff);
+}
+
+CARD32 *
+VBESetGetPaletteData(vbeInfoPtr pVbe, Bool set, int first, int num,
+		      CARD32 *data, Bool secondary, Bool wait_retrace)
+{
+    /*
+    Input:
+    (16-bit)
+	AX    := 4F09h VBE Load/Unload Palette Data
+	BL    := 00h Set Palette Data
+	      := 01h Get Palette Data
+	      := 02h Set Secondary Palette Data
+	      := 03h Get Secondary Palette Data
+	      := 80h Set Palette Data during Vertical Retrace
+	CX    := Number of palette registers to update (to a maximum of 256)
+	DX    := First of the palette registers to update (start)
+	ES:DI := Table of palette values (see below for format)
+
+    Output:
+	AX    := VBE Return Status
+
+
+    Input:
+    (32-bit)
+	BL     := 00h Set Palette Data
+	       := 80h Set Palette Data during Vertical Retrace
+	CX     := Number of palette registers to update (to a maximum of 256)
+	DX     := First of the palette registers to update (start)
+	ES:EDI := Table of palette values (see below for format)
+	DS     := Selector for memory mapped registers
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f09;
+    if (!secondary)
+	pVbe->pInt10->bx = set && wait_retrace ? 0x80 : set ? 0 : 1;
+    else
+	pVbe->pInt10->bx = set ? 2 : 3;
+    pVbe->pInt10->cx = num;
+    pVbe->pInt10->dx = first;
+    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);
+    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);
+    if (set)
+	memcpy(pVbe->memory, data, num * sizeof(CARD32));
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return NULL;
+
+    if (set)
+	return data;
+
+    data = malloc(num * sizeof(CARD32));
+    memcpy(data, pVbe->memory, num * sizeof(CARD32));
+
+    return data;
+}
+
+VBEpmi *
+VBEGetVBEpmi(vbeInfoPtr pVbe)
+{
+    VBEpmi *pmi;
+
+    /*
+    Input:
+	AH    := 4Fh	Super VGA support
+	AL    := 0Ah	Protected Mode Interface
+	BL    := 00h	Return Protected Mode Table
+
+    Output:
+	AX    := Status
+	ES    := Real Mode Segment of Table
+	DI    := Offset of Table
+	CX    := Lenght of Table including protected mode code in bytes (for copying purposes)
+	(All other registers are preserved)
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f0a;
+    pVbe->pInt10->bx = 0;
+    pVbe->pInt10->di = 0;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return NULL;
+
+    pmi = malloc(sizeof(VBEpmi));
+    pmi->seg_tbl = R16(pVbe->pInt10->es);
+    pmi->tbl_off = R16(pVbe->pInt10->di);
+    pmi->tbl_len = R16(pVbe->pInt10->cx);
+
+    return pmi;
+}
+
+#if 0
+vbeModeInfoPtr
+VBEBuildVbeModeList(vbeInfoPtr pVbe, VbeInfoBlock *vbe)
+{
+    vbeModeInfoPtr ModeList = NULL;
+
+    int i = 0;
+    while (vbe->VideoModePtr[i] != 0xffff) {
+	vbeModeInfoPtr m;
+	VbeModeInfoBlock *mode;
+	int id = vbe->VideoModePtr[i++];
+	int bpp;
+
+	if ((mode = VBEGetModeInfo(pVbe, id)) == NULL)
+	    continue;
+
+ 	bpp = mode->BitsPerPixel;
+
+	m = xnfcalloc(sizeof(vbeModeInfoRec),1);
+	m->width = mode->XResolution;
+	m->height = mode->YResolution;
+	m->bpp = bpp;
+	m->n = id;
+	m->next = ModeList;
+
+	xf86DrvMsgVerb(pVbe->pInt10->scrnIndex, X_PROBED, 3,
+		       "BIOS reported VESA mode 0x%x: x:%i y:%i bpp:%i\n",
+		       m->n, m->width, m->height, m->bpp);
+
+	ModeList = m;
+
+	VBEFreeModeInfo(mode);
+    }
+    return ModeList;
+}
+
+unsigned short 
+VBECalcVbeModeIndex(vbeModeInfoPtr m, DisplayModePtr mode, int bpp)
+{
+    while (m) {
+	if (bpp == m->bpp 
+	    && mode->HDisplay == m->width 
+	    && mode->VDisplay == m->height)
+	    return m->n;
+	m = m->next;
+    }
+    return 0;
+}
+#endif
+
+void
+VBEVesaSaveRestore(vbeInfoPtr pVbe, vbeSaveRestorePtr vbe_sr,
+		  vbeSaveRestoreFunction function)
+{
+    Bool SaveSucc = FALSE;
+
+    if (VBE_VERSION_MAJOR(pVbe->version) > 1
+	&& (function == MODE_SAVE || vbe_sr->pstate)) {
+	if (function == MODE_RESTORE)
+	    memcpy(vbe_sr->state, vbe_sr->pstate, vbe_sr->stateSize);
+	ErrorF("VBESaveRestore\n");
+	if ((VBESaveRestore(pVbe,function,
+			    (pointer)&vbe_sr->state,
+			    &vbe_sr->stateSize,&vbe_sr->statePage))) {
+	    if (function == MODE_SAVE) {
+		SaveSucc = TRUE;
+		vbe_sr->stateMode = -1; /* invalidate */
+		/* don't rely on the memory not being touched */
+		if (vbe_sr->pstate == NULL)
+		    vbe_sr->pstate = malloc(vbe_sr->stateSize);
+		memcpy(vbe_sr->pstate, vbe_sr->state, vbe_sr->stateSize);
+	    }
+	    ErrorF("VBESaveRestore done with success\n");
+	    return;
+	}
+	ErrorF("VBESaveRestore done\n");
+    } 
+    
+    if (function == MODE_SAVE && !SaveSucc)
+	    (void)VBEGetVBEMode(pVbe, &vbe_sr->stateMode);
+	
+    if (function == MODE_RESTORE && vbe_sr->stateMode != -1)
+	    VBESetVBEMode(pVbe, vbe_sr->stateMode, NULL);
+
+}
+
+int
+VBEGetPixelClock(vbeInfoPtr pVbe, int mode, int clock)
+{
+    /*
+    Input:
+	AX := 4F0Bh VBE Get Pixel Clock
+	BL := 00h Get Pixel Clock
+	ECX := pixel clock in units of Hz
+        DX := mode number
+     
+    Output:
+	AX := VBE Return Status
+	ECX := Closest pixel clock
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f0b;
+    pVbe->pInt10->bx = 0x00;
+    pVbe->pInt10->cx = clock;
+    pVbe->pInt10->dx = mode;
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if (R16(pVbe->pInt10->ax) != 0x4f)
+	return 0;
+
+    return pVbe->pInt10->cx;
+}
+
+Bool
+VBEDPMSSet(vbeInfoPtr pVbe, int mode)
+{
+    /*
+    Input:
+	AX := 4F10h DPMS
+	BL := 01h Set Display Power State
+	BH := requested power state
+     
+    Output:
+	AX := VBE Return Status
+     */
+
+    pVbe->pInt10->num = 0x10;
+    pVbe->pInt10->ax = 0x4f10;
+    pVbe->pInt10->bx = 0x01;
+    switch (mode) {
+    case DPMSModeOn:
+	break;
+    case DPMSModeStandby:
+	pVbe->pInt10->bx |= 0x100;
+	break;
+    case DPMSModeSuspend:
+	pVbe->pInt10->bx |= 0x200;
+	break;
+    case DPMSModeOff:
+	pVbe->pInt10->bx |= 0x400;
+	break;
+    }
+    xf86ExecX86int10(pVbe->pInt10);
+    return (R16(pVbe->pInt10->ax) == 0x4f);
+}
+
+void
+VBEInterpretPanelID(int scrnIndex, struct vbePanelID *data)
+{
+    ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
+    DisplayModePtr mode;
+    const float PANEL_HZ = 60.0;
+
+    if (!data)
+	return;
+
+    xf86DrvMsg(scrnIndex, X_INFO, "PanelID returned panel resolution %dx%d\n",
+	    data->hsize, data->vsize);
+
+    if (pScrn->monitor->nHsync || pScrn->monitor->nVrefresh)
+	return;
+
+    if (data->hsize < 320 || data->vsize < 240) {
+	xf86DrvMsg(scrnIndex, X_INFO, "...which I refuse to believe\n");
+	return;
+    }
+
+    mode = xf86CVTMode(data->hsize, data->vsize, PANEL_HZ, 1, 0);
+
+    pScrn->monitor->nHsync = 1;
+    pScrn->monitor->hsync[0].lo = 31.5;
+    pScrn->monitor->hsync[0].hi = (float)mode->Clock / (float)mode->HTotal;
+    pScrn->monitor->nVrefresh = 1;
+    pScrn->monitor->vrefresh[0].lo = 56.0;
+    pScrn->monitor->vrefresh[0].hi =
+	(float)mode->Clock*1000.0 / (float)mode->HTotal / (float)mode->VTotal;
+
+    free(mode);
+}
+
+struct vbePanelID *
+VBEReadPanelID(vbeInfoPtr pVbe)
+{
+    int RealOff = pVbe->real_mode_base;
+    pointer page = pVbe->memory;
+    void *tmp = NULL;
+    int screen = pVbe->pInt10->scrnIndex;
+
+    pVbe->pInt10->ax = 0x4F11;
+    pVbe->pInt10->bx = 0x01;
+    pVbe->pInt10->cx = 0;
+    pVbe->pInt10->dx = 0;
+    pVbe->pInt10->es = SEG_ADDR(RealOff);
+    pVbe->pInt10->di = SEG_OFF(RealOff);
+    pVbe->pInt10->num = 0x10;
+
+    xf86ExecX86int10(pVbe->pInt10);
+
+    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID invalid\n");
+	goto error;
+    }
+
+    switch (pVbe->pInt10->ax & 0xff00) {
+    case 0x0:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID read successfully\n");
+	tmp = xnfalloc(32); 
+	memcpy(tmp, page, 32); 
+	break;
+    case 0x100:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID read failed\n");       
+	break;
+    default:
+	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE PanelID unknown failure %i\n",
+		       pVbe->pInt10->ax & 0xff00);
+	break;
+    }
+
+error:
+    return tmp;
+}
diff --git a/xorg-server/hw/xfree86/xaa/xaaInit.c b/xorg-server/hw/xfree86/xaa/xaaInit.c
index ff1dd3d8b..dcbd5aba0 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 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;

-    }

-}

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