diff options
Diffstat (limited to 'src/savage_dri.c')
| -rw-r--r-- | src/savage_dri.c | 2172 |
1 files changed, 2172 insertions, 0 deletions
diff --git a/src/savage_dri.c b/src/savage_dri.c new file mode 100644 index 0000000..de3b073 --- /dev/null +++ b/src/savage_dri.c @@ -0,0 +1,2172 @@ +/* + * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved. + * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved. + * + * 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, sub license, + * 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 (including the + * next paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL + * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS 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 XF86DRI + +#include "xf86.h" +#include "xf86_OSproc.h" +#include "xf86_ansic.h" +#include "xf86Priv.h" + +#include "xaalocal.h" +#include "xaarop.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" +#include "xf86fbman.h" + +#if 0 +#define PSZ 8 +#include "cfb.h" +#undef PSZ +#include "cfb16.h" +#include "cfb32.h" +#endif + +#include "miline.h" + + +/*#include "savage_vbe.h"*/ +#include "savage_regs.h" +#include "savage_driver.h" +#include "savage_bci.h" + +#define _XF86DRI_SERVER_ +#include "GL/glxtokens.h" +#include "sarea.h" +#include "savage_dri.h" +#include "savage_sarea.h" + +static char SAVAGEKernelDriverName[] = "savage"; +static char SAVAGEClientDriverName[] = "savage"; + +static Bool SAVAGEDRIOpenFullScreen(ScreenPtr pScreen); +static Bool SAVAGEDRICloseFullScreen(ScreenPtr pScreen); +/* DRI buffer management + */ +void SAVAGEDRIInitBuffers( WindowPtr pWin, RegionPtr prgn, + CARD32 index ); +void SAVAGEDRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg, + RegionPtr prgnSrc, CARD32 index ); + +/* almost the same besides set src/desc to */ +/* Primary Bitmap Description */ + +static void +SAVAGEDRISetupForScreenToScreenCopy( + ScrnInfoPtr pScrn, int xdir, int ydir, + int rop, unsigned planemask, int transparency_color); + + +static void +SAVAGEDRISubsequentScreenToScreenCopy( + ScrnInfoPtr pScrn, int x1, int y1, int x2, int y2, + int w, int h); + + +static void +SAVAGEDRISetupForSolidFill( + ScrnInfoPtr pScrn, int color, int rop, unsigned planemask); + + +static void +SAVAGEDRISubsequentSolidFillRect( + ScrnInfoPtr pScrn, int x, int y, int w, int h); + +#if 0 +extern int +SavageHelpSolidROP(ScrnInfoPtr pScrn, int *fg,int pm,int *rop); +#endif +unsigned long SAVAGEDRIGetPhyAddress(ScrnInfoPtr pScrn,void * pointer); + +/* Initialize the visual configs that are supported by the hardware. + * These are combined with the visual configs that the indirect + * rendering core supports, and the intersection is exported to the + * client. + */ +static Bool SAVAGEInitVisualConfigs( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + int numConfigs = 0; + __GLXvisualConfig *pConfigs = 0; + SAVAGEConfigPrivPtr pSAVAGEConfigs = 0; + SAVAGEConfigPrivPtr *pSAVAGEConfigPtrs = 0; + int i, db, depth, stencil, accum; + + switch ( pScrn->bitsPerPixel ) { + case 8: + case 24: + break; + + case 16: + numConfigs = 8; + + pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig), + numConfigs ); + if ( !pConfigs ) { + return FALSE; + } + + pSAVAGEConfigs = (SAVAGEConfigPrivPtr)xcalloc( sizeof(SAVAGEConfigPrivRec), + numConfigs ); + if ( !pSAVAGEConfigs ) { + xfree( pConfigs ); + return FALSE; + } + + pSAVAGEConfigPtrs = (SAVAGEConfigPrivPtr*)xcalloc( sizeof(SAVAGEConfigPrivPtr), + numConfigs ); + if ( !pSAVAGEConfigPtrs ) { + xfree( pConfigs ); + xfree( pSAVAGEConfigs ); + return FALSE; + } + + for ( i = 0 ; i < numConfigs ; i++ ) { + pSAVAGEConfigPtrs[i] = &pSAVAGEConfigs[i]; + } + + i = 0; + depth = 1; + for ( accum = 0 ; accum <= 1 ; accum++ ) { + for ( stencil = 0 ; stencil <= 1 ; stencil++ ) { + for ( db = 1 ; db >= 0 ; db-- ) { + pConfigs[i].vid = -1; + pConfigs[i].class = -1; + pConfigs[i].rgba = TRUE; + pConfigs[i].redSize = 5; + pConfigs[i].greenSize = 6; + pConfigs[i].blueSize = 5; + pConfigs[i].alphaSize = 0; + pConfigs[i].redMask = 0x0000F800; + pConfigs[i].greenMask = 0x000007E0; + pConfigs[i].blueMask = 0x0000001F; + pConfigs[i].alphaMask = 0; + if ( accum ) { + pConfigs[i].accumRedSize = 16; + pConfigs[i].accumGreenSize = 16; + pConfigs[i].accumBlueSize = 16; + pConfigs[i].accumAlphaSize = 0; + } else { + pConfigs[i].accumRedSize = 0; + pConfigs[i].accumGreenSize = 0; + pConfigs[i].accumBlueSize = 0; + pConfigs[i].accumAlphaSize = 0; + } + if ( db ) { + pConfigs[i].doubleBuffer = TRUE; + } else { + pConfigs[i].doubleBuffer = FALSE; + } + pConfigs[i].stereo = FALSE; + pConfigs[i].bufferSize = 16; + if ( depth ) { + pConfigs[i].depthSize = 16; + } else { + pConfigs[i].depthSize = 0; + } + if ( stencil ) { + pConfigs[i].stencilSize = 8; + } else { + pConfigs[i].stencilSize = 0; + } + pConfigs[i].auxBuffers = 0; + pConfigs[i].level = 0; + if ( accum || stencil ) { + pConfigs[i].visualRating = GLX_SLOW_VISUAL_EXT; + } else { + pConfigs[i].visualRating = GLX_NONE_EXT; + } + pConfigs[i].transparentPixel = 0; + pConfigs[i].transparentRed = 0; + pConfigs[i].transparentGreen = 0; + pConfigs[i].transparentBlue = 0; + pConfigs[i].transparentAlpha = 0; + pConfigs[i].transparentIndex = 0; + i++; + } + } + } + if ( i != numConfigs ) { + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Incorrect initialization of visuals\n" ); + return FALSE; + } + break; + + case 32: + numConfigs = 8; + + pConfigs = (__GLXvisualConfig*)xcalloc( sizeof(__GLXvisualConfig), + numConfigs ); + if ( !pConfigs ) { + return FALSE; + } + + pSAVAGEConfigs = (SAVAGEConfigPrivPtr)xcalloc( sizeof(SAVAGEConfigPrivRec), + numConfigs ); + if ( !pSAVAGEConfigs ) { + xfree( pConfigs ); + return FALSE; + } + + pSAVAGEConfigPtrs = (SAVAGEConfigPrivPtr*)xcalloc( sizeof(SAVAGEConfigPrivPtr), + numConfigs ); + if ( !pSAVAGEConfigPtrs ) { + xfree( pConfigs ); + xfree( pSAVAGEConfigs ); + return FALSE; + } + + for ( i = 0 ; i < numConfigs ; i++ ) { + pSAVAGEConfigPtrs[i] = &pSAVAGEConfigs[i]; + } + + i = 0; + for ( accum = 0 ; accum <= 1 ; accum++ ) { + for ( depth = 0 ; depth <= 1 ; depth++ ) { /* and stencil */ + for ( db = 1 ; db >= 0 ; db-- ) { + pConfigs[i].vid = -1; + pConfigs[i].class = -1; + pConfigs[i].rgba = TRUE; + pConfigs[i].redSize = 8; + pConfigs[i].greenSize = 8; + pConfigs[i].blueSize = 8; + pConfigs[i].alphaSize = 8; + pConfigs[i].redMask = 0x00FF0000; + pConfigs[i].greenMask = 0x0000FF00; + pConfigs[i].blueMask = 0x000000FF; + pConfigs[i].alphaMask = 0; + if ( accum ) { + pConfigs[i].accumRedSize = 16; + pConfigs[i].accumGreenSize = 16; + pConfigs[i].accumBlueSize = 16; + pConfigs[i].accumAlphaSize = 0; + } else { + pConfigs[i].accumRedSize = 0; + pConfigs[i].accumGreenSize = 0; + pConfigs[i].accumBlueSize = 0; + pConfigs[i].accumAlphaSize = 0; + } + if ( db ) { + pConfigs[i].doubleBuffer = TRUE; + } else { + pConfigs[i].doubleBuffer = FALSE; + } + pConfigs[i].stereo = FALSE; + pConfigs[i].bufferSize = 32; + if ( depth ) { + pConfigs[i].depthSize = 24; + pConfigs[i].stencilSize = 8; + } + else { + pConfigs[i].depthSize = 0; + pConfigs[i].stencilSize = 0; + } + pConfigs[i].auxBuffers = 0; + pConfigs[i].level = 0; + if ( accum ) { + pConfigs[i].visualRating = GLX_SLOW_VISUAL_EXT; + } else { + pConfigs[i].visualRating = GLX_NONE_EXT; + } + pConfigs[i].transparentPixel = 0; + pConfigs[i].transparentRed = 0; + pConfigs[i].transparentGreen = 0; + pConfigs[i].transparentBlue = 0; + pConfigs[i].transparentAlpha = 0; + pConfigs[i].transparentIndex = 0; + i++; + } + } + } + if ( i != numConfigs ) { + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Incorrect initialization of visuals\n" ); + return FALSE; + } + break; + + default: + /* Unexpected bits/pixels */ + break; + } + + psav->numVisualConfigs = numConfigs; + psav->pVisualConfigs = pConfigs; + psav->pVisualConfigsPriv = pSAVAGEConfigs; + + GlxSetVisualConfigs( numConfigs, pConfigs, (void **)pSAVAGEConfigPtrs ); + + return TRUE; +} + +static Bool SAVAGECreateContext( ScreenPtr pScreen, VisualPtr visual, + drm_context_t hwContext, void *pVisualConfigPriv, + DRIContextType contextStore ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + savageAgpBufferPtr pAgp; + + int ret,size,i; + unsigned long handle,map_handle; + drm_savage_sarea_t * pShare; + unsigned long offset; + + if(psav->xvmcContext) + return FALSE; + else + { + psav->DRIrunning++; + } + /* alloc agp memory to dma */ + pShare = (drm_savage_sarea_ptr)DRIGetSAREAPrivate(pScreen); + pShare->agp_offset=0; + /* find the available buffer*/ + for (i=0,pAgp = pSAVAGEDRIServer->agpBuffer;i<pSAVAGEDRIServer->numBuffer;i++,pAgp++) + { + if (pAgp->flags==0) + break; + } + if (i >= pSAVAGEDRIServer->numBuffer) + { + return TRUE; + } + + offset=pAgp->agp_offset; + size = DRM_SAVAGE_DMA_AGP_SIZE; + if (size <=0) + return TRUE; + ret=drmAgpAlloc( psav->drmFD,size,0,NULL,&handle); + if ( ret<0) + { + return TRUE; + } + ret=drmAgpBind( psav->drmFD,handle,offset); + if (ret<0) + { + return TRUE; + } + if (drmAddMap(psav->drmFD, + offset, + DRM_SAVAGE_DMA_AGP_SIZE, + DRM_AGP, + 0, + &map_handle)<0) + { + return TRUE; + } + pAgp->ctxOwner = hwContext; + pAgp->flags = 1; + pAgp->agp_handle = handle; + pAgp->map_handle = map_handle; + pShare->agp_offset=map_handle; + + return TRUE; + +} + +static void SAVAGEDestroyContext( ScreenPtr pScreen, drm_context_t hwContext, + DRIContextType contextStore ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + savageAgpBufferPtr pAgp; + drm_savage_sarea_t * pShare; + int i; + unsigned long handle,map_handle; + + psav->DRIrunning--; + + pShare = (drm_savage_sarea_ptr)DRIGetSAREAPrivate(pScreen); + + for (i=0,pAgp = pSAVAGEDRIServer->agpBuffer;i<pSAVAGEDRIServer->numBuffer;i++,pAgp++) + { + if (pAgp->ctxOwner == hwContext) + break; + } + if (i >= pSAVAGEDRIServer->numBuffer || !pAgp->flags || !pAgp->agp_handle) + { + return; + } + handle = pAgp->agp_handle; + map_handle = pAgp->map_handle; + drmRmMap(psav->drmFD,map_handle); + drmAgpUnbind(psav->drmFD,handle); + drmAgpFree(psav->drmFD,handle); + pAgp->flags=0; + pAgp->ctxOwner=0; +} + +#if 0 +/* Quiescence, locking + */ +#define SAVAGE_TIMEOUT 2048 + +static void SAVAGEWaitForIdleDMA( ScrnInfoPtr pScrn ) +{ + SavagePtr psav = SAVPTR(pScrn); + int ret; + int i = 0; + + for (;;) { + do { + ret = drmSAVAGEFlushDMA( psav->drmFD, + DRM_LOCK_QUIESCENT | DRM_LOCK_FLUSH ); + } while ( ( ret == -EBUSY ) && ( i++ < SAVAGE_TIMEOUT ) ); + + if ( ret == 0 ) + return; + + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[dri] Idle timed out, resetting engine...\n" ); + + drmSAVAGEEngineReset( psav->drmFD ); + } +} + + +void SAVAGEGetQuiescence( ScrnInfoPtr pScrn ) +{ + SavagePtr psav = SAVPTR(pScrn); + + DRILock( screenInfo.screens[pScrn->scrnIndex], 0 ); + psav->haveQuiescense = 1; + + if ( psav->directRenderingEnabled ) { + SAVAGEFBLayout *pLayout = &psav->CurrentLayout; + + SAVAGEWaitForIdleDMA( pScrn ); + + WAITFIFO( 11 ); + OUTREG( SAVAGEREG_MACCESS, psav->MAccess ); + OUTREG( SAVAGEREG_PITCH, pLayout->displayWidth ); + + psav->PlaneMask = ~0; + OUTREG( SAVAGEREG_PLNWT, psav->PlaneMask ); + + psav->BgColor = 0; + psav->FgColor = 0; + OUTREG( SAVAGEREG_BCOL, psav->BgColor ); + OUTREG( SAVAGEREG_FCOL, psav->FgColor ); + OUTREG( SAVAGEREG_SRCORG, psav->realSrcOrg ); + + psav->SrcOrg = 0; + OUTREG( SAVAGEREG_DSTORG, psav->DstOrg ); + OUTREG( SAVAGEREG_OPMODE, SAVAGEOPM_DMA_BLIT ); + OUTREG( SAVAGEREG_CXBNDRY, 0xFFFF0000 ); /* (maxX << 16) | minX */ + OUTREG( SAVAGEREG_YTOP, 0x00000000 ); /* minPixelPointer */ + OUTREG( SAVAGEREG_YBOT, 0x007FFFFF ); /* maxPixelPointer */ + + psav->AccelFlags &= ~CLIPPER_ON; + } +} + +void SAVAGEGetQuiescenceShared( ScrnInfoPtr pScrn ) +{ + SavagePtr psav = SAVPTR(pScrn); + SAVAGEEntPtr pSAVAGEEnt = psav->entityPrivate; + SavagePtr pSAVAGE2 = SAVPTR(pSAVAGEEnt->pScrn_2); + + DRILock( screenInfo.screens[pSAVAGEEnt->pScrn_1->scrnIndex], 0 ); + + psav = SAVPTR(pSAVAGEEnt->pScrn_1); + psav->haveQuiescense = 1; + pSAVAGE2->haveQuiescense = 1; + + if ( pSAVAGEEnt->directRenderingEnabled ) { + SAVAGEWaitForIdleDMA( pSAVAGEEnt->pScrn_1 ); + psav->RestoreAccelState( pScrn ); + xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex ); + } +} + +#endif + +/* move in SAVAGEDRISwapContext() */ +#if 0 +static void SAVAGESwapContext( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + + /* Arrange for dma_quiescence and xaa sync to be called as + * appropriate. + */ + psav->LockHeld = 1; /* port as pMGA->haveQuiescense*/ + psav->AccelInfoRec->NeedToSync = TRUE; +} +#endif + +/* no double-head */ +#if 0 +static void SAVAGESwapContextShared( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEEntPtr pSAVAGEEnt = psav->entityPrivate; + SavagePtr pSAVAGE2 = SAVPTR(pSAVAGEEnt->pScrn_2); + + psav = SAVPTR(pSAVAGEEnt->pScrn_1); + + psav->haveQuiescense = 0; + psav->AccelInfoRec->NeedToSync = TRUE; + + pSAVAGE2->haveQuiescense = 0; + pSAVAGE2->AccelInfoRec->NeedToSync = TRUE; +} +#endif + +/* This is really only called from validate/postvalidate as we + * override the dri lock/unlock. Want to remove validate/postvalidate + * processing, but need to remove all client-side use of drawable lock + * first (otherwise there is noone recover when a client dies holding + * the drawable lock). + * + * What does this mean? + * + * - The above code gets executed every time a + * window changes shape or the focus changes, which isn't really + * optimal. + * - The X server therefore believes it needs to do an XAA sync + * *and* a dma quiescense ioctl each time that happens. + * + * We don't wrap wakeuphandler any longer, so at least we can say that + * this doesn't happen *every time the mouse moves*... + */ +static void +SAVAGEDRISwapContext( ScreenPtr pScreen, DRISyncType syncType, + DRIContextType oldContextType, void *oldContext, + DRIContextType newContextType, void *newContext ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + +#if 1 + /* this case call from DRIDoWakeupandler, */ + /* swap context in */ + if ( syncType == DRI_3D_SYNC && + oldContextType == DRI_2D_CONTEXT && + newContextType == DRI_2D_CONTEXT ) + { + psav->LockHeld = 1; /* port as pMGA->haveQuiescense*/ + psav->AccelInfoRec->NeedToSync = TRUE; + } + /* this case call from DRIDoBlockHandler, */ + /* swap context out */ + else if (syncType == DRI_2D_SYNC && + oldContextType == DRI_NO_CONTEXT && + newContextType == DRI_2D_CONTEXT) + { + psav->LockHeld = 0; + psav->AccelInfoRec->NeedToSync = TRUE; + } +#endif +} + +/* no Double-Head */ +#if 0 +static void +SAVAGEDRISwapContextShared( ScreenPtr pScreen, DRISyncType syncType, + DRIContextType oldContextType, void *oldContext, + DRIContextType newContextType, void *newContext ) +{ +#if 0 + if ( syncType == DRI_3D_SYNC && + oldContextType == DRI_2D_CONTEXT && + newContextType == DRI_2D_CONTEXT ) + { + SAVAGESwapContextShared( pScreen ); + } +#endif +} +#endif + +/* following I810 and R128 swaping method */ +/* MGA swaping method is for their double head */ +#if 0 +static void SAVAGEWakeupHandler( int screenNum, pointer wakeupData, + unsigned long result, pointer pReadmask ) +{ + ScreenPtr pScreen = screenInfo.screens[screenNum]; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + + if ( xf86IsEntityShared( pScrn->entityList[0] ) ) { + SAVAGESwapContextShared( pScreen ); + } else { + SAVAGESwapContext( pScreen ); + } +} + +static void SAVAGEBlockHandler( int screenNum, pointer blockData, + pointer pTimeout, pointer pReadmask ) + +{ + ScreenPtr pScreen = screenInfo.screens[screenNum]; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEEntPtr pSAVAGEEnt; + + if ( psav->haveQuiescense ) { + if ( xf86IsEntityShared( pScrn->entityList[0] ) ) { + /* Restore to first screen */ + psav->RestoreAccelState( pScrn ); + xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex ); + pSAVAGEEnt = psav->entityPrivate; + + if ( pSAVAGEEnt->directRenderingEnabled ) { + DRIUnlock( screenInfo.screens[pSAVAGEEnt->pScrn_1->scrnIndex] ); + } + } else { + if ( psav->directRenderingEnabled ) { + DRIUnlock( pScreen ); + } + } + psav->haveQuiescense = 0; + } +} +#endif + +void SAVAGESelectBuffer( ScrnInfoPtr pScrn, int which ) +{ + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate; + + psav->WaitIdleEmpty(psav); + + OUTREG(0x48C18,INREG(0x48C18)&(~0x00000008)); + + switch ( which ) { + case SAVAGE_BACK: + OUTREG( 0x8170, pSAVAGEDRI->backOffset ); + OUTREG( 0x8174, pSAVAGEDRI->backBitmapDesc ); + break; + case SAVAGE_DEPTH: + OUTREG( 0x8170, pSAVAGEDRI->depthOffset ); + OUTREG( 0x8174, pSAVAGEDRI->depthBitmapDesc ); + break; + default: + case SAVAGE_FRONT: + OUTREG( 0x8170, pSAVAGEDRI->frontOffset ); + OUTREG( 0x8174, pSAVAGEDRI->frontBitmapDesc ); + break; + } + OUTREG(0x48C18,INREG(0x48C18)|(0x00000008)); + psav->WaitIdleEmpty(psav); + +} + + +static unsigned int mylog2( unsigned int n ) +{ + unsigned int log2 = 1; + + n--; + while ( n > 1 ) n >>= 1, log2++; + + return log2; +} + +static Bool SAVAGEDRIAgpInit(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + unsigned long mode; + unsigned int vendor, device; + int ret; + int size,numbuffer,i; + savageAgpBufferPtr agpbuffer; + + /* FIXME: Make these configurable... + */ + /*pSAVAGEDRIServer->agp.size = 16 * 1024 * 1024;*/ + pSAVAGEDRIServer->agp.size = psav->agpSize * 1024 * 1024; + pSAVAGEDRIServer->agp.offset = pSAVAGEDRIServer->agp.size; + + pSAVAGEDRIServer->agpTextures.offset = 0; + /*pSAVAGEDRIServer->agpTextures.size = 16*1024*1024;*/ + pSAVAGEDRIServer->agpTextures.size = psav->agpSize * 1024 * 1024; + pSAVAGEDRIServer->logAgpTextureGranularity = 10; + + if ( drmAgpAcquire( psav->drmFD ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not available\n" ); + return FALSE; + } + + mode = drmAgpGetMode( psav->drmFD ); /* Default mode */ + vendor = drmAgpVendorId( psav->drmFD ); + device = drmAgpDeviceId( psav->drmFD ); + + mode &= ~SAVAGE_AGP_MODE_MASK; + + switch ( psav->agpMode ) { + case 4: + mode |= SAVAGE_AGP_4X_MODE; + case 2: + mode |= SAVAGE_AGP_2X_MODE; + case 1: + default: + mode |= SAVAGE_AGP_1X_MODE; + } + + /* mode |= SAVAGE_AGP_1X_MODE;*/ + + xf86DrvMsg( pScreen->myNum, X_INFO, + "[agp] Mode 0x%08lx [AGP 0x%04x/0x%04x; Card 0x%04x/0x%04x]\n", + mode, vendor, device, + psav->PciInfo->vendor, + psav->PciInfo->chipType ); + + if ( drmAgpEnable( psav->drmFD, mode ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not enabled\n" ); + drmAgpRelease( psav->drmFD ); + return FALSE; + } + + ret = drmAgpAlloc( psav->drmFD, pSAVAGEDRIServer->agp.size, + 0, NULL, &pSAVAGEDRIServer->agp.handle ); + if ( ret < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Out of memory (%d)\n", ret ); + drmAgpRelease( psav->drmFD ); + return FALSE; + } + xf86DrvMsg( pScreen->myNum, X_INFO, + "[agp] %d kB allocated with handle 0x%08x\n", + pSAVAGEDRIServer->agp.size/1024, pSAVAGEDRIServer->agp.handle ); + + if ( drmAgpBind( psav->drmFD, pSAVAGEDRIServer->agp.handle, 0 ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Could not bind memory\n" ); + drmAgpFree( psav->drmFD, pSAVAGEDRIServer->agp.handle ); + drmAgpRelease( psav->drmFD ); + return FALSE; + } + + if ( drmAddMap( psav->drmFD, + pSAVAGEDRIServer->agpTextures.offset, + pSAVAGEDRIServer->agpTextures.size, + DRM_AGP, 0, + &pSAVAGEDRIServer->agpTextures.handle ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[agp] Could not add agpTextures \n" ); + return FALSE; + } + /* pSAVAGEDRIServer->agp_offset=pSAVAGEDRIServer->agpTexture.size;*/ + xf86DrvMsg( pScreen->myNum, X_INFO, + "[agp] agpTextures microcode handle = 0x%08lx\n", + pSAVAGEDRIServer->agpTextures.handle ); + + /*if ( drmMap( psav->drmFD, + pSAVAGEDRIServer->agpTextures.handle, + pSAVAGEDRIServer->agpTextures.size, + &pSAVAGEDRIServer->agpTextures.map ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[agp] Could not map agpTextures \n" ); + return FALSE; + }*/ + + xf86DrvMsg( pScreen->myNum, X_INFO, + "[agp] agpTextures mapped at 0x%08lx\n", + (unsigned long)pSAVAGEDRIServer->agpTextures.map ); + + /* for agp dma buffer*/ + size = drmAgpSize(psav->drmFD); + size -= pSAVAGEDRIServer->agpTextures.size;/*sub texture size*/ + numbuffer = size / DRM_SAVAGE_DMA_AGP_SIZE; + agpbuffer = (savageAgpBufferPtr)xcalloc(sizeof(savageAgpBuffer),numbuffer); + for (i=0;i<numbuffer;i++) + { + agpbuffer[i].ctxOwner = 0; + agpbuffer[i].agp_offset = + pSAVAGEDRIServer->agpTextures.size + i* DRM_SAVAGE_DMA_AGP_SIZE; + agpbuffer[i].flags = 0; + agpbuffer[i].agp_handle = 0; + } + pSAVAGEDRIServer->numBuffer = numbuffer; + pSAVAGEDRIServer->agpBuffer = agpbuffer; + + return TRUE; +} + +static Bool SAVAGEDRIMapInit( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + + pSAVAGEDRIServer->registers.size = SAVAGEIOMAPSIZE; + + if ( drmAddMap( psav->drmFD, + (drm_handle_t)psav->MmioBase, + pSAVAGEDRIServer->registers.size, + DRM_REGISTERS,0, + &pSAVAGEDRIServer->registers.handle ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] Could not add MMIO registers mapping\n" ); + return FALSE; + } + + pSAVAGEDRIServer->aperture.size = 5 * 0x01000000; + + if ( drmAddMap( psav->drmFD, + (drm_handle_t)(psav->ApertureBase), + pSAVAGEDRIServer->aperture.size, + DRM_FRAME_BUFFER,0, + &pSAVAGEDRIServer->aperture.handle ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] Could not add aperture mapping\n" ); + return FALSE; + } + + xf86DrvMsg( pScreen->myNum, X_INFO, + "[drm] aperture handle = 0x%08lx\n", + pSAVAGEDRIServer->aperture.handle ); + + /*if(drmMap(psav->drmFD, + pSAVAGEDRIServer->registers.handle, + pSAVAGEDRIServer->registers.size, + &pSAVAGEDRIServer->registers.map)<0) + { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] Could not map MMIO registers region to virtual\n" ); + return FALSE; + + }*/ + + pSAVAGEDRIServer->status.size = SAREA_MAX; + + if ( drmAddMap( psav->drmFD, 0, pSAVAGEDRIServer->status.size, + DRM_SHM, DRM_READ_ONLY | DRM_LOCKED | DRM_KERNEL, + &pSAVAGEDRIServer->status.handle ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] Could not add status page mapping\n" ); + return FALSE; + } + xf86DrvMsg( pScreen->myNum, X_INFO, + "[drm] Status handle = 0x%08lx\n", + pSAVAGEDRIServer->status.handle ); + + if ( drmMap( psav->drmFD, + pSAVAGEDRIServer->status.handle, + pSAVAGEDRIServer->status.size, + &pSAVAGEDRIServer->status.map ) < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[agp] Could not map status page\n" ); + return FALSE; + } + xf86DrvMsg( pScreen->myNum, X_INFO, + "[agp] Status page mapped at 0x%08lx\n", + (unsigned long)pSAVAGEDRIServer->status.map ); + + return TRUE; +} + +/* no need DMA */ +#if 0 +static Bool SAVAGEDRIKernelInit( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + drmSAVAGEInit init; + int ret; + + memset( &init, 0, sizeof(drmSAVAGEInit) ); + + init.sarea_priv_offset = sizeof(XF86DRISAREARec); + + switch ( psav->Chipset ) { + case PCI_CHIP_SAVAGEG400: + init.chipset = SAVAGE_CARD_TYPE_G400; + break; + case PCI_CHIP_SAVAGEG200: + case PCI_CHIP_SAVAGEG200_PCI: + init.chipset = SAVAGE_CARD_TYPE_G200; + break; + default: + return FALSE; + } + init.sgram = !psav->HasSDRAM; + + init.maccess = psav->MAccess; + + init.fb_cpp = pScrn->bitsPerPixel / 8; + init.front_offset = pSAVAGEDRIServer->frontOffset; + init.front_pitch = pSAVAGEDRIServer->frontPitch / init.fb_cpp; + init.back_offset = pSAVAGEDRIServer->backOffset; + init.back_pitch = pSAVAGEDRIServer->backPitch / init.fb_cpp; + + init.depth_cpp = pScrn->bitsPerPixel / 8; + init.depth_offset = pSAVAGEDRIServer->depthOffset; + init.depth_pitch = pSAVAGEDRIServer->depthPitch / init.depth_cpp; + + init.texture_offset[0] = pSAVAGEDRIServer->textureOffset; + init.texture_size[0] = pSAVAGEDRIServer->textureSize; + + init.fb_offset = psav->FbAddress; + init.mmio_offset = pSAVAGEDRIServer->registers.handle; + init.status_offset = pSAVAGEDRIServer->status.handle; + + init.warp_offset = pSAVAGEDRIServer->warp.handle; + init.primary_offset = pSAVAGEDRIServer->primary.handle; + init.buffers_offset = pSAVAGEDRIServer->buffers.handle; + + ret = drmSAVAGEInitDMA( psav->drmFD, &init ); + if ( ret < 0 ) { + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Failed to initialize DMA! (%d)\n", ret ); + return FALSE; + } + +#if 0 + /* FIXME: This is just here to clean up after the engine reset test + * in the kernel module. Please remove it later... + */ + psav->GetQuiescence( pScrn ); +#endif + + return TRUE; +} + +static Bool SAVAGEDRIBuffersInit( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + + + pSAVAGEDRIServer->drmBuffers = drmMapBufs( psav->drmFD ); + if ( !pSAVAGEDRIServer->drmBuffers ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] Failed to map DMA buffers list\n" ); + return FALSE; + } + xf86DrvMsg( pScreen->myNum, X_INFO, + "[drm] Mapped %d DMA buffers\n", + pSAVAGEDRIServer->drmBuffers->count ); + + return TRUE; +} +#endif + +Bool SAVAGEDRIScreenInit( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + DRIInfoPtr pDRIInfo; + SAVAGEDRIPtr pSAVAGEDRI; + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer; + +/* disable first....*/ +#if 0 + switch ( psav->Chipset ) { + case PCI_CHIP_SAVAGEG400: + case PCI_CHIP_SAVAGEG200: +#if 0 + case PCI_CHIP_SAVAGEG200_PCI: +#endif + break; + default: + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Direct rendering only supported with AGP G200/G400 cards!\n" ); + return FALSE; + } +#endif + + /* Check that the GLX, DRI, and DRM modules have been loaded by testing + * for canonical symbols in each module. + */ + if ( !xf86LoaderCheckSymbol( "GlxSetVisualConfigs" ) ) return FALSE; + if ( !xf86LoaderCheckSymbol( "DRIScreenInit" ) ) return FALSE; + if ( !xf86LoaderCheckSymbol( "drmAvailable" ) ) return FALSE; + if ( !xf86LoaderCheckSymbol( "DRIQueryVersion" ) ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[dri] SAVAGEDRIScreenInit failed (libdri.a too old)\n" ); + return FALSE; + } + +/* disable first */ +#if 1 + /* Check the DRI version */ + { + int major, minor, patch; + DRIQueryVersion( &major, &minor, &patch ); + if ( major != 4 || minor < 0 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[dri] SAVAGEDRIScreenInit failed because of a version mismatch.\n" + "[dri] libDRI version = %d.%d.%d but version 4.0.x is needed.\n" + "[dri] Disabling the DRI.\n", + major, minor, patch ); + return FALSE; + } + } +#endif + + xf86DrvMsg( pScreen->myNum, X_INFO, + "[drm] bpp: %d depth: %d\n", + pScrn->bitsPerPixel, pScrn->depth ); + + if ( (pScrn->bitsPerPixel / 8) != 2 && + (pScrn->bitsPerPixel / 8) != 4 ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[dri] Direct rendering only supported in 16 and 32 bpp modes\n" ); + return FALSE; + } + + pDRIInfo = DRICreateInfoRec(); + if ( !pDRIInfo ) { + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[dri] DRICreateInfoRec() failed\n" ); + return FALSE; + } + psav->pDRIInfo = pDRIInfo; + + pDRIInfo->drmDriverName = SAVAGEKernelDriverName; + pDRIInfo->clientDriverName = SAVAGEClientDriverName; + if (xf86LoaderCheckSymbol("DRICreatePCIBusID")) { + pDRIInfo->busIdString = DRICreatePCIBusID(psav->PciInfo); + } else { + pDRIInfo->busIdString = xalloc(64); + sprintf(pDRIInfo->busIdString, + "PCI:%d:%d:%d", + psav->PciInfo->bus, + psav->PciInfo->device, + psav->PciInfo->func); + } + pDRIInfo->ddxDriverMajorVersion = 1/*SAVAGE_MAJOR_VERSION*/; + pDRIInfo->ddxDriverMinorVersion = 1/*SAVAGE_MINOR_VERSION*/; + pDRIInfo->ddxDriverPatchVersion = 16/*SAVAGE_PATCHLEVEL*/; + pDRIInfo->frameBufferPhysicalAddress = psav->FrameBufferBase; + pDRIInfo->frameBufferSize = psav->videoRambytes; + pDRIInfo->frameBufferStride = pScrn->displayWidth*(pScrn->bitsPerPixel/8); + pDRIInfo->ddxDrawableTableEntry = SAVAGE_MAX_DRAWABLES; + +/* mark off these... we use default */ +#if 0 + pDRIInfo->wrap.BlockHandler = SAVAGEBlockHandler; + pDRIInfo->wrap.WakeupHandler = SAVAGEWakeupHandler; +#endif + + pDRIInfo->wrap.ValidateTree = NULL; + pDRIInfo->wrap.PostValidateTree = NULL; + + pDRIInfo->createDummyCtx = TRUE; + pDRIInfo->createDummyCtxPriv = FALSE; + + if ( SAREA_MAX_DRAWABLES < SAVAGE_MAX_DRAWABLES ) { + pDRIInfo->maxDrawableTableEntry = SAREA_MAX_DRAWABLES; + } else { + pDRIInfo->maxDrawableTableEntry = SAVAGE_MAX_DRAWABLES; + } + + /* For now the mapping works by using a fixed size defined + * in the SAREA header. + */ + if ( sizeof(XF86DRISAREARec) + sizeof(SAVAGESAREAPrivRec) > SAREA_MAX ) { + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Data does not fit in SAREA\n" ); + return FALSE; + } + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, + "[drm] Sarea %d+%d: %d\n", + sizeof(XF86DRISAREARec), sizeof(SAVAGESAREAPrivRec), + sizeof(XF86DRISAREARec) + sizeof(SAVAGESAREAPrivRec) ); + + pDRIInfo->SAREASize = SAREA_MAX; + + pSAVAGEDRI = (SAVAGEDRIPtr)xcalloc( sizeof(SAVAGEDRIRec), 1 ); + if ( !pSAVAGEDRI ) { + DRIDestroyInfoRec( psav->pDRIInfo ); + psav->pDRIInfo = 0; + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Failed to allocate memory for private record\n" ); + return FALSE; + } + + pSAVAGEDRIServer = (SAVAGEDRIServerPrivatePtr) + xcalloc( sizeof(SAVAGEDRIServerPrivateRec), 1 ); + if ( !pSAVAGEDRIServer ) { + xfree( pSAVAGEDRI ); + DRIDestroyInfoRec( psav->pDRIInfo ); + psav->pDRIInfo = 0; + xf86DrvMsg( pScrn->scrnIndex, X_ERROR, + "[drm] Failed to allocate memory for private record\n" ); + return FALSE; + } + psav->DRIServerInfo = pSAVAGEDRIServer; + + pDRIInfo->devPrivate = pSAVAGEDRI; + pDRIInfo->devPrivateSize = sizeof(SAVAGEDRIRec); + pDRIInfo->contextSize = sizeof(SAVAGEDRIContextRec); + + pDRIInfo->CreateContext = SAVAGECreateContext; + pDRIInfo->DestroyContext = SAVAGEDestroyContext; + +/* we don't have double head */ +#if 0 + if ( xf86IsEntityShared( pScrn->entityList[0] ) ) { + pDRIInfo->SwapContext = SAVAGEDRISwapContextShared; + } else +#endif + + { + pDRIInfo->SwapContext = SAVAGEDRISwapContext; + } + +#if 0 + switch( pScrn->bitsPerPixel ) { + case 8: + pDRIInfo->InitBuffers = Savage8DRIInitBuffers; + pDRIInfo->MoveBuffers = Savage8DRIMoveBuffers; + case 16: + pDRIInfo->InitBuffers = Savage16DRIInitBuffers; + pDRIInfo->MoveBuffers = Savage16DRIMoveBuffers; + case 24: + pDRIInfo->InitBuffers = Savage24DRIInitBuffers; + pDRIInfo->MoveBuffers = Savage24DRIMoveBuffers; + case 32: + pDRIInfo->InitBuffers = Savage32DRIInitBuffers; + pDRIInfo->MoveBuffers = Savage32DRIMoveBuffers; + } +#endif + + pDRIInfo->InitBuffers = SAVAGEDRIInitBuffers; + pDRIInfo->MoveBuffers = SAVAGEDRIMoveBuffers; + pDRIInfo->OpenFullScreen = SAVAGEDRIOpenFullScreen; + pDRIInfo->CloseFullScreen = SAVAGEDRICloseFullScreen; + pDRIInfo->bufferRequests = DRI_ALL_WINDOWS; + + if ( !DRIScreenInit( pScreen, pDRIInfo, &psav->drmFD ) ) { + xfree( pSAVAGEDRIServer ); + psav->DRIServerInfo = 0; + xfree( pDRIInfo->devPrivate ); + pDRIInfo->devPrivate = 0; + DRIDestroyInfoRec( psav->pDRIInfo ); + psav->pDRIInfo = 0; + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[drm] DRIScreenInit failed. Disabling DRI.\n" ); + return FALSE; + } + +/* Disable these */ +#if 1 + /* Check the SAVAGE DRM version */ + { + drmVersionPtr version = drmGetVersion(psav->drmFD); + if ( version ) { + if ( version->version_major != 1 || + version->version_minor < 0 ) { + /* incompatible drm version */ + xf86DrvMsg( pScreen->myNum, X_ERROR, + "[dri] SAVAGEDRIScreenInit failed because of a version mismatch.\n" + "[dri] savage.o kernel module version is %d.%d.%d but version 3.0.x is needed.\n" + "[dri] Disabling DRI.\n", + version->version_major, + version->version_minor, + version->version_patchlevel ); + drmFreeVersion( version ); + SAVAGEDRICloseScreen( pScreen ); /* FIXME: ??? */ + return FALSE; + } + drmFreeVersion( version ); + } + } +#endif + +#if 0 + /* Calculate texture constants for AGP texture space. + * FIXME: move! + */ + { + CARD32 agpTextureOffset = SAVAGE_DMA_BUF_SZ * SAVAGE_DMA_BUF_NR; + CARD32 agpTextureSize = pSAVAGEDRI->agp.size - agpTextureOffset; + + i = mylog2(agpTextureSize / SAVAGE_NR_TEX_REGIONS); + if (i < SAVAGE_LOG_MIN_TEX_REGION_SIZE) + i = SAVAGE_LOG_MIN_TEX_REGION_SIZE; + + pSAVAGEDRI->logAgpTextureGranularity = i; + pSAVAGEDRI->agpTextureSize = (agpTextureSize >> i) << i; + pSAVAGEDRI->agpTextureOffset = agpTextureOffset; + } +#endif + + if ( !SAVAGEDRIAgpInit( pScreen ) ) { + DRICloseScreen( pScreen ); + return FALSE; + } + + if ( !SAVAGEDRIMapInit( pScreen ) ) { + DRICloseScreen( pScreen ); + return FALSE; + } + + if ( !SAVAGEInitVisualConfigs( pScreen ) ) { + DRICloseScreen( pScreen ); + return FALSE; + } + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[dri] visual configs initialized\n" ); + + return TRUE; +} + + +Bool SAVAGEDRIFinishScreenInit( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate; + int i; + unsigned int TileStride; + + + if ( !psav->pDRIInfo ) + return FALSE; + + psav->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT; + + /* NOTE: DRIFinishScreenInit must be called before *DRIKernelInit + * because *DRIKernelInit requires that the hardware lock is held by + * the X server, and the first time the hardware lock is grabbed is + * in DRIFinishScreenInit. + */ + if ( !DRIFinishScreenInit( pScreen ) ) { + SAVAGEDRICloseScreen( pScreen ); + return FALSE; + } + +/* no dma...... */ +#if 0 + if ( !SAVAGEDRIKernelInit( pScreen ) ) { + SAVAGEDRICloseScreen( pScreen ); + return FALSE; + } + + if ( !SAVAGEDRIBuffersInit( pScreen ) ) { + SAVAGEDRICloseScreen( pScreen ); + return FALSE; + } + + switch ( psav->Chipset ) { + case PCI_CHIP_SAVAGEG400: + pSAVAGEDRI->chipset = SAVAGE_CARD_TYPE_G400; + break; + case PCI_CHIP_SAVAGEG200: + case PCI_CHIP_SAVAGEG200_PCI: + pSAVAGEDRI->chipset = SAVAGE_CARD_TYPE_G200; + break; + default: + return FALSE; + } +#endif + + pSAVAGEDRI->chipset = psav->Chipset; + pSAVAGEDRI->width = pScrn->virtualX; + pSAVAGEDRI->height = pScrn->virtualY; + pSAVAGEDRI->mem = pScrn->videoRam * 1024; + pSAVAGEDRI->cpp = pScrn->bitsPerPixel / 8; + pSAVAGEDRI->zpp =pSAVAGEDRI->cpp; + pSAVAGEDRI->agpMode = psav->agpMode; + + pSAVAGEDRI->frontOffset = pSAVAGEDRIServer->frontOffset; + pSAVAGEDRI->frontbufferSize = pSAVAGEDRIServer->frontbufferSize; + pSAVAGEDRI->frontbuffer = psav->FrameBufferBase + + pSAVAGEDRI->frontOffset; + pSAVAGEDRI->frontPitch = pSAVAGEDRIServer->frontPitch; + pSAVAGEDRI->IsfrontTiled = psav->bTiled; /* AGD: was 0 */ + + if(pSAVAGEDRI->IsfrontTiled) + { + if(pSAVAGEDRI->cpp==2) + TileStride = (pSAVAGEDRI->width+63)&(~63); + else + TileStride = (pSAVAGEDRI->width+31)&(~31); + + if ((psav->Chipset == S3_TWISTER) + || (psav->Chipset == S3_PROSAVAGE) + || (psav->Chipset == S3_PROSAVAGEDDR) + || (psav->Chipset == S3_SUPERSAVAGE)) + { + pSAVAGEDRI->frontBitmapDesc = 0x10000000 | /* block write disabled */ + (1<<24) | /* destination tile format */ + (pScrn->bitsPerPixel<<16) | /* bpp */ + TileStride; /* stride */ + } else { + pSAVAGEDRI->frontBitmapDesc = 0x10000000 | /* block write disabled */ + ((pSAVAGEDRI->cpp==2)? + BCI_BD_TILE_16:BCI_BD_TILE_32) | /*16/32 bpp tile format */ + (pScrn->bitsPerPixel<<16) | /* bpp */ + TileStride; /* stride */ + pSAVAGEDRI->frontPitch = TileStride; + } + } + else + { + pSAVAGEDRI->frontBitmapDesc = 0x10000000 | /* AGD: block write should be disabled: was 0x00000000 */ + pScrn->bitsPerPixel<<16 | + pSAVAGEDRI->width; + } + + pSAVAGEDRI->backOffset = pSAVAGEDRIServer->backOffset; + pSAVAGEDRI->backbufferSize = pSAVAGEDRIServer->backbufferSize; + pSAVAGEDRI->backbuffer = psav->FrameBufferBase + + pSAVAGEDRI->backOffset; + pSAVAGEDRI->backPitch = pSAVAGEDRIServer->backPitch; + + { + if(pSAVAGEDRI->cpp==2) + TileStride = (pSAVAGEDRI->width+63)&(~63); + else + TileStride = (pSAVAGEDRI->width+31)&(~31); + + if ((psav->Chipset == S3_TWISTER) + || (psav->Chipset == S3_PROSAVAGE) + || (psav->Chipset == S3_PROSAVAGEDDR) + || (psav->Chipset == S3_SUPERSAVAGE)) /* AGD: supersavage may work like savage4/MX/IX, I just don't know. */ + { /* It's here since the 2D driver sets it up like prosavage */ + pSAVAGEDRI->backBitmapDesc = 0x10000000 | + (1<<24) | + (pScrn->bitsPerPixel<<16) | + TileStride; + } else { + pSAVAGEDRI->backBitmapDesc = 0x10000000 | + ((pSAVAGEDRI->cpp==2)? + BCI_BD_TILE_16:BCI_BD_TILE_32) | + (pScrn->bitsPerPixel<<16) | + TileStride; + } + } + + pSAVAGEDRI->depthOffset = pSAVAGEDRIServer->depthOffset; + pSAVAGEDRI->depthbufferSize = pSAVAGEDRIServer->depthbufferSize; + pSAVAGEDRI->depthbuffer = psav->FrameBufferBase + + pSAVAGEDRI->depthOffset; + pSAVAGEDRI->depthPitch = pSAVAGEDRIServer->depthPitch; + + { + if(pSAVAGEDRI->zpp==2) + TileStride = (pSAVAGEDRI->width+63)&(~63); + else + TileStride = (pSAVAGEDRI->width+31)&(~31); + + if ((psav->Chipset == S3_TWISTER) + || (psav->Chipset == S3_PROSAVAGE) + || (psav->Chipset == S3_PROSAVAGEDDR) + || (psav->Chipset == S3_SUPERSAVAGE)) + { + pSAVAGEDRI->depthBitmapDesc = 0x10000000 | + (1<<24) | + (pScrn->bitsPerPixel<<16) | + TileStride; + } else { + pSAVAGEDRI->depthBitmapDesc = 0x10000000 | + ((pSAVAGEDRI->zpp==2)? + BCI_BD_TILE_16:BCI_BD_TILE_32) | + (pScrn->bitsPerPixel<<16) | + TileStride; + } + } + + pSAVAGEDRI->textureOffset = pSAVAGEDRIServer->textureOffset; + pSAVAGEDRI->textures = psav->FrameBufferBase + + pSAVAGEDRI->textureOffset; + pSAVAGEDRI->textureSize = pSAVAGEDRIServer->textureSize; + + i = mylog2( pSAVAGEDRI->textureSize / SAVAGE_NR_TEX_REGIONS ); + if ( i < SAVAGE_LOG_MIN_TEX_REGION_SIZE ) + i = SAVAGE_LOG_MIN_TEX_REGION_SIZE; + + pSAVAGEDRI->logTextureGranularity = i; + pSAVAGEDRI->textureSize = (pSAVAGEDRI->textureSize >> i) << i; /* truncate */ + + pSAVAGEDRI->agpTextures.handle = pSAVAGEDRIServer->agpTextures.handle; + pSAVAGEDRI->agpTextures.offset = pSAVAGEDRIServer->agpTextures.offset; + pSAVAGEDRI->agpTextures.size = pSAVAGEDRIServer->agpTextures.size; + pSAVAGEDRI->agpTextures.map = pSAVAGEDRIServer->agpTextures.map; + + i = mylog2( pSAVAGEDRI->agpTextures.size / SAVAGE_NR_TEX_REGIONS ); + if ( i < SAVAGE_LOG_MIN_TEX_REGION_SIZE ) + i = SAVAGE_LOG_MIN_TEX_REGION_SIZE; + + pSAVAGEDRI->logAgpTextureGranularity = i; + pSAVAGEDRI->agpTextures.size = (pSAVAGEDRI->agpTextures.size >> i) << i; /* truncate */ + + pSAVAGEDRI->aperture.handle = pSAVAGEDRIServer->aperture.handle; + pSAVAGEDRI->aperture.size = pSAVAGEDRIServer->aperture.size; + pSAVAGEDRI->aperture.map = pSAVAGEDRIServer->aperture.map; + { + unsigned int shift = 0; + + if(pSAVAGEDRI->width > 1024) + shift = 1; + + /* pSAVAGEDRI->aperturePitch = psav->ulAperturePitch; */ + pSAVAGEDRI->aperturePitch = psav->ul3DAperturePitch; + } + + { + unsigned int value = 0; + + OUTREG(0x850C,(INREG(0x850C) | 0x00008000)); /* AGD: I don't think this does anything on 3D/MX/IX */ + /* maybe savage4 too... */ + /* we don't use Y range flag,so comment it */ + /* + if(pSAVAGEDRI->width <= 1024) + value |= (1<<29); + */ + if ((psav->Chipset == S3_SAVAGE_MX) /* 3D/MX/IX seem to set up the tile stride differently */ + || (psav->Chipset == S3_SAVAGE3D)) { + if(pSAVAGEDRI->cpp == 2) + { + value |= ((psav->l3DDelta / 4) >> 5) << 24; /* I assume psav->l3DDelta for 3D */ + value |= 2<<30; + } else { + value |= ((psav->l3DDelta / 4) >> 5) << 24; /* I assume psav->l3DDelta for 3D */ + value |= 3<<30; + } + + OUTREG(0x48C40, value|(pSAVAGEDRI->frontOffset) ); /* front */ + OUTREG(0x48C44, value|(pSAVAGEDRI->backOffset) ); /* back */ + OUTREG(0x48C48, value|(pSAVAGEDRI->depthOffset) ); /* depth */ + } else { + if(pSAVAGEDRI->cpp == 2) + { + value |= (((pSAVAGEDRI->width + 0x3F) & 0xFFC0) >> 6) << 20; + value |= 2<<30; + } else { + value |= (((pSAVAGEDRI->width + 0x1F) & 0xFFE0) >> 5) << 20; + value |= 3<<30; + } + + OUTREG(0x48C40, value|(pSAVAGEDRI->frontOffset >> 5) ); /* front */ + OUTREG(0x48C44, value|(pSAVAGEDRI->backOffset >> 5) ); /* back */ + OUTREG(0x48C48, value|(pSAVAGEDRI->depthOffset >> 5) ); /* depth */ + } + } + + pSAVAGEDRI->registers.handle = pSAVAGEDRIServer->registers.handle; + pSAVAGEDRI->registers.size = pSAVAGEDRIServer->registers.size; + pSAVAGEDRI->registers.map = pSAVAGEDRIServer->registers.map; + + pSAVAGEDRI->BCIcmdBuf.handle = pSAVAGEDRIServer->registers.handle+0x00010000; + pSAVAGEDRI->BCIcmdBuf.size = 0x00020000; + pSAVAGEDRI->BCIcmdBuf.map = (drmAddress)( (unsigned int) + pSAVAGEDRIServer->registers.map + + 0x00010000); + + pSAVAGEDRI->status.handle = pSAVAGEDRIServer->status.handle; + pSAVAGEDRI->status.size = pSAVAGEDRIServer->status.size; + pSAVAGEDRI->shadowStatus = psav->ShadowStatus; + +/* no DMA now ....*/ +#if 0 + pSAVAGEDRI->primary.handle = pSAVAGEDRIServer->primary.handle; + pSAVAGEDRI->primary.size = pSAVAGEDRIServer->primary.size; + pSAVAGEDRI->buffers.handle = pSAVAGEDRIServer->buffers.handle; + pSAVAGEDRI->buffers.size = pSAVAGEDRIServer->buffers.size; +#endif + + pSAVAGEDRI->sarea_priv_offset = sizeof(XF86DRISAREARec); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]pSAVAGEDRIServer:\n" ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] reserved_map_agpstart:0x%08x\n",pSAVAGEDRIServer->reserved_map_agpstart); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] reserved_map_idx:0x%08x\n",pSAVAGEDRIServer->reserved_map_idx); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] sarea_priv_offset:0x%08lx\n",pSAVAGEDRIServer->sarea_priv_offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] chipset:0x%08x\n",pSAVAGEDRIServer->chipset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] sgram:0x%08x\n",pSAVAGEDRIServer->sgram); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontbufferSize:0x%08x\n",pSAVAGEDRIServer->frontbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontOffset:0x%08x\n",pSAVAGEDRIServer->frontOffset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontPitch:0x%08x\n",pSAVAGEDRIServer->frontPitch); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backbufferSize:0x%08x\n",pSAVAGEDRIServer->backbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backOffset:0x%08x\n",pSAVAGEDRIServer->backOffset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backPitch:0x%08x\n",pSAVAGEDRIServer->backPitch); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthbufferSize:0x%08x\n",pSAVAGEDRIServer->depthbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthOffset:0x%08x\n",pSAVAGEDRIServer->depthOffset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthPitch:0x%08x\n",pSAVAGEDRIServer->depthPitch); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textureOffset:0x%08x\n",pSAVAGEDRIServer->textureOffset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textureSize:0x%08x\n",pSAVAGEDRIServer->textureSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textureSize:0x%08x\n",pSAVAGEDRIServer->textureSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] logTextureGranularity:0x%08x\n",pSAVAGEDRIServer->logTextureGranularity); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agp:handle:0x%08lx\n",pSAVAGEDRIServer->agp.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agp:offset:0x%08lx\n",pSAVAGEDRIServer->agp.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agp:size:0x%08lx\n",pSAVAGEDRIServer->agp.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agp:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->agp.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:handle:0x%08lx\n",pSAVAGEDRIServer->registers.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:offset:0x%08lx\n",pSAVAGEDRIServer->registers.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:size:0x%08lx\n",pSAVAGEDRIServer->registers.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->registers.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:handle:0x%08lx\n",pSAVAGEDRIServer->status.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:offset:0x%08lx\n",pSAVAGEDRIServer->status.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:size:0x%08lx\n",pSAVAGEDRIServer->status.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->status.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:handle:0x%08lx\n",pSAVAGEDRIServer->agpTextures.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:offset:0x%08lx\n",pSAVAGEDRIServer->agpTextures.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:size:0x%08lx\n",pSAVAGEDRIServer->agpTextures.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] apgTextures:map:0x%08lx\n",(unsigned long)pSAVAGEDRIServer->agpTextures.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] logAgpTextureGranularity:0x%08x\n",pSAVAGEDRIServer->logAgpTextureGranularity); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers]pSAVAGEDRI:\n" ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] chipset:0x%08x\n",pSAVAGEDRI->chipset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] width:0x%08x\n",pSAVAGEDRI->width ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] height:0x%08x\n",pSAVAGEDRI->height ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] mem:0x%08lx\n",pSAVAGEDRI->mem ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] cpp:%d\n",pSAVAGEDRI->cpp ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] zpp:%d\n",pSAVAGEDRI->zpp ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpMode:%d\n",pSAVAGEDRI->agpMode ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontbuffer:0x%08lx\n",pSAVAGEDRI->frontbuffer); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontbufferSize:0x%08x\n",pSAVAGEDRI->frontbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontOffset:0x%08x\n",pSAVAGEDRI->frontOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontPitch:0x%08x\n",pSAVAGEDRI->frontPitch ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] frontBitmapDesc:0x%08lx\n",pSAVAGEDRI->frontBitmapDesc ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backbuffer:0x%08lx\n",pSAVAGEDRI->backbuffer); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backbufferSize:0x%08x\n",pSAVAGEDRI->backbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backOffset:0x%08x\n",pSAVAGEDRI->backOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backPitch:0x%08x\n",pSAVAGEDRI->backPitch ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] backBitmapDesc:0x%08lx\n",pSAVAGEDRI->backBitmapDesc ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthbuffer:0x%08lx\n",pSAVAGEDRI->depthbuffer); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthbufferSize:0x%08x\n",pSAVAGEDRI->depthbufferSize); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthOffset:0x%08x\n",pSAVAGEDRI->depthOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthPitch:0x%08x\n",pSAVAGEDRI->depthPitch ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] depthBitmapDesc:0x%08lx\n",pSAVAGEDRI->depthBitmapDesc ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textures:0x%08lx\n",pSAVAGEDRI->textures ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textureOffset:0x%08x\n",pSAVAGEDRI->textureOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] textureSize:0x%08x\n",pSAVAGEDRI->textureSize ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] logTextureGranularity:0x%08x\n",pSAVAGEDRI->logTextureGranularity ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpBufferOffset:0x%08x\n",pSAVAGEDRI->agpBufferOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextureOffset:0x%08x\n",pSAVAGEDRI->agpTextureOffset ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextureSize:0x%08x\n",pSAVAGEDRI->agpTextureSize ); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] logAgpTextureGranularity:0x%08x\n",pSAVAGEDRI->logAgpTextureGranularity ); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:handle:0x%08lx\n",pSAVAGEDRI->agpTextures.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:offset:0x%08lx\n",pSAVAGEDRI->agpTextures.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] agpTextures:size:0x%08lx\n",pSAVAGEDRI->agpTextures.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] apgTextures:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->agpTextures.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:handle:0x%08lx\n",pSAVAGEDRI->registers.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:offset:0x%08lx\n",pSAVAGEDRI->registers.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:size:0x%08lx\n",pSAVAGEDRI->registers.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] registers:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->registers.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] aperture:handle:0x%08lx\n",pSAVAGEDRI->aperture.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] aperture:offset:0x%08lx\n",pSAVAGEDRI->aperture.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] aperture:size:0x%08lx\n",pSAVAGEDRI->aperture.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] aperture:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->aperture.map); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] aperturePitch:0x%08x\n",pSAVAGEDRI->aperturePitch); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] BCIcmdBuf:handle:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] BCIcmdBuf:offset:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] BCIcmdBuf:size:0x%08lx\n",pSAVAGEDRI->BCIcmdBuf.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] BCIcmdBuf:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->BCIcmdBuf.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:handle:0x%08lx\n",pSAVAGEDRI->status.handle); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:offset:0x%08lx\n",pSAVAGEDRI->status.offset); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:size:0x%08lx\n",pSAVAGEDRI->status.size); + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] status:map:0x%08lx\n",(unsigned long)pSAVAGEDRI->status.map); + + xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[junkers] sarea_priv_offset:0x%08lx\n",pSAVAGEDRI->sarea_priv_offset); + + return TRUE; +} + + +void SAVAGEDRICloseScreen( ScreenPtr pScreen ) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIServerPrivatePtr pSAVAGEDRIServer = psav->DRIServerInfo; + +/* no DMA now..... */ +#if 0 + if ( pSAVAGEDRIServer->drmBuffers ) { + drmUnmapBufs( pSAVAGEDRIServer->drmBuffers ); + pSAVAGEDRIServer->drmBuffers = NULL; + } + + drmSAVAGECleanupDMA( psav->drmFD ); +#endif + + if ( pSAVAGEDRIServer->status.map ) { + drmUnmap( pSAVAGEDRIServer->status.map, pSAVAGEDRIServer->status.size ); + pSAVAGEDRIServer->status.map = NULL; + } + + if ( pSAVAGEDRIServer->registers.map ) { + drmUnmap( pSAVAGEDRIServer->registers.map, pSAVAGEDRIServer->registers.size ); + pSAVAGEDRIServer->registers.map = NULL; + } + + + if ( pSAVAGEDRIServer->agpTextures.map ) { + drmUnmap( pSAVAGEDRIServer->agpTextures.map, + pSAVAGEDRIServer->agpTextures.size ); + pSAVAGEDRIServer->agpTextures.map = NULL; + } + + if (pSAVAGEDRIServer->status.handle) + drmRmMap(psav->drmFD,pSAVAGEDRIServer->status.handle); + + if (pSAVAGEDRIServer->registers.handle) + drmRmMap(psav->drmFD,pSAVAGEDRIServer->registers.handle); + + if (pSAVAGEDRIServer->agpTextures.handle) + drmRmMap(psav->drmFD,pSAVAGEDRIServer->agpTextures.handle); + +/* no DMA now.... */ +#if 0 + if ( pSAVAGEDRIServer->buffers.map ) { + drmUnmap( pSAVAGEDRIServer->buffers.map, pSAVAGEDRIServer->buffers.size ); + pSAVAGEDRIServer->buffers.map = NULL; + } + if ( pSAVAGEDRIServer->primary.map ) { + drmUnmap( pSAVAGEDRIServer->primary.map, pSAVAGEDRIServer->primary.size ); + pSAVAGEDRIServer->primary.map = NULL; + } + if ( pSAVAGEDRIServer->warp.map ) { + drmUnmap( pSAVAGEDRIServer->warp.map, pSAVAGEDRIServer->warp.size ); + pSAVAGEDRIServer->warp.map = NULL; + } +#endif + + if ( pSAVAGEDRIServer->agp.handle ) { + drmAgpUnbind( psav->drmFD, pSAVAGEDRIServer->agp.handle ); + drmAgpFree( psav->drmFD, pSAVAGEDRIServer->agp.handle ); + pSAVAGEDRIServer->agp.handle = 0; + drmAgpRelease( psav->drmFD ); + } + + DRICloseScreen( pScreen ); + + /*Don't use shadow status any more*/ + psav->ShadowVirtual = NULL; + psav->ShadowPhysical = 0; + + if(psav->reserved) + xf86FreeOffscreenLinear(psav->reserved); + + if ( psav->pDRIInfo ) { + if ( psav->pDRIInfo->devPrivate ) { + xfree( psav->pDRIInfo->devPrivate ); + psav->pDRIInfo->devPrivate = 0; + } + DRIDestroyInfoRec( psav->pDRIInfo ); + psav->pDRIInfo = 0; + } + if ( psav->DRIServerInfo ) { + xfree( psav->DRIServerInfo ); + psav->DRIServerInfo = 0; + } + if ( psav->pVisualConfigs ) { + xfree( psav->pVisualConfigs ); + } + if ( psav->pVisualConfigsPriv ) { + xfree( psav->pVisualConfigsPriv ); + } +} + +void +SAVAGEDRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + BoxPtr pbox = REGION_RECTS(prgn); + int nbox = REGION_NUM_RECTS(prgn); + + +#if 0 + CHECK_DMA_QUIESCENT(SAVPTR(pScrn), pScrn); +#endif +#if 0 + if(!psav->LockHeld) + psav->LockHeld = 1; + SAVAGEDRISetupForSolidFill(pScrn, 0, GXcopy, -1); + while (nbox--) { + SAVAGESelectBuffer(pScrn, SAVAGE_BACK); + SAVAGEDRISubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1, + pbox->x2-pbox->x1, pbox->y2-pbox->y1); + SAVAGESelectBuffer(pScrn, SAVAGE_DEPTH); + SAVAGEDRISubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1, + pbox->x2-pbox->x1, pbox->y2-pbox->y1); + pbox++; + } +#endif +#if 0 + { + SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate; + unsigned int *bcicmd; + BCI_GET_PTR; + /*bcicmd = (unsigned int *) psav->BciMem; + *(bcicmd) = 0x4BCC8000; + *(bcicmd) = 0x00F80000; + *(bcicmd) = 0x02000200; + *(bcicmd) = 0x01000100;*/ + BCI_SEND(0x4BCC8000); + BCI_SEND(0x00F80000); + BCI_SEND(0x02000200); + BCI_SEND(0x01000100); + sleep(5); + } +#endif +#if 0 + SAVAGESelectBuffer(pScrn, SAVAGE_FRONT); + psav->AccelInfoRec->NeedToSync = TRUE; +#endif +} + +/* + This routine is a modified form of XAADoBitBlt with the calls to + ScreenToScreenBitBlt built in. My routine has the prgnSrc as source + instead of destination. My origin is upside down so the ydir cases + are reversed. +*/ + +void +SAVAGEDRIMoveBuffers(WindowPtr pParent, DDXPointRec ptOldOrg, + RegionPtr prgnSrc, CARD32 index) +{ + ScreenPtr pScreen = pParent->drawable.pScreen; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + int nbox; + BoxPtr pbox, pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2; + DDXPointPtr pptTmp, pptNew1, pptNew2; + int xdir, ydir; + int dx, dy; + DDXPointPtr pptSrc; + int screenwidth = pScrn->virtualX; + int screenheight = pScrn->virtualY; + +#if 1 +#if 0 + CHECK_DMA_QUIESCENT(SAVPTR(pScrn), pScrn); +#endif + if(!psav->LockHeld) + psav->LockHeld = 1; + + pbox = REGION_RECTS(prgnSrc); + nbox = REGION_NUM_RECTS(prgnSrc); + pboxNew1 = 0; + pptNew1 = 0; + pboxNew2 = 0; + pboxNew2 = 0; + pptSrc = &ptOldOrg; + + dx = pParent->drawable.x - ptOldOrg.x; + dy = pParent->drawable.y - ptOldOrg.y; + + /* If the copy will overlap in Y, reverse the order */ + if (dy>0) { + ydir = -1; + + if (nbox>1) { + /* Keep ordering in each band, reverse order of bands */ + pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox); + if (!pboxNew1) return; + pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox); + if (!pptNew1) { + DEALLOCATE_LOCAL(pboxNew1); + return; + } + pboxBase = pboxNext = pbox+nbox-1; + while (pboxBase >= pbox) { + while ((pboxNext >= pbox) && (pboxBase->y1 == pboxNext->y1)) + pboxNext--; + pboxTmp = pboxNext+1; + pptTmp = pptSrc + (pboxTmp - pbox); + while (pboxTmp <= pboxBase) { + *pboxNew1++ = *pboxTmp++; + *pptNew1++ = *pptTmp++; + } + pboxBase = pboxNext; + } + pboxNew1 -= nbox; + pbox = pboxNew1; + pptNew1 -= nbox; + pptSrc = pptNew1; + } + } else { + /* No changes required */ + ydir = 1; + } + + /* If the regions will overlap in X, reverse the order */ + if (dx>0) { + xdir = -1; + + if (nbox > 1) { + /*reverse orderof rects in each band */ + pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox); + pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox); + if (!pboxNew2 || !pptNew2) { + if (pptNew2) DEALLOCATE_LOCAL(pptNew2); + if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2); + if (pboxNew1) { + DEALLOCATE_LOCAL(pptNew1); + DEALLOCATE_LOCAL(pboxNew1); + } + return; + } + pboxBase = pboxNext = pbox; + while (pboxBase < pbox+nbox) { + while ((pboxNext < pbox+nbox) && + (pboxNext->y1 == pboxBase->y1)) + pboxNext++; + pboxTmp = pboxNext; + pptTmp = pptSrc + (pboxTmp - pbox); + while (pboxTmp != pboxBase) { + *pboxNew2++ = *--pboxTmp; + *pptNew2++ = *--pptTmp; + } + pboxBase = pboxNext; + } + pboxNew2 -= nbox; + pbox = pboxNew2; + pptNew2 -= nbox; + pptSrc = pptNew2; + } + } else { + /* No changes are needed */ + xdir = 1; + } +#if 0 + SAVAGEDRISetupForScreenToScreenCopy(pScrn, xdir, ydir, GXcopy, -1, -1); + for ( ; nbox-- ; pbox++) + { + int x1 = pbox->x1; + int y1 = pbox->y1; + int destx = x1 + dx; + int desty = y1 + dy; + int w = pbox->x2 - x1 + 1; + int h = pbox->y2 - y1 + 1; + + if ( destx < 0 ) x1 -= destx, w += destx, destx = 0; + if ( desty < 0 ) y1 -= desty, h += desty, desty = 0; + if ( destx + w > screenwidth ) w = screenwidth - destx; + if ( desty + h > screenheight ) h = screenheight - desty; + if ( w <= 0 ) continue; + if ( h <= 0 ) continue; + + SAVAGESelectBuffer(pScrn, SAVAGE_BACK); + SAVAGEDRISubsequentScreenToScreenCopy(pScrn, x1, y1, + destx,desty, w, h); + SAVAGESelectBuffer(pScrn, SAVAGE_DEPTH); + SAVAGEDRISubsequentScreenToScreenCopy(pScrn, x1,y1, + destx,desty, w, h); + } + SAVAGESelectBuffer(pScrn, SAVAGE_FRONT); + + if (pboxNew2) { + DEALLOCATE_LOCAL(pptNew2); + DEALLOCATE_LOCAL(pboxNew2); + } + if (pboxNew1) { + DEALLOCATE_LOCAL(pptNew1); + DEALLOCATE_LOCAL(pboxNew1); + } + + psav->AccelInfoRec->NeedToSync = TRUE; +#endif +#endif +} + +static void +SAVAGEDRISetupForScreenToScreenCopy( + ScrnInfoPtr pScrn, + int xdir, + int ydir, + int rop, + unsigned planemask, + int transparency_color) +{ + SavagePtr psav = SAVPTR(pScrn); + int cmd =0; + + cmd = BCI_CMD_RECT | BCI_CMD_DEST_PBD | BCI_CMD_SRC_PBD_COLOR; + BCI_CMD_SET_ROP( cmd, XAACopyROP[rop] ); + if (transparency_color != -1) + cmd |= BCI_CMD_SEND_COLOR | BCI_CMD_SRC_TRANSPARENT; + + if (xdir == 1 ) cmd |= BCI_CMD_RECT_XP; + if (ydir == 1 ) cmd |= BCI_CMD_RECT_YP; + + psav->SavedBciCmd = cmd; + psav->SavedBgColor = transparency_color; + +} + +static void +SAVAGEDRISubsequentScreenToScreenCopy( + ScrnInfoPtr pScrn, + int x1, + int y1, + int x2, + int y2, + int w, + int h) +{ + SavagePtr psav = SAVPTR(pScrn); + BCI_GET_PTR; + + if (!w || !h) return; + if (!(psav->SavedBciCmd & BCI_CMD_RECT_XP)) { + w --; + x1 += w; + x2 += w; + w ++; + } + if (!(psav->SavedBciCmd & BCI_CMD_RECT_YP)) { + h --; + y1 += h; + y2 += h; + h ++; + } + + psav->WaitQueue(psav,6); + BCI_SEND(psav->SavedBciCmd); + if (psav->SavedBgColor != -1) + BCI_SEND(psav->SavedBgColor); + BCI_SEND(BCI_X_Y(x1, y1)); + BCI_SEND(BCI_X_Y(x2, y2)); + BCI_SEND(BCI_W_H(w, h)); + +} + + +/* + * SetupForSolidFill is also called to set up for lines. + */ +#if 0 +static void +SAVAGEDRISetupForSolidFill( + ScrnInfoPtr pScrn, + int color, + int rop, + unsigned planemask) +{ + SavagePtr psav = SAVPTR(pScrn); + XAAInfoRecPtr xaaptr = GET_XAAINFORECPTR_FROM_SCRNINFOPTR( pScrn ); + int cmd; + int mix; + + cmd = BCI_CMD_RECT + | BCI_CMD_RECT_XP | BCI_CMD_RECT_YP + | BCI_CMD_DEST_PBD | BCI_CMD_SRC_SOLID; + + /* Don't send a color if we don't have to. */ + + if( rop == GXcopy ) + { + if( color == 0 ) + rop = GXclear; + else if( color == xaaptr->FullPlanemask ) + rop = GXset; + } + +#if 1 + mix = SavageHelpSolidROP( pScrn, &color, planemask, &rop ); +#endif + if( mix & ROP_PAT ) + cmd |= BCI_CMD_SEND_COLOR; + + BCI_CMD_SET_ROP( cmd, rop ); + + psav->SavedBciCmd = cmd; + psav->SavedFgColor = color; +} +#endif + +static void +SAVAGEDRISubsequentSolidFillRect( + ScrnInfoPtr pScrn, + int x, + int y, + int w, + int h) +{ + SavagePtr psav = SAVPTR(pScrn); + BCI_GET_PTR; + + if( !w || !h ) + return; + + psav->WaitQueue(psav,5); + + BCI_SEND(psav->SavedBciCmd); + if( psav->SavedBciCmd & BCI_CMD_SEND_COLOR ) + BCI_SEND(psav->SavedFgColor); + BCI_SEND(BCI_X_Y(x, y)); + BCI_SEND(BCI_W_H(w, h)); +} + + +static Bool +SAVAGEDRIOpenFullScreen(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + vgaHWPtr hwp = VGAHWPTR(pScrn); + SavagePtr psav = SAVPTR(pScrn); + unsigned int vgaCRIndex = hwp->IOBase + 4; + unsigned int vgaCRReg = hwp->IOBase + 5; + SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate; + unsigned int TileStride; + unsigned int WidthinTiles; + unsigned int depth; + + OUTREG(0x48C18, INREG(0x48C18) & 0xFFFFFFF7); + /*VGAOUT8(vgaCRIndex,0x66); + VGAOUT8(vgaCRReg, VGAIN8(vgaCRReg)|0x10);*/ + VGAOUT8(vgaCRIndex,0x69); + VGAOUT8(vgaCRReg, 0x80); + + depth = pScrn->bitsPerPixel; + + if(depth == 16) + { + WidthinTiles = (pSAVAGEDRI->width+63)>>6; + TileStride = (pSAVAGEDRI->width+63)&(~63); + + } + else + { + WidthinTiles = (pSAVAGEDRI->width+31)>>5; + TileStride = (pSAVAGEDRI->width+31)&(~31); + + } + + + /* set primary stream stride */ + { + unsigned int value; + + /*value = 0x80000000|(WidthinTiles<<24)|(TileStride*depth/8);*/ + value = 0x80000000|(WidthinTiles<<24); + if(depth == 32) + value |= 0x40000000; + + OUTREG(PRI_STREAM_STRIDE, value); + + } + + /* set global bitmap descriptor */ + { + unsigned int value; + value = 0x10000000| + 0x00000009| + 0x01000000| + (depth<<16) | TileStride; + + OUTREG(0x816C,value); + + } + + OUTREG(0x48C18, INREG(0x48C18) | 0x8); + + return TRUE; +} + +static Bool +SAVAGEDRICloseFullScreen(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + SavagePtr psav = SAVPTR(pScrn); + SAVAGEDRIPtr pSAVAGEDRI = (SAVAGEDRIPtr)psav->pDRIInfo->devPrivate; + unsigned int depth = pScrn->bitsPerPixel; + BCI_GET_PTR; + + BCI_SEND(0xC0FF0000); + psav->WaitIdleEmpty(psav); + OUTREG(0x48C18, INREG(0x48C18) & 0xFFFFFFF7); + /* set primary stream stride */ + { + /* MM81C0 and 81C4 are used to control primary stream. */ + OUTREG32(PRI_STREAM_FBUF_ADDR0,0x00000000); + OUTREG32(PRI_STREAM_FBUF_ADDR1,0x00000000); + + /* FIFO control */ + OUTREG32(0X81EC,0Xffffffff); + + if (!psav->bTiled) { + OUTREG32(PRI_STREAM_STRIDE, + (((psav->lDelta * 2) << 16) & 0x3FFFE000) | + (psav->lDelta & 0x00001fff)); + } + else if (pScrn->bitsPerPixel == 16) { + /* Scanline-length-in-bytes/128-bytes-per-tile * 256 Qwords/tile */ + OUTREG32(PRI_STREAM_STRIDE, + (((psav->lDelta * 2) << 16) & 0x3FFFE000) + | 0x80000000 | (psav->lDelta & 0x00001fff)); + } + else if (pScrn->bitsPerPixel == 32) { + OUTREG32(PRI_STREAM_STRIDE, + (((psav->lDelta * 2) << 16) & 0x3FFFE000) + | 0xC0000000 | (psav->lDelta & 0x00001fff)); + } + + + } + + /* set global bitmap descriptor */ + { + OUTREG32(S3_GLB_BD_LOW,psav->GlobalBD.bd2.LoPart ); + OUTREG32(S3_GLB_BD_HIGH,psav->GlobalBD.bd2.HiPart | BCI_ENABLE | S3_LITTLE_ENDIAN | S3_BD64); + + } + + OUTREG(0x48C18, INREG(0x48C18) | 0x8); + return TRUE; +} +/* get the physics address (for shadow status)*/ +unsigned long SAVAGEDRIGetPhyAddress(ScrnInfoPtr pScrn,void * pointer) +{ + + SavagePtr psav = SAVPTR(pScrn); + + drm_savage_get_physcis_address_t req; + int ret; + + req.v_address = (unsigned long )pointer; + ret = ioctl(psav->drmFD, DRM_IOCTL_SAVAGE_GET_PHYSICS_ADDRESS,&req); + if (ret != 1) + fprintf(stderr,"[GetPhyAddress],Wrong virtual address.\n"); + return req.p_address; +} + +#endif |