From 263581bba4d61291c54313648063a30c47106f0b Mon Sep 17 00:00:00 2001 From: Felix Kuehling Date: Sun, 22 Feb 2004 16:11:12 +0000 Subject: Imported the Savage DRI driver from the savage-2-0-0-branch of DRI CVS with modifications to make it work with current Mesa 6. --- src/mesa/drivers/dri/savage/savage_xmesa.c | 800 +++++++++++++++++++++++++++++ 1 file changed, 800 insertions(+) create mode 100644 src/mesa/drivers/dri/savage/savage_xmesa.c (limited to 'src/mesa/drivers/dri/savage/savage_xmesa.c') diff --git a/src/mesa/drivers/dri/savage/savage_xmesa.c b/src/mesa/drivers/dri/savage/savage_xmesa.c new file mode 100644 index 0000000000..bc15e0bd30 --- /dev/null +++ b/src/mesa/drivers/dri/savage/savage_xmesa.c @@ -0,0 +1,800 @@ +/* + * 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 GLX_DIRECT_RENDERING + +#include +#include + +#include "savagecontext.h" +#include "context.h" +#include "matrix.h" + +#include "simple_list.h" + +#include "swrast/swrast.h" +#include "swrast_setup/swrast_setup.h" +#include "tnl/tnl.h" +#include "array_cache/acache.h" + +#include "tnl/t_pipeline.h" + +#include "drivers/common/driverfuncs.h" + +#include "savagedd.h" +#include "savagestate.h" +#include "savagetex.h" +#include "savagespan.h" +#include "savagetris.h" +#include "savagevb.h" +#include "savageioctl.h" +#include "savage_bci.h" + +#include "savage_dri.h" + +#include "savagedma.h" + +#ifndef SAVAGE_DEBUG +int SAVAGE_DEBUG = (0 +/* | DEBUG_ALWAYS_SYNC */ +/* | DEBUG_VERBOSE_RING */ +/* | DEBUG_VERBOSE_OUTREG */ +/* | DEBUG_VERBOSE_MSG */ +/* | DEBUG_NO_OUTRING */ +/* | DEBUG_NO_OUTREG */ +/* | DEBUG_VERBOSE_API */ +/* | DEBUG_VERBOSE_2D */ +/* | DEBUG_VERBOSE_DRI */ +/* | DEBUG_VALIDATE_RING */ +/* | DEBUG_VERBOSE_IOCTL */ + ); +#endif + + +/*For time caculating test*/ +#if defined(DEBUG_TIME) && DEBUG_TIME +struct timeval tv_s,tv_f; +unsigned long time_sum=0; +struct timeval tv_s1,tv_f1; +#endif + +/* this is first function called in dirver*/ + +static GLboolean +savageInitDriver(__DRIscreenPrivate *sPriv) +{ + savageScreenPrivate *savageScreen; + SAVAGEDRIPtr gDRIPriv = (SAVAGEDRIPtr)sPriv->pDevPriv; + + + /* Check the DRI version */ + { + int major, minor, patch; + if (XF86DRIQueryVersion(sPriv->display, &major, &minor, &patch)) { + if (major != 4 || minor < 0) { + __driUtilMessage("savage DRI driver expected DRI version 4.0.x but got version %d.%d.%d", major, minor, patch); + return GL_FALSE; + } + } + } + + /* Check that the DDX driver version is compatible */ + if (sPriv->ddxMajor != 1 || + sPriv->ddxMinor < 0) { + __driUtilMessage("savage DRI driver expected DDX driver version 1.0.x but got version %d.%d.%d", sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch); + return GL_FALSE; + } + + /* Check that the DRM driver version is compatible */ + if (sPriv->drmMajor != 1 || + sPriv->drmMinor < 0) { + __driUtilMessage("savage DRI driver expected DRM driver version 1.1.x but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch); + return GL_FALSE; + } + + /* Allocate the private area */ + savageScreen = (savageScreenPrivate *)Xmalloc(sizeof(savageScreenPrivate)); + if (!savageScreen) + return GL_FALSE; + + savageScreen->driScrnPriv = sPriv; + sPriv->private = (void *)savageScreen; + + savageScreen->chipset=gDRIPriv->chipset; + savageScreen->width=gDRIPriv->width; + savageScreen->height=gDRIPriv->height; + savageScreen->mem=gDRIPriv->mem; + savageScreen->cpp=gDRIPriv->cpp; + savageScreen->zpp=gDRIPriv->zpp; + savageScreen->frontPitch=gDRIPriv->frontPitch; + savageScreen->frontOffset=gDRIPriv->frontOffset; + savageScreen->frontBitmapDesc = gDRIPriv->frontBitmapDesc; + + if (gDRIPriv->cpp == 4) + savageScreen->frontFormat = DV_PF_8888; + else + savageScreen->frontFormat = DV_PF_565; + + savageScreen->backOffset = gDRIPriv->backOffset; + savageScreen->backBitmapDesc = gDRIPriv->backBitmapDesc; + savageScreen->depthOffset=gDRIPriv->depthOffset; + savageScreen->depthBitmapDesc = gDRIPriv->depthBitmapDesc; +#if 0 + savageScreen->backPitch = gDRIPriv->auxPitch; + savageScreen->backPitchBits = gDRIPriv->auxPitchBits; +#endif + savageScreen->textureOffset[SAVAGE_CARD_HEAP] = + gDRIPriv->textureOffset; + savageScreen->textureSize[SAVAGE_CARD_HEAP] = + gDRIPriv->textureSize; + savageScreen->logTextureGranularity[SAVAGE_CARD_HEAP] = + gDRIPriv->logTextureGranularity; + + savageScreen->textureOffset[SAVAGE_AGP_HEAP] = + gDRIPriv->agpTextures.handle; + savageScreen->textureSize[SAVAGE_AGP_HEAP] = + gDRIPriv->agpTextures.size; + savageScreen->logTextureGranularity[SAVAGE_AGP_HEAP] = + gDRIPriv->logAgpTextureGranularity; + + savageScreen->back.handle = gDRIPriv->backbuffer; + savageScreen->back.size = gDRIPriv->backbufferSize; + savageScreen->back.map = + (drmAddress)(((unsigned int)sPriv->pFB)+gDRIPriv->backOffset); + + savageScreen->depth.handle = gDRIPriv->depthbuffer; + savageScreen->depth.size = gDRIPriv->depthbufferSize; + + savageScreen->depth.map = + (drmAddress)(((unsigned int)sPriv->pFB)+gDRIPriv->depthOffset); + + savageScreen->sarea_priv_offset = gDRIPriv->sarea_priv_offset; + + savageScreen->texVirtual[SAVAGE_CARD_HEAP] = + (drmAddress)(((unsigned int)sPriv->pFB)+gDRIPriv->textureOffset); +#if 0 + savageDDFastPathInit(); + savageDDTrifuncInit(); + savageDDSetupInit(); +#endif + return GL_TRUE; +} + +/* Accessed by dlsym from dri_mesa_init.c + */ +static void +savageDestroyScreen(__DRIscreenPrivate *sPriv) +{ + savageScreenPrivate *savageScreen = (savageScreenPrivate *)sPriv->private; + + + Xfree(savageScreen); + sPriv->private = NULL; +} + +#if 0 +GLvisual *XMesaCreateVisual(Display *dpy, + __DRIscreenPrivate *driScrnPriv, + const XVisualInfo *visinfo, + const __GLXvisualConfig *config) +{ + /* Drivers may change the args to _mesa_create_visual() in order to + * setup special visuals. + */ + return _mesa_create_visual( config->rgba, + config->doubleBuffer, + config->stereo, + _mesa_bitcount(visinfo->red_mask), + _mesa_bitcount(visinfo->green_mask), + _mesa_bitcount(visinfo->blue_mask), + config->alphaSize, + 0, /* index bits */ + config->depthSize, + config->stencilSize, + config->accumRedSize, + config->accumGreenSize, + config->accumBlueSize, + config->accumAlphaSize, + 0 /* num samples */ ); +} +#endif + + +static GLboolean +savageCreateContext( const __GLcontextModes *mesaVis, + __DRIcontextPrivate *driContextPriv, + void *sharedContextPrivate ) +{ + GLcontext *ctx, *shareCtx; + savageContextPtr imesa; + __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv; + struct dd_function_table functions; + SAVAGEDRIPtr gDRIPriv = (SAVAGEDRIPtr)sPriv->pDevPriv; + savageScreenPrivate *savageScreen = (savageScreenPrivate *)sPriv->private; + drm_savage_sarea_t *saPriv=(drm_savage_sarea_t *)(((char*)sPriv->pSAREA)+ + savageScreen->sarea_priv_offset); + int i; + imesa = (savageContextPtr)Xcalloc(sizeof(savageContext), 1); + if (!imesa) { + return GL_FALSE; + } + + /* Init default driver functions then plug in savage-specific texture + * functions that are needed as early as during context creation. */ + _mesa_init_driver_functions( &functions ); + savageDDInitTextureFuncs( &functions ); + + /* Allocate the Mesa context */ + if (sharedContextPrivate) + shareCtx = ((savageContextPtr) sharedContextPrivate)->glCtx; + else + shareCtx = NULL; + ctx = _mesa_create_context(mesaVis, shareCtx, &functions, imesa); + if (!ctx) { + Xfree(imesa); + return GL_FALSE; + } + driContextPriv->driverPrivate = imesa; + + /* BEGIN;*/ + /* Set the maximum texture size small enough that we can guarentee + * that both texture units can bind a maximal texture and have them + * in memory at once. + */ + if (savageScreen->textureSize[SAVAGE_CARD_HEAP] < 2*1024*1024) { + ctx->Const.MaxTextureLevels = 9; + } else if (savageScreen->textureSize[SAVAGE_CARD_HEAP] < 8*1024*1024) { + ctx->Const.MaxTextureLevels = 10; + } else { + ctx->Const.MaxTextureLevels = 11; + } + if (savageScreen->chipset >= S3_SAVAGE4) + ctx->Const.MaxTextureUnits = 2; + else + ctx->Const.MaxTextureUnits = 1; + +#if 0 + ctx->Const.MinLineWidth = 1.0; + ctx->Const.MinLineWidthAA = 1.0; + ctx->Const.MaxLineWidth = 3.0; + ctx->Const.MaxLineWidthAA = 3.0; + ctx->Const.LineWidthGranularity = 1.0; +#endif + + /* Dri stuff + */ + imesa->hHWContext = driContextPriv->hHWContext; + imesa->driFd = sPriv->fd; + imesa->driHwLock = &sPriv->pSAREA->lock; + + imesa->savageScreen = savageScreen; + imesa->driScreen = sPriv; + imesa->sarea = saPriv; + imesa->glBuffer = NULL; + + /* DMA buffer */ + + /*The shadow pointer*/ + imesa->shadowPointer = + (volatile GLuint *)((((GLuint)(&saPriv->shadow_status)) + 31) & 0xffffffe0L) ; + /* here we use eventTag1 because eventTag0 is used by HWXvMC*/ + imesa->eventTag1 = (volatile GLuint *)(imesa->shadowPointer + 6); + /* imesa->eventTag1=(volatile GLuint *)(imesa->MMIO_BASE+0x48c04);*/ + imesa->shadowCounter = MAX_SHADOWCOUNTER; + imesa->shadowStatus = GL_TRUE;/*Will judge by 2d message */ + + if (drmMap(sPriv->fd, + gDRIPriv->registers.handle, + gDRIPriv->registers.size, + (drmAddress *)&(gDRIPriv->registers.map)) != 0) + { + Xfree(savageScreen); + sPriv->private = NULL; + return GL_FALSE; + } + + if (drmMap(sPriv->fd, + gDRIPriv->agpTextures.handle, + gDRIPriv->agpTextures.size, + (drmAddress *)&(gDRIPriv->agpTextures.map)) != 0) + { + Xfree(savageScreen); + sPriv->private = NULL; + return GL_FALSE; + } + +/* agp texture*/ + savageScreen->texVirtual[SAVAGE_AGP_HEAP] = + (drmAddress)(gDRIPriv->agpTextures.map); + + + + gDRIPriv->BCIcmdBuf.map = (drmAddress *) + ((unsigned int)gDRIPriv->registers.map+0x00010000); + + imesa->MMIO_BASE = (GLuint)gDRIPriv->registers.map; + imesa->BCIBase= (GLuint)gDRIPriv->BCIcmdBuf.map; + + savageScreen->aperture.handle = gDRIPriv->aperture.handle; + savageScreen->aperture.size = gDRIPriv->aperture.size; + if (drmMap(sPriv->fd, + savageScreen->aperture.handle, + savageScreen->aperture.size, + (drmAddress *)&savageScreen->aperture.map) != 0) + { + Xfree(savageScreen); + sPriv->private = NULL; + return GL_FALSE; + } + + + + + + for(i=0;i<5;i++) + { + imesa->apertureBase[i] = ((GLuint)savageScreen->aperture.map + + 0x01000000 * i ); + + + } + + { + volatile unsigned int * tmp; + + tmp=(volatile unsigned int *)(imesa->MMIO_BASE + 0x850C); + + + tmp=(volatile unsigned int *)(imesa->MMIO_BASE + 0x48C40); + + + tmp=(volatile unsigned int *)(imesa->MMIO_BASE + 0x48C44); + + + tmp=(volatile unsigned int *)(imesa->MMIO_BASE + 0x48C48); + + + + } + + imesa->aperturePitch = gDRIPriv->aperturePitch; + + + /* change texHeap initialize to support two kind of texture heap*/ + /* here is some parts of initialization, others in InitDriver() */ + + imesa->lastTexHeap = savageScreen->texVirtual[SAVAGE_AGP_HEAP] ? 2 : 1; + + /*allocate texHeap for multi-tex*/ + { + int i; + + for(i=0;itexHeap[i] = mmInit( 0, savageScreen->textureSize[i] ); + make_empty_list(&imesa->TexObjList[i]); + } + + make_empty_list(&imesa->SwappedOut); + } + + imesa->hw_stencil = GL_FALSE; +#if HW_STENCIL + imesa->hw_stencil = mesaVis->stencilBits && mesaVis->depthBits == 24; +#endif + imesa->depth_scale = (imesa->savageScreen->zpp == 2) ? + (1.0F/0x10000):(1.0F/0x1000000); + + /* Utah stuff + */ + imesa->new_state = ~0; + imesa->RenderIndex = ~0; + imesa->dirty = ~0; + imesa->vertex_format = 0; + imesa->TextureMode = ctx->Texture.Unit[0].EnvMode; + imesa->CurrentTexObj[0] = 0; + imesa->CurrentTexObj[1] = 0; + imesa->texAge[SAVAGE_CARD_HEAP]=0; + imesa->texAge[SAVAGE_AGP_HEAP]=0; + + /* Initialize the software rasterizer and helper modules. + */ + _swrast_CreateContext( ctx ); + _ac_CreateContext( ctx ); + _tnl_CreateContext( ctx ); + + _swsetup_CreateContext( ctx ); + + /* Install the customized pipeline: + */ +#if 0 + _tnl_destroy_pipeline( ctx ); + _tnl_install_pipeline( ctx, savage_pipeline ); +#endif + + /* Configure swrast to match hardware characteristics: + */ + _swrast_allow_pixel_fog( ctx, GL_FALSE ); + _swrast_allow_vertex_fog( ctx, GL_TRUE ); + + ctx->DriverCtx = (void *) imesa; + imesa->glCtx = ctx; + if (savageDMAInit(imesa) == GL_FALSE) + return GL_FALSE; + + savageDDExtensionsInit( ctx ); + + savageDDInitStateFuncs( ctx ); + savageDDInitSpanFuncs( ctx ); + savageDDInitDriverFuncs( ctx ); + savageDDInitIoctlFuncs( ctx ); + savageInitTriFuncs( ctx ); + + savageInitVB( ctx ); + savageDDInitState( imesa ); + + driContextPriv->driverPrivate = (void *) imesa; + + return GL_TRUE; +} + +static void +savageDestroyContext(__DRIcontextPrivate *driContextPriv) +{ + savageContextPtr imesa = (savageContextPtr) driContextPriv->driverPrivate; + + assert (imesa); /* should never be NULL */ + if (imesa) { + savageTextureObjectPtr next_t, t; + + /* update for multi-tex*/ + { + int i; + for(i=0;iTexObjList[i])) + savageDestroyTexObj(imesa, t); + } + foreach_s (t, next_t, &(imesa->SwappedOut)) + savageDestroyTexObj(imesa, t); + /*free the dma buffer*/ + savageDMAClose(imesa); + _swsetup_DestroyContext(imesa->glCtx ); + _tnl_DestroyContext( imesa->glCtx ); + _ac_DestroyContext( imesa->glCtx ); + _swrast_DestroyContext( imesa->glCtx ); + + savageFreeVB( imesa->glCtx ); + + /* free the Mesa context */ + imesa->glCtx->DriverCtx = NULL; + _mesa_destroy_context(imesa->glCtx); + + /* no longer use vertex_dma_buf*/ + Xfree(imesa); + } +} + +static GLboolean +savageCreateBuffer( __DRIscreenPrivate *driScrnPriv, + __DRIdrawablePrivate *driDrawPriv, + const __GLcontextModes *mesaVis, + GLboolean isPixmap) +{ + if (isPixmap) { + return GL_FALSE; /* not implemented */ + } + else { +#if HW_STENCIL + GLboolean swStencil = mesaVis->stencilBits > 0 && mesaVis->depthBits != 24; +#else + GLboolean swStencil = mesaVis->stencilBits > 0; +#endif + driDrawPriv->driverPrivate = (void *) + _mesa_create_framebuffer(mesaVis, + GL_FALSE, /* software depth buffer? */ + swStencil, + mesaVis->accumRedBits > 0, + mesaVis->alphaBits > 0 ); + + return (driDrawPriv->driverPrivate != NULL); + } +} + +static void +savageDestroyBuffer(__DRIdrawablePrivate *driDrawPriv) +{ + _mesa_destroy_framebuffer((GLframebuffer *) (driDrawPriv->driverPrivate)); +} + +#if 0 +void XMesaSwapBuffers(__DRIdrawablePrivate *driDrawPriv) +{ + /* XXX should do swap according to the buffer, not the context! */ + savageContextPtr imesa = savageCtx; + + FLUSH_VB( imesa->glCtx, "swap buffers" ); + savageSwapBuffers(imesa); +} +#endif + +void savageXMesaSetFrontClipRects( savageContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->dirty |= SAVAGE_UPLOAD_CLIPRECTS; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; + + savageEmitDrawingRectangle( imesa ); +} + + +void savageXMesaSetBackClipRects( savageContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + if (dPriv->numBackClipRects == 0) + { + + + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; + } else { + + + imesa->numClipRects = dPriv->numBackClipRects; + imesa->pClipRects = dPriv->pBackClipRects; + imesa->drawX = dPriv->backX; + imesa->drawY = dPriv->backY; + } + + savageEmitDrawingRectangle( imesa ); + imesa->dirty |= SAVAGE_UPLOAD_CLIPRECTS; + + +} + + +static void savageXMesaWindowMoved( savageContextPtr imesa ) +{ + if (0) + fprintf(stderr, "savageXMesaWindowMoved\n\n"); + + switch (imesa->glCtx->Color._DrawDestMask) { + case FRONT_LEFT_BIT: + savageXMesaSetFrontClipRects( imesa ); + break; + case BACK_LEFT_BIT: + savageXMesaSetBackClipRects( imesa ); + break; + default: + break; + } +} + + +static GLboolean +savageUnbindContext(__DRIcontextPrivate *driContextPriv) +{ + savageContextPtr savage = (savageContextPtr) driContextPriv->driverPrivate; + if (savage) + savage->dirty = ~0; + + return GL_TRUE; +} + +static GLboolean +savageOpenFullScreen(__DRIcontextPrivate *driContextPriv) +{ + + + + if (driContextPriv) { + savageContextPtr imesa = (savageContextPtr) driContextPriv->driverPrivate; + imesa->IsFullScreen = GL_TRUE; + imesa->backup_frontOffset = imesa->savageScreen->frontOffset; + imesa->backup_backOffset = imesa->savageScreen->backOffset; + imesa->backup_frontBitmapDesc = imesa->savageScreen->frontBitmapDesc; + imesa->savageScreen->frontBitmapDesc = imesa->savageScreen->backBitmapDesc; + imesa->toggle = TARGET_BACK; + } + + return GL_TRUE; +} + +static GLboolean +savageCloseFullScreen(__DRIcontextPrivate *driContextPriv) +{ + + if (driContextPriv) { + savageContextPtr imesa = (savageContextPtr) driContextPriv->driverPrivate; + WAIT_IDLE_EMPTY; + imesa->IsFullScreen = GL_FALSE; + imesa->savageScreen->frontOffset = imesa->backup_frontOffset; + imesa->savageScreen->backOffset = imesa->backup_backOffset; + imesa->savageScreen->frontBitmapDesc = imesa->backup_frontBitmapDesc; + } + return GL_TRUE; +} + + +static GLboolean +savageMakeCurrent(__DRIcontextPrivate *driContextPriv, + __DRIdrawablePrivate *driDrawPriv, + __DRIdrawablePrivate *driReadPriv) +{ + if (driContextPriv) { + savageContextPtr imesa = (savageContextPtr) driContextPriv->driverPrivate; + + imesa->driReadable = driReadPriv; + imesa->driDrawable = driDrawPriv; + imesa->mesa_drawable = driDrawPriv; + imesa->dirty = ~0; + + _mesa_make_current2(imesa->glCtx, + (GLframebuffer *) driDrawPriv->driverPrivate, + (GLframebuffer *) driReadPriv->driverPrivate); + + savageXMesaWindowMoved( imesa ); + + if (!imesa->glCtx->Viewport.Width) + _mesa_set_viewport(imesa->glCtx, 0, 0, + driDrawPriv->w, driDrawPriv->h); + } + else + { + _mesa_make_current(NULL, NULL); + } + return GL_TRUE; +} + + +void savageGetLock( savageContextPtr imesa, GLuint flags ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + __DRIscreenPrivate *sPriv = imesa->driScreen; + drm_savage_sarea_t *sarea = imesa->sarea; + int me = imesa->hHWContext; + int stamp = dPriv->lastStamp; + int heap; + + + + /* We know there has been contention. + */ + drmGetLock(imesa->driFd, imesa->hHWContext, flags); + + + /* Note contention for throttling hint + */ + imesa->any_contend = 1; + + /* If the window moved, may need to set a new cliprect now. + * + * NOTE: This releases and regains the hw lock, so all state + * checking must be done *after* this call: + */ + DRI_VALIDATE_DRAWABLE_INFO(sPriv, dPriv); + + + + + /* If we lost context, need to dump all registers to hardware. + * Note that we don't care about 2d contexts, even if they perform + * accelerated commands, so the DRI locking in the X server is even + * more broken than usual. + */ + if (sarea->ctxOwner != me) { + imesa->dirty |= (SAVAGE_UPLOAD_CTX | + SAVAGE_UPLOAD_CLIPRECTS | + SAVAGE_UPLOAD_TEX0 | + SAVAGE_UPLOAD_TEX1); + imesa->Registers.changed.uiRegistersChanged = __HW_ALL_CHANGED; + sarea->ctxOwner = me; + } + + /* Shared texture managment - if another client has played with + * texture space, figure out which if any of our textures have been + * ejected, and update our global LRU. + */ + /*frank just for compiling,texAge,texList,AGP*/ + + for(heap= 0 ;heap < imesa->lastTexHeap ; heap++) + { + if (sarea->texAge[heap] != imesa->texAge[heap]) { + int sz = 1 << (imesa->savageScreen->logTextureGranularity[heap]); + int idx, nr = 0; + + /* Have to go right round from the back to ensure stuff ends up + * LRU in our local list... + */ + for (idx = sarea->texList[heap][SAVAGE_NR_TEX_REGIONS].prev ; + idx != SAVAGE_NR_TEX_REGIONS && nr < SAVAGE_NR_TEX_REGIONS ; + idx = sarea->texList[heap][idx].prev, nr++) + { + if (sarea->texList[heap][idx].age > imesa->texAge[heap]) + { + savageTexturesGone(imesa, heap ,idx * sz, sz, + sarea->texList[heap][idx].in_use); + } + } + + if (nr == SAVAGE_NR_TEX_REGIONS) + { + savageTexturesGone(imesa, heap, 0, + imesa->savageScreen->textureSize[heap], 0); + savageResetGlobalLRU( imesa , heap ); + } + + imesa->dirty |= SAVAGE_UPLOAD_TEX0IMAGE; + imesa->dirty |= SAVAGE_UPLOAD_TEX1IMAGE; + imesa->texAge[heap] = sarea->texAge[heap]; + } + } /* end of for loop */ + + if (dPriv->lastStamp != stamp) + savageXMesaWindowMoved( imesa ); + + + +} + + + +static const struct __DriverAPIRec savageAPI = { + savageInitDriver, + savageDestroyScreen, + savageCreateContext, + savageDestroyContext, + savageCreateBuffer, + savageDestroyBuffer, + savageSwapBuffers, + savageMakeCurrent, + savageUnbindContext, + savageOpenFullScreen, + savageCloseFullScreen +}; + + + +/* + * This is the bootstrap function for the driver. + * The __driCreateScreen name is the symbol that libGL.so fetches. + * Return: pointer to a __DRIscreenPrivate. + */ +void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, + int numConfigs, __GLXvisualConfig *config) +{ + __DRIscreenPrivate *psp; + psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &savageAPI); + return (void *) psp; +} + + +#endif -- cgit v1.2.3