summaryrefslogtreecommitdiff
path: root/src/mga_dri.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/mga_dri.c')
-rw-r--r--src/mga_dri.c1418
1 files changed, 1418 insertions, 0 deletions
diff --git a/src/mga_dri.c b/src/mga_dri.c
new file mode 100644
index 0000000..37d3a9a
--- /dev/null
+++ b/src/mga_dri.c
@@ -0,0 +1,1418 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/mga/mga_dri.c,v 1.28 2003/02/08 21:26:58 dawes Exp $ */
+
+/*
+ * Copyright 2000 VA Linux Systems Inc., Fremont, California.
+ * 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, 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 (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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * VA LINUX SYSTEMS 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.
+ *
+ * Authors:
+ * Keith Whitwell <keith@tungstengraphics.com>
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "xf86.h"
+#include "xf86_OSproc.h"
+#include "xf86_ansic.h"
+#include "xf86Priv.h"
+
+#include "xf86PciInfo.h"
+#include "xf86Pci.h"
+#define PSZ 8
+#include "cfb.h"
+#undef PSZ
+#include "cfb16.h"
+#include "cfb32.h"
+
+#include "miline.h"
+
+
+
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "mga_dri.h"
+#include "mga_sarea.h"
+
+#define _XF86DRI_SERVER_
+#include "GL/glxtokens.h"
+#include "sarea.h"
+
+
+
+
+
+#include "GL/glxtokens.h"
+
+#include "mga_bios.h"
+#include "mga_reg.h"
+#include "mga.h"
+#include "mga_macros.h"
+#include "mga_dri.h"
+
+#include "mga_sarea.h"
+
+static char MGAKernelDriverName[] = "mga";
+static char MGAClientDriverName[] = "mga";
+
+/* DRI buffer management
+ */
+extern void Mga8DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga8DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga16DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga16DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga24DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga24DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+extern void Mga32DRIInitBuffers( WindowPtr pWin, RegionPtr prgn,
+ CARD32 index );
+extern void Mga32DRIMoveBuffers( WindowPtr pParent, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc, CARD32 index );
+
+
+/* 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 MGAInitVisualConfigs( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ int numConfigs = 0;
+ __GLXvisualConfig *pConfigs = 0;
+ MGAConfigPrivPtr pMGAConfigs = 0;
+ MGAConfigPrivPtr *pMGAConfigPtrs = 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;
+ }
+
+ pMGAConfigs = (MGAConfigPrivPtr)xcalloc( sizeof(MGAConfigPrivRec),
+ numConfigs );
+ if ( !pMGAConfigs ) {
+ xfree( pConfigs );
+ return FALSE;
+ }
+
+ pMGAConfigPtrs = (MGAConfigPrivPtr*)xcalloc( sizeof(MGAConfigPrivPtr),
+ numConfigs );
+ if ( !pMGAConfigPtrs ) {
+ xfree( pConfigs );
+ xfree( pMGAConfigs );
+ return FALSE;
+ }
+
+ for ( i = 0 ; i < numConfigs ; i++ ) {
+ pMGAConfigPtrs[i] = &pMGAConfigs[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;
+ }
+
+ pMGAConfigs = (MGAConfigPrivPtr)xcalloc( sizeof(MGAConfigPrivRec),
+ numConfigs );
+ if ( !pMGAConfigs ) {
+ xfree( pConfigs );
+ return FALSE;
+ }
+
+ pMGAConfigPtrs = (MGAConfigPrivPtr*)xcalloc( sizeof(MGAConfigPrivPtr),
+ numConfigs );
+ if ( !pMGAConfigPtrs ) {
+ xfree( pConfigs );
+ xfree( pMGAConfigs );
+ return FALSE;
+ }
+
+ for ( i = 0 ; i < numConfigs ; i++ ) {
+ pMGAConfigPtrs[i] = &pMGAConfigs[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 = 0;
+ pConfigs[i].redMask = 0x00FF0000;
+ pConfigs[i].greenMask = 0x0000FF00;
+ pConfigs[i].blueMask = 0x000000FF;
+ pConfigs[i].alphaMask = 0x0;
+ 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 = 24;
+ 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;
+ }
+
+ pMga->numVisualConfigs = numConfigs;
+ pMga->pVisualConfigs = pConfigs;
+ pMga->pVisualConfigsPriv = pMGAConfigs;
+
+ GlxSetVisualConfigs( numConfigs, pConfigs, (void **)pMGAConfigPtrs );
+
+ return TRUE;
+}
+
+static Bool MGACreateContext( ScreenPtr pScreen, VisualPtr visual,
+ drmContext hwContext, void *pVisualConfigPriv,
+ DRIContextType contextStore )
+{
+ /* Nothing yet */
+ return TRUE;
+}
+
+static void MGADestroyContext( ScreenPtr pScreen, drmContext hwContext,
+ DRIContextType contextStore )
+{
+ /* Nothing yet */
+}
+
+
+/* Quiescence, locking
+ */
+#define MGA_TIMEOUT 2048
+
+static void MGAWaitForIdleDMA( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ drmMGALock lock;
+ int ret;
+ int i = 0;
+
+ memset( &lock, 0, sizeof(drmMGALock) );
+
+ for (;;) {
+ do {
+ /* first ask for quiescent and flush */
+ lock.flags = DRM_MGA_LOCK_QUIESCENT | DRM_MGA_LOCK_FLUSH;
+ do {
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_FLUSH,
+ &lock, sizeof( drmMGALock ) );
+ } while ( ret == -EBUSY && i++ < DRM_MGA_IDLE_RETRY );
+
+ /* if it's still busy just try quiescent */
+ if ( ret == -EBUSY ) {
+ lock.flags = DRM_MGA_LOCK_QUIESCENT;
+ do {
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_FLUSH,
+ &lock, sizeof( drmMGALock ) );
+ } while ( ret == -EBUSY && i++ < DRM_MGA_IDLE_RETRY );
+ }
+ } while ( ( ret == -EBUSY ) && ( i++ < MGA_TIMEOUT ) );
+
+ if ( ret == 0 )
+ return;
+
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[dri] Idle timed out, resetting engine...\n" );
+
+ drmCommandNone( pMga->drmFD, DRM_MGA_RESET );
+ }
+}
+
+
+void MGAGetQuiescence( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ DRILock( screenInfo.screens[pScrn->scrnIndex], 0 );
+ pMga->haveQuiescense = 1;
+
+ if ( pMga->directRenderingEnabled ) {
+ MGAFBLayout *pLayout = &pMga->CurrentLayout;
+
+ MGAWaitForIdleDMA( pScrn );
+
+ WAITFIFO( 11 );
+ OUTREG( MGAREG_MACCESS, pMga->MAccess );
+ OUTREG( MGAREG_PITCH, pLayout->displayWidth );
+
+ pMga->PlaneMask = ~0;
+ OUTREG( MGAREG_PLNWT, pMga->PlaneMask );
+
+ pMga->BgColor = 0;
+ pMga->FgColor = 0;
+ OUTREG( MGAREG_BCOL, pMga->BgColor );
+ OUTREG( MGAREG_FCOL, pMga->FgColor );
+ OUTREG( MGAREG_SRCORG, pMga->realSrcOrg );
+
+ pMga->SrcOrg = 0;
+ OUTREG( MGAREG_DSTORG, pMga->DstOrg );
+ OUTREG( MGAREG_OPMODE, MGAOPM_DMA_BLIT );
+ OUTREG( MGAREG_CXBNDRY, 0xFFFF0000 ); /* (maxX << 16) | minX */
+ OUTREG( MGAREG_YTOP, 0x00000000 ); /* minPixelPointer */
+ OUTREG( MGAREG_YBOT, 0x007FFFFF ); /* maxPixelPointer */
+
+ pMga->AccelFlags &= ~CLIPPER_ON;
+ }
+}
+
+void MGAGetQuiescenceShared( ScrnInfoPtr pScrn )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt = pMga->entityPrivate;
+ MGAPtr pMGA2 = MGAPTR(pMGAEnt->pScrn_2);
+
+ DRILock( screenInfo.screens[pMGAEnt->pScrn_1->scrnIndex], 0 );
+
+ pMga = MGAPTR(pMGAEnt->pScrn_1);
+ pMga->haveQuiescense = 1;
+ pMGA2->haveQuiescense = 1;
+
+ if ( pMGAEnt->directRenderingEnabled ) {
+ MGAWaitForIdleDMA( pMGAEnt->pScrn_1 );
+ pMga->RestoreAccelState( pScrn );
+ xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+ }
+}
+
+static void MGASwapContext( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+
+ /* Arrange for dma_quiescence and xaa sync to be called as
+ * appropriate.
+ */
+ pMga->haveQuiescense = 0;
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+}
+
+static void MGASwapContextShared( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt = pMga->entityPrivate;
+ MGAPtr pMGA2 = MGAPTR(pMGAEnt->pScrn_2);
+
+ pMga = MGAPTR(pMGAEnt->pScrn_1);
+
+ pMga->haveQuiescense = 0;
+ pMga->AccelInfoRec->NeedToSync = TRUE;
+
+ pMGA2->haveQuiescense = 0;
+ pMGA2->AccelInfoRec->NeedToSync = TRUE;
+}
+
+/* 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
+MGADRISwapContext( 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 )
+ {
+ MGASwapContext( pScreen );
+ }
+#endif
+}
+
+static void
+MGADRISwapContextShared( 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 )
+ {
+ MGASwapContextShared( pScreen );
+ }
+#endif
+}
+
+
+static void MGAWakeupHandler( int screenNum, pointer wakeupData,
+ unsigned long result, pointer pReadmask )
+{
+ ScreenPtr pScreen = screenInfo.screens[screenNum];
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ MGASwapContextShared( pScreen );
+ } else {
+ MGASwapContext( pScreen );
+ }
+}
+
+static void MGABlockHandler( int screenNum, pointer blockData,
+ pointer pTimeout, pointer pReadmask )
+
+{
+ ScreenPtr pScreen = screenInfo.screens[screenNum];
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGAEntPtr pMGAEnt;
+
+ if ( pMga->haveQuiescense ) {
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ /* Restore to first screen */
+ pMga->RestoreAccelState( pScrn );
+ xf86SetLastScrnFlag( pScrn->entityList[0], pScrn->scrnIndex );
+ pMGAEnt = pMga->entityPrivate;
+
+ if ( pMGAEnt->directRenderingEnabled ) {
+ DRIUnlock( screenInfo.screens[pMGAEnt->pScrn_1->scrnIndex] );
+ }
+ } else {
+ if ( pMga->directRenderingEnabled ) {
+ DRIUnlock( pScreen );
+ }
+ }
+ pMga->haveQuiescense = 0;
+ }
+}
+
+void MGASelectBuffer( ScrnInfoPtr pScrn, int which )
+{
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIPtr pMGADRI = (MGADRIPtr)pMga->pDRIInfo->devPrivate;
+
+ switch ( which ) {
+ case MGA_BACK:
+ OUTREG( MGAREG_DSTORG, pMGADRI->backOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->backOffset );
+ break;
+ case MGA_DEPTH:
+ OUTREG( MGAREG_DSTORG, pMGADRI->depthOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->depthOffset );
+ break;
+ default:
+ case MGA_FRONT:
+ OUTREG( MGAREG_DSTORG, pMGADRI->frontOffset );
+ OUTREG( MGAREG_SRCORG, pMGADRI->frontOffset );
+ break;
+ }
+}
+
+
+static unsigned int mylog2( unsigned int n )
+{
+ unsigned int log2 = 1;
+ while ( n > 1 ) n >>= 1, log2++;
+ return log2;
+}
+
+static Bool MGADRIAgpInit(ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ unsigned long mode;
+ unsigned int vendor, device;
+ int ret, count, i;
+
+ if(pMga->agpSize < 12)pMga->agpSize = 12;
+ if(pMga->agpSize > 64)pMga->agpSize = 64; /* cap */
+
+ /* FIXME: Make these configurable...
+ */
+ pMGADRIServer->agp.size = pMga->agpSize * 1024 * 1024;
+
+ pMGADRIServer->warp.offset = 0;
+ pMGADRIServer->warp.size = MGA_WARP_UCODE_SIZE;
+
+ pMGADRIServer->primary.offset = (pMGADRIServer->warp.offset +
+ pMGADRIServer->warp.size);
+ pMGADRIServer->primary.size = 1024 * 1024;
+
+ pMGADRIServer->buffers.offset = (pMGADRIServer->primary.offset +
+ pMGADRIServer->primary.size);
+ pMGADRIServer->buffers.size = MGA_NUM_BUFFERS * MGA_BUFFER_SIZE;
+
+
+ pMGADRIServer->agpTextures.offset = (pMGADRIServer->buffers.offset +
+ pMGADRIServer->buffers.size);
+
+ pMGADRIServer->agpTextures.size = pMGADRIServer->agp.size -
+ pMGADRIServer->agpTextures.offset;
+
+ if ( drmAgpAcquire( pMga->drmFD ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not available\n" );
+ return FALSE;
+ }
+
+ mode = drmAgpGetMode( pMga->drmFD ); /* Default mode */
+ vendor = drmAgpVendorId( pMga->drmFD );
+ device = drmAgpDeviceId( pMga->drmFD );
+
+ mode &= ~MGA_AGP_MODE_MASK;
+ switch ( pMga->agpMode ) {
+ case 4:
+ mode |= MGA_AGP_4X_MODE;
+ case 2:
+ mode |= MGA_AGP_2X_MODE;
+ case 1:
+ default:
+ mode |= MGA_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,
+ pMga->PciInfo->vendor,
+ pMga->PciInfo->chipType );
+
+ if ( drmAgpEnable( pMga->drmFD, mode ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] AGP not enabled\n" );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+
+ if ( pMga->Chipset == PCI_CHIP_MGAG200 ) {
+ switch ( pMga->agpMode ) {
+ case 2:
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Enabling AGP 2x PLL encoding\n" );
+ OUTREG( MGAREG_AGP_PLL, MGA_AGP2XPLL_ENABLE );
+ break;
+
+ case 1:
+ default:
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Disabling AGP 2x PLL encoding\n" );
+ OUTREG( MGAREG_AGP_PLL, MGA_AGP2XPLL_DISABLE );
+ pMga->agpMode = 1;
+ break;
+ }
+ }
+
+ ret = drmAgpAlloc( pMga->drmFD, pMGADRIServer->agp.size,
+ 0, NULL, &pMGADRIServer->agp.handle );
+ if ( ret < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Out of memory (%d)\n", ret );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] %d kB allocated with handle 0x%08x\n",
+ pMGADRIServer->agp.size/1024, pMGADRIServer->agp.handle );
+
+ if ( drmAgpBind( pMga->drmFD, pMGADRIServer->agp.handle, 0 ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR, "[agp] Could not bind memory\n" );
+ drmAgpFree( pMga->drmFD, pMGADRIServer->agp.handle );
+ drmAgpRelease( pMga->drmFD );
+ return FALSE;
+ }
+
+ /* WARP microcode space
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->warp.offset,
+ pMGADRIServer->warp.size,
+ DRM_AGP, DRM_READ_ONLY,
+ &pMGADRIServer->warp.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add WARP microcode mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] WARP microcode handle = 0x%08lx\n",
+ pMGADRIServer->warp.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->warp.handle,
+ pMGADRIServer->warp.size,
+ &pMGADRIServer->warp.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map WARP microcode\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] WARP microcode mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->warp.map );
+
+ /* Primary DMA space
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->primary.offset,
+ pMGADRIServer->primary.size,
+ DRM_AGP, DRM_READ_ONLY,
+ &pMGADRIServer->primary.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add primary DMA mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Primary DMA handle = 0x%08lx\n",
+ pMGADRIServer->primary.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->primary.handle,
+ pMGADRIServer->primary.size,
+ &pMGADRIServer->primary.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map primary DMA\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] Primary DMA mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->primary.map );
+
+ /* DMA buffers
+ */
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->buffers.offset,
+ pMGADRIServer->buffers.size,
+ DRM_AGP, 0,
+ &pMGADRIServer->buffers.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add DMA buffers mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] DMA buffers handle = 0x%08lx\n",
+ pMGADRIServer->buffers.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->buffers.handle,
+ pMGADRIServer->buffers.size,
+ &pMGADRIServer->buffers.map ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not map DMA buffers\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] DMA buffers mapped at 0x%08lx\n",
+ (unsigned long)pMGADRIServer->buffers.map );
+
+ count = drmAddBufs( pMga->drmFD,
+ MGA_NUM_BUFFERS, MGA_BUFFER_SIZE,
+ DRM_AGP_BUFFER, pMGADRIServer->buffers.offset );
+ if ( count <= 0 ) {
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO,
+ "[drm] failure adding %d %d byte DMA buffers\n",
+ MGA_NUM_BUFFERS, MGA_BUFFER_SIZE );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Added %d %d byte DMA buffers\n",
+ count, MGA_BUFFER_SIZE );
+
+ i = mylog2(pMGADRIServer->agpTextures.size / MGA_NR_TEX_REGIONS);
+ if(i < MGA_LOG_MIN_TEX_REGION_SIZE)
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+ pMGADRIServer->agpTextures.size = (pMGADRIServer->agpTextures.size >> i) << i;
+
+ if ( drmAddMap( pMga->drmFD,
+ pMGADRIServer->agpTextures.offset,
+ pMGADRIServer->agpTextures.size,
+ DRM_AGP, 0,
+ &pMGADRIServer->agpTextures.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[agp] Could not add agpTexture mapping\n" );
+ return FALSE;
+ }
+/* should i map it ? */
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] agpTexture handle = 0x%08lx\n",
+ pMGADRIServer->agpTextures.handle );
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[agp] agpTexture size: %d kb\n", pMGADRIServer->agpTextures.size/1024 );
+
+ return TRUE;
+}
+
+static Bool MGADRIMapInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+
+ pMGADRIServer->registers.size = MGAIOMAPSIZE;
+
+ if ( drmAddMap( pMga->drmFD,
+ (drmHandle)pMga->IOAddress,
+ pMGADRIServer->registers.size,
+ DRM_REGISTERS, DRM_READ_ONLY,
+ &pMGADRIServer->registers.handle ) < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] Could not add MMIO registers mapping\n" );
+ return FALSE;
+ }
+ xf86DrvMsg( pScreen->myNum, X_INFO,
+ "[drm] Registers handle = 0x%08lx\n",
+ pMGADRIServer->registers.handle );
+
+ pMGADRIServer->status.size = SAREA_MAX;
+
+ if ( drmAddMap( pMga->drmFD, 0, pMGADRIServer->status.size,
+ DRM_SHM, DRM_READ_ONLY | DRM_LOCKED | DRM_KERNEL,
+ &pMGADRIServer->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",
+ pMGADRIServer->status.handle );
+
+ if ( drmMap( pMga->drmFD,
+ pMGADRIServer->status.handle,
+ pMGADRIServer->status.size,
+ &pMGADRIServer->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)pMGADRIServer->status.map );
+
+ return TRUE;
+}
+
+static Bool MGADRIKernelInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ drmMGAInit init;
+ int ret;
+
+ memset( &init, 0, sizeof(drmMGAInit) );
+
+ init.func = MGA_INIT_DMA;
+ init.sarea_priv_offset = sizeof(XF86DRISAREARec);
+
+ switch ( pMga->Chipset ) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ init.chipset = MGA_CARD_TYPE_G400;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ init.chipset = MGA_CARD_TYPE_G200;
+ break;
+ default:
+ return FALSE;
+ }
+ init.sgram = !pMga->HasSDRAM;
+
+ init.maccess = pMga->MAccess;
+
+ init.fb_cpp = pScrn->bitsPerPixel / 8;
+ init.front_offset = pMGADRIServer->frontOffset;
+ init.front_pitch = pMGADRIServer->frontPitch / init.fb_cpp;
+ init.back_offset = pMGADRIServer->backOffset;
+ init.back_pitch = pMGADRIServer->backPitch / init.fb_cpp;
+
+ init.depth_cpp = pScrn->bitsPerPixel / 8;
+ init.depth_offset = pMGADRIServer->depthOffset;
+ init.depth_pitch = pMGADRIServer->depthPitch / init.depth_cpp;
+
+ init.texture_offset[0] = pMGADRIServer->textureOffset;
+ init.texture_size[0] = pMGADRIServer->textureSize;
+
+ init.fb_offset = pMGADRIServer->fb.handle;
+ init.mmio_offset = pMGADRIServer->registers.handle;
+ init.status_offset = pMGADRIServer->status.handle;
+
+ init.warp_offset = pMGADRIServer->warp.handle;
+ init.primary_offset = pMGADRIServer->primary.handle;
+ init.buffers_offset = pMGADRIServer->buffers.handle;
+
+ init.texture_offset[1] = pMGADRIServer->agpTextures.handle;
+ init.texture_size[1] = pMGADRIServer->agpTextures.size;
+
+ ret = drmCommandWrite( pMga->drmFD, DRM_MGA_INIT, &init, sizeof(drmMGAInit));
+ 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...
+ */
+ pMga->GetQuiescence( pScrn );
+#endif
+
+ return TRUE;
+}
+
+static void MGADRIIrqInit(MGAPtr pMga, ScreenPtr pScreen)
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+
+ /* version = drmGetVersion(pMga->drmFD);
+ if ( version ) {
+ if ( version->version_major != 3 ||
+ version->version_minor < 0 ) {*/
+ if (!pMga->irq) {
+ pMga->irq = drmGetInterruptFromBusID(
+ pMga->drmFD,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->busnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->devnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->funcnum);
+
+ if((drmCtlInstHandler(pMga->drmFD, pMga->irq)) != 0) {
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "[drm] failure adding irq handler, "
+ "there is a device already using that irq\n"
+ "[drm] falling back to irq-free operation\n");
+ pMga->irq = 0;
+ } else {
+ pMga->reg_ien = INREG( MGAREG_IEN );
+ }
+ }
+
+ if (pMga->irq)
+ xf86DrvMsg(pScrn->scrnIndex, X_INFO,
+ "[drm] dma control initialized, using IRQ %d\n",
+ pMga->irq);
+}
+
+static Bool MGADRIBuffersInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+
+
+ pMGADRIServer->drmBuffers = drmMapBufs( pMga->drmFD );
+ if ( !pMGADRIServer->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",
+ pMGADRIServer->drmBuffers->count );
+
+ return TRUE;
+}
+
+
+Bool MGADRIScreenInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ DRIInfoPtr pDRIInfo;
+ MGADRIPtr pMGADRI;
+ MGADRIServerPrivatePtr pMGADRIServer;
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ case PCI_CHIP_MGAG200:
+#if 0
+ case PCI_CHIP_MGAG200_PCI:
+#endif
+ break;
+ default:
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "[drm] Direct rendering only supported with G200/G400/G550 AGP\n");
+ return FALSE;
+ }
+
+ /* 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] MGADRIScreenInit failed (libdri.a too old)\n" );
+ return FALSE;
+ }
+
+ /* Check the DRI version */
+ {
+ int major, minor, patch;
+ DRIQueryVersion( &major, &minor, &patch );
+ if ( major != 4 || minor < 0 ) {
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit 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;
+ }
+ }
+
+ 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;
+ }
+ pMga->pDRIInfo = pDRIInfo;
+
+ pDRIInfo->drmDriverName = MGAKernelDriverName;
+ pDRIInfo->clientDriverName = MGAClientDriverName;
+ pDRIInfo->busIdString = xalloc(64);
+ sprintf( pDRIInfo->busIdString, "PCI:%d:%d:%d",
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->busnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->devnum,
+ ((pciConfigPtr)pMga->PciInfo->thisCard)->funcnum );
+ pDRIInfo->ddxDriverMajorVersion = MGA_MAJOR_VERSION;
+ pDRIInfo->ddxDriverMinorVersion = MGA_MINOR_VERSION;
+ pDRIInfo->ddxDriverPatchVersion = MGA_PATCHLEVEL;
+ pDRIInfo->frameBufferPhysicalAddress = pMga->FbAddress;
+ pDRIInfo->frameBufferSize = pMga->FbMapSize;
+ pDRIInfo->frameBufferStride = pScrn->displayWidth*(pScrn->bitsPerPixel/8);
+ pDRIInfo->ddxDrawableTableEntry = MGA_MAX_DRAWABLES;
+
+ pDRIInfo->wrap.BlockHandler = MGABlockHandler;
+ pDRIInfo->wrap.WakeupHandler = MGAWakeupHandler;
+ pDRIInfo->wrap.ValidateTree = NULL;
+ pDRIInfo->wrap.PostValidateTree = NULL;
+
+ pDRIInfo->createDummyCtx = TRUE;
+ pDRIInfo->createDummyCtxPriv = FALSE;
+
+ if ( SAREA_MAX_DRAWABLES < MGA_MAX_DRAWABLES ) {
+ pDRIInfo->maxDrawableTableEntry = SAREA_MAX_DRAWABLES;
+ } else {
+ pDRIInfo->maxDrawableTableEntry = MGA_MAX_DRAWABLES;
+ }
+
+ /* For now the mapping works by using a fixed size defined
+ * in the SAREA header.
+ */
+ if ( sizeof(XF86DRISAREARec) + sizeof(MGASAREAPrivRec) > 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(MGASAREAPrivRec),
+ sizeof(XF86DRISAREARec) + sizeof(MGASAREAPrivRec) );
+
+ pDRIInfo->SAREASize = SAREA_MAX;
+
+ pMGADRI = (MGADRIPtr)xcalloc( sizeof(MGADRIRec), 1 );
+ if ( !pMGADRI ) {
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Failed to allocate memory for private record\n" );
+ return FALSE;
+ }
+
+ pMGADRIServer = (MGADRIServerPrivatePtr)
+ xcalloc( sizeof(MGADRIServerPrivateRec), 1 );
+ if ( !pMGADRIServer ) {
+ xfree( pMGADRI );
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScrn->scrnIndex, X_ERROR,
+ "[drm] Failed to allocate memory for private record\n" );
+ return FALSE;
+ }
+ pMga->DRIServerInfo = pMGADRIServer;
+
+ pDRIInfo->devPrivate = pMGADRI;
+ pDRIInfo->devPrivateSize = sizeof(MGADRIRec);
+ pDRIInfo->contextSize = sizeof(MGADRIContextRec);
+
+ pDRIInfo->CreateContext = MGACreateContext;
+ pDRIInfo->DestroyContext = MGADestroyContext;
+ if ( xf86IsEntityShared( pScrn->entityList[0] ) ) {
+ pDRIInfo->SwapContext = MGADRISwapContextShared;
+ } else {
+ pDRIInfo->SwapContext = MGADRISwapContext;
+ }
+
+ switch( pScrn->bitsPerPixel ) {
+ case 8:
+ pDRIInfo->InitBuffers = Mga8DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga8DRIMoveBuffers;
+ case 16:
+ pDRIInfo->InitBuffers = Mga16DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga16DRIMoveBuffers;
+ case 24:
+ pDRIInfo->InitBuffers = Mga24DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga24DRIMoveBuffers;
+ case 32:
+ pDRIInfo->InitBuffers = Mga32DRIInitBuffers;
+ pDRIInfo->MoveBuffers = Mga32DRIMoveBuffers;
+ }
+
+ pDRIInfo->bufferRequests = DRI_ALL_WINDOWS;
+
+ if ( !DRIScreenInit( pScreen, pDRIInfo, &pMga->drmFD ) ) {
+ xfree( pMGADRIServer );
+ pMga->DRIServerInfo = 0;
+ xfree( pDRIInfo->devPrivate );
+ pDRIInfo->devPrivate = 0;
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[drm] DRIScreenInit failed. Disabling DRI.\n" );
+ return FALSE;
+ }
+
+ /* Check the DRM versioning */
+ {
+ drmVersionPtr version;
+
+ /* Check the DRM lib version.
+ drmGetLibVersion was not supported in version 1.0, so check for
+ symbol first to avoid possible crash or hang.
+ */
+ if (xf86LoaderCheckSymbol("drmGetLibVersion")) {
+ version = drmGetLibVersion(pMga->drmFD);
+ }
+ else {
+ /* drmlib version 1.0.0 didn't have the drmGetLibVersion
+ entry point. Fake it by allocating a version record
+ via drmGetVersion and changing it to version 1.0.0
+ */
+ version = drmGetVersion(pMga->drmFD);
+ version->version_major = 1;
+ version->version_minor = 0;
+ version->version_patchlevel = 0;
+ }
+
+ if (version) {
+ if (version->version_major != 1 ||
+ version->version_minor < 1) {
+ /* incompatible drm library version */
+ xf86DrvMsg(pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed because of a version mismatch.\n"
+ "[dri] libdrm.a module version is %d.%d.%d but version 1.1.x is needed.\n"
+ "[dri] Disabling DRI.\n",
+ version->version_major,
+ version->version_minor,
+ version->version_patchlevel);
+ drmFreeVersion(version);
+ MGADRICloseScreen( pScreen ); /* FIXME: ??? */
+ return FALSE;
+ }
+ drmFreeVersion(version);
+ }
+
+ /* Check the MGA DRM version */
+ version = drmGetVersion(pMga->drmFD);
+ if ( version ) {
+ if ( version->version_major != 3 ||
+ version->version_minor < 0 ) {
+ /* incompatible drm version */
+ xf86DrvMsg( pScreen->myNum, X_ERROR,
+ "[dri] MGADRIScreenInit failed because of a version mismatch.\n"
+ "[dri] mga.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 );
+ MGADRICloseScreen( pScreen ); /* FIXME: ??? */
+ return FALSE;
+ }
+ drmFreeVersion( version );
+ }
+ }
+
+#if 0
+ /* Calculate texture constants for AGP texture space.
+ * FIXME: move!
+ */
+ {
+ CARD32 agpTextureOffset = MGA_DMA_BUF_SZ * MGA_DMA_BUF_NR;
+ CARD32 agpTextureSize = pMGADRI->agp.size - agpTextureOffset;
+
+ i = mylog2(agpTextureSize / MGA_NR_TEX_REGIONS);
+ if (i < MGA_LOG_MIN_TEX_REGION_SIZE)
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logAgpTextureGranularity = i;
+ pMGADRI->agpTextureSize = (agpTextureSize >> i) << i;
+ pMGADRI->agpTextureOffset = agpTextureOffset;
+ }
+#endif
+
+ if ( !MGADRIAgpInit( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIMapInit( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+ {
+ void *scratch_ptr;
+ int scratch_int;
+
+ DRIGetDeviceInfo(pScreen, &pMGADRIServer->fb.handle,
+ &scratch_int, &scratch_int,
+ &scratch_int, &scratch_int,
+ &scratch_ptr);
+ }
+
+ if ( !MGAInitVisualConfigs( pScreen ) ) {
+ DRICloseScreen( pScreen );
+ return FALSE;
+ }
+ xf86DrvMsg( pScrn->scrnIndex, X_INFO, "[dri] visual configs initialized\n" );
+
+ return TRUE;
+}
+
+
+Bool MGADRIFinishScreenInit( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ MGADRIPtr pMGADRI = (MGADRIPtr)pMga->pDRIInfo->devPrivate;
+ int i;
+
+ if ( !pMga->pDRIInfo )
+ return FALSE;
+
+ pMga->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 ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIKernelInit( pScreen ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ if ( !MGADRIBuffersInit( pScreen ) ) {
+ MGADRICloseScreen( pScreen );
+ return FALSE;
+ }
+
+ MGADRIIrqInit(pMga, pScreen);
+
+ switch(pMga->Chipset) {
+ case PCI_CHIP_MGAG550:
+ case PCI_CHIP_MGAG400:
+ pMGADRI->chipset = MGA_CARD_TYPE_G400;
+ break;
+ case PCI_CHIP_MGAG200:
+ case PCI_CHIP_MGAG200_PCI:
+ pMGADRI->chipset = MGA_CARD_TYPE_G200;
+ break;
+ default:
+ return FALSE;
+ }
+ pMGADRI->width = pScrn->virtualX;
+ pMGADRI->height = pScrn->virtualY;
+ pMGADRI->mem = pScrn->videoRam * 1024;
+ pMGADRI->cpp = pScrn->bitsPerPixel / 8;
+
+ pMGADRI->agpMode = pMga->agpMode;
+
+ pMGADRI->frontOffset = pMGADRIServer->frontOffset;
+ pMGADRI->frontPitch = pMGADRIServer->frontPitch;
+ pMGADRI->backOffset = pMGADRIServer->backOffset;
+ pMGADRI->backPitch = pMGADRIServer->backPitch;
+ pMGADRI->depthOffset = pMGADRIServer->depthOffset;
+ pMGADRI->depthPitch = pMGADRIServer->depthPitch;
+ pMGADRI->textureOffset = pMGADRIServer->textureOffset;
+ pMGADRI->textureSize = pMGADRIServer->textureSize;
+
+ i = mylog2( pMGADRI->textureSize / MGA_NR_TEX_REGIONS );
+ if ( i < MGA_LOG_MIN_TEX_REGION_SIZE )
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logTextureGranularity = i;
+ pMGADRI->textureSize = (pMGADRI->textureSize >> i) << i; /* truncate */
+
+ i = mylog2( pMGADRIServer->agpTextures.size / MGA_NR_TEX_REGIONS );
+ if ( i < MGA_LOG_MIN_TEX_REGION_SIZE )
+ i = MGA_LOG_MIN_TEX_REGION_SIZE;
+
+ pMGADRI->logAgpTextureGranularity = i;
+ pMGADRI->agpTextureOffset = (unsigned int)pMGADRIServer->agpTextures.handle;
+ pMGADRI->agpTextureSize = (unsigned int)pMGADRIServer->agpTextures.size;
+
+ pMGADRI->registers.handle = pMGADRIServer->registers.handle;
+ pMGADRI->registers.size = pMGADRIServer->registers.size;
+ pMGADRI->status.handle = pMGADRIServer->status.handle;
+ pMGADRI->status.size = pMGADRIServer->status.size;
+ pMGADRI->primary.handle = pMGADRIServer->primary.handle;
+ pMGADRI->primary.size = pMGADRIServer->primary.size;
+ pMGADRI->buffers.handle = pMGADRIServer->buffers.handle;
+ pMGADRI->buffers.size = pMGADRIServer->buffers.size;
+ pMGADRI->sarea_priv_offset = sizeof(XF86DRISAREARec);
+ return TRUE;
+}
+
+
+void MGADRICloseScreen( ScreenPtr pScreen )
+{
+ ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+ MGAPtr pMga = MGAPTR(pScrn);
+ MGADRIServerPrivatePtr pMGADRIServer = pMga->DRIServerInfo;
+ drmMGAInit init;
+
+ if ( pMGADRIServer->drmBuffers ) {
+ drmUnmapBufs( pMGADRIServer->drmBuffers );
+ pMGADRIServer->drmBuffers = NULL;
+ }
+
+ if (pMga->irq) {
+ drmCtlUninstHandler(pMga->drmFD);
+ pMga->irq = 0;
+ }
+
+ /* Cleanup DMA */
+ memset( &init, 0, sizeof(drmMGAInit) );
+ init.func = MGA_CLEANUP_DMA;
+ drmCommandWrite( pMga->drmFD, DRM_MGA_INIT, &init, sizeof(drmMGAInit) );
+
+ if ( pMGADRIServer->status.map ) {
+ drmUnmap( pMGADRIServer->status.map, pMGADRIServer->status.size );
+ pMGADRIServer->status.map = NULL;
+ }
+ if ( pMGADRIServer->buffers.map ) {
+ drmUnmap( pMGADRIServer->buffers.map, pMGADRIServer->buffers.size );
+ pMGADRIServer->buffers.map = NULL;
+ }
+ if ( pMGADRIServer->primary.map ) {
+ drmUnmap( pMGADRIServer->primary.map, pMGADRIServer->primary.size );
+ pMGADRIServer->primary.map = NULL;
+ }
+ if ( pMGADRIServer->warp.map ) {
+ drmUnmap( pMGADRIServer->warp.map, pMGADRIServer->warp.size );
+ pMGADRIServer->warp.map = NULL;
+ }
+
+ if ( pMGADRIServer->agpTextures.map ) {
+ drmUnmap( pMGADRIServer->agpTextures.map, pMGADRIServer->agpTextures.size );
+ pMGADRIServer->agpTextures.map = NULL;
+ }
+
+ if ( pMGADRIServer->agp.handle ) {
+ drmAgpUnbind( pMga->drmFD, pMGADRIServer->agp.handle );
+ drmAgpFree( pMga->drmFD, pMGADRIServer->agp.handle );
+ pMGADRIServer->agp.handle = 0;
+ drmAgpRelease( pMga->drmFD );
+ }
+
+ DRICloseScreen( pScreen );
+
+ if ( pMga->pDRIInfo ) {
+ if ( pMga->pDRIInfo->devPrivate ) {
+ xfree( pMga->pDRIInfo->devPrivate );
+ pMga->pDRIInfo->devPrivate = 0;
+ }
+ DRIDestroyInfoRec( pMga->pDRIInfo );
+ pMga->pDRIInfo = 0;
+ }
+ if ( pMga->DRIServerInfo ) {
+ xfree( pMga->DRIServerInfo );
+ pMga->DRIServerInfo = 0;
+ }
+ if ( pMga->pVisualConfigs ) {
+ xfree( pMga->pVisualConfigs );
+ }
+ if ( pMga->pVisualConfigsPriv ) {
+ xfree( pMga->pVisualConfigsPriv );
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 21:09:02 +0000