diff options
Diffstat (limited to 'src/i830_dri.c')
| -rw-r--r-- | src/i830_dri.c | 1664 |
1 files changed, 1664 insertions, 0 deletions
diff --git a/src/i830_dri.c b/src/i830_dri.c new file mode 100644 index 00000000..197a8252 --- /dev/null +++ b/src/i830_dri.c @@ -0,0 +1,1664 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/i810/i830_dri.c,v 1.12 2003/02/08 21:26:57 dawes Exp $ */ +/************************************************************************** + +Copyright 2001 VA Linux Systems Inc., Fremont, California. +Copyright © 2002 by David Dawes + +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 +on 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 +ATI, VA LINUX SYSTEMS AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Reformatted with GNU indent (2.2.8), using the following options: + * + * -bad -bap -c41 -cd0 -ncdb -ci6 -cli0 -cp0 -ncs -d0 -di3 -i3 -ip3 -l78 + * -lp -npcs -psl -sob -ss -br -ce -sc -hnl + * + * This provides a good match with the original i810 code and preferred + * XFree86 formatting conventions. + * + * When editing this driver, please follow the existing formatting, and edit + * with <TAB> characters expanded at 8-column intervals. + */ + +/* + * Authors: Jeff Hartmann <jhartmann@valinux.com> + * David Dawes <dawes@tungstengraphics.com> + * Keith Whitwell <keith@tungstengraphics.com> + */ + +/* + * This driver does AGP memory allocation a little differently from most + * others. The 2D and 3D allocations have been unified (see i830_memory.c). + * The driver does the AGP allocations and binding directly, then passes + * on the mappings to the DRM module. The DRM's AGP interfaces are not used. + * The main difference with this is that the offsets need to include + * the AGP aperture base address because that won't be known or added on + * by the DRM module. + * + * DHD 07/2002 + */ + +#include "xf86.h" +#include "xf86_OSproc.h" +#include "xf86_ansic.h" +#include "xf86Priv.h" + +#include "xf86PciInfo.h" +#include "xf86Pci.h" + +#include "windowstr.h" +#include "shadow.h" + +#include "GL/glxtokens.h" + +#include "i830.h" +#include "i830_dri.h" +#include "i830_3d_reg.h" + +static char I830KernelDriverName[] = "i830"; +static char I830ClientDriverName[] = "i830"; + +static Bool I830InitVisualConfigs(ScreenPtr pScreen); +static Bool I830CreateContext(ScreenPtr pScreen, VisualPtr visual, + drmContext hwContext, void *pVisualConfigPriv, + DRIContextType contextStore); +static void I830DestroyContext(ScreenPtr pScreen, drmContext hwContext, + DRIContextType contextStore); +static void I830DRISwapContext(ScreenPtr pScreen, DRISyncType syncType, + DRIContextType readContextType, + void *readContextStore, + DRIContextType writeContextType, + void *writeContextStore); +static void I830DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index); +static void I830DRIMoveBuffers(WindowPtr pParent, DDXPointRec ptOldOrg, + RegionPtr prgnSrc, CARD32 index); + +static Bool I830DRICloseFullScreen(ScreenPtr pScreen); +static Bool I830DRIOpenFullScreen(ScreenPtr pScreen); +static void I830DRITransitionTo2d(ScreenPtr pScreen); +static void I830DRITransitionTo3d(ScreenPtr pScreen); +static void I830DRITransitionMultiToSingle3d(ScreenPtr pScreen); +static void I830DRITransitionSingleToMulti3d(ScreenPtr pScreen); + +static void I830DRIShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf); + +extern void GlxSetVisualConfigs(int nconfigs, + __GLXvisualConfig * configs, + void **configprivs); + +static Bool +I830CleanupDma(ScrnInfoPtr pScrn) +{ + I830Ptr pI830 = I830PTR(pScrn); + drmI830Init info; + + memset(&info, 0, sizeof(drmI830Init)); + info.func = I830_CLEANUP_DMA; + + if (drmCommandWrite(pI830->drmSubFD, DRM_I830_INIT, + &info, sizeof(drmI830Init))) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "I830 Dma Cleanup Failed\n"); + return FALSE; + } + + return TRUE; +} + +static Bool +I830InitDma(ScrnInfoPtr pScrn) +{ + I830Ptr pI830 = I830PTR(pScrn); + I830RingBuffer *ring = &(pI830->LpRing); + I830DRIPtr pI830DRI = (I830DRIPtr) pI830->pDRIInfo->devPrivate; + drmI830Init info; + + memset(&info, 0, sizeof(drmI830Init)); + info.func = I830_INIT_DMA; + + info.ring_start = ring->mem.Start + pI830->LinearAddr; + info.ring_end = ring->mem.End + pI830->LinearAddr; + info.ring_size = ring->mem.Size; + + info.mmio_offset = (unsigned int)pI830DRI->regs; + info.buffers_offset = (unsigned int)pI830->buffer_map; + + info.sarea_priv_offset = sizeof(XF86DRISAREARec); + + info.front_offset = pI830->FrontBuffer.Start; + info.back_offset = pI830->BackBuffer.Start; + info.depth_offset = pI830->DepthBuffer.Start; + info.w = pScrn->virtualX; + info.h = pScrn->virtualY; + info.pitch = pI830->auxPitch; + info.pitch_bits = pI830->auxPitchBits; + info.back_pitch = pI830->auxPitch; + info.depth_pitch = pI830->auxPitch; + info.cpp = pI830->cpp; + + if (drmCommandWrite(pI830->drmSubFD, DRM_I830_INIT, + &info, sizeof(drmI830Init))) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, + "I830 Dma Initialization Failed\n"); + return FALSE; + } + + return TRUE; +} + +static Bool +I830SetParam(ScrnInfoPtr pScrn, int param, int value) +{ + I830Ptr pI830 = I830PTR(pScrn); + drmI830SetParam sp; + + memset(&sp, 0, sizeof(sp)); + sp.param = param; + sp.value = value; + + if (drmCommandWrite(pI830->drmSubFD, DRM_I830_SETPARAM, &sp, sizeof(sp))) { + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "I830 SetParam Failed\n"); + return FALSE; + } + + return TRUE; +} + + +static Bool +I830InitVisualConfigs(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + int numConfigs = 0; + __GLXvisualConfig *pConfigs = 0; + I830ConfigPrivPtr pI830Configs = 0; + I830ConfigPrivPtr *pI830ConfigPtrs = 0; + int accum, stencil, db, depth; + int i; + + switch (pScrn->bitsPerPixel) { + case 8: + case 24: + break; + + case 16: + numConfigs = 8; + + pConfigs = + (__GLXvisualConfig *) xcalloc(sizeof(__GLXvisualConfig), + numConfigs); + if (!pConfigs) + return FALSE; + + pI830Configs = + (I830ConfigPrivPtr) xcalloc(sizeof(I830ConfigPrivRec), + numConfigs); + if (!pI830Configs) { + xfree(pConfigs); + return FALSE; + } + + pI830ConfigPtrs = + (I830ConfigPrivPtr *) xcalloc(sizeof(I830ConfigPrivPtr), + numConfigs); + if (!pI830ConfigPtrs) { + xfree(pConfigs); + xfree(pI830Configs); + return FALSE; + } + + for (i = 0; i < numConfigs; i++) + pI830ConfigPtrs[i] = &pI830Configs[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].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 = 16; + } else { + pConfigs[i].accumRedSize = 0; + pConfigs[i].accumGreenSize = 0; + pConfigs[i].accumBlueSize = 0; + pConfigs[i].accumAlphaSize = 0; + } + pConfigs[i].doubleBuffer = db ? TRUE : 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 (stencil || 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++; + } + } + } + assert(i == numConfigs); + break; + + case 32: + numConfigs = 8; + + pConfigs = (__GLXvisualConfig *) xcalloc(sizeof(__GLXvisualConfig), + numConfigs); + if (!pConfigs) { + return FALSE; + } + + pI830Configs = (I830ConfigPrivPtr) xcalloc(sizeof(I830ConfigPrivRec), + numConfigs); + if (!pI830Configs) { + xfree(pConfigs); + return FALSE; + } + + pI830ConfigPtrs = (I830ConfigPrivPtr *) + xcalloc(sizeof(I830ConfigPrivPtr), numConfigs); + if (!pI830ConfigPtrs) { + xfree(pConfigs); + xfree(pI830Configs); + return FALSE; + } + + for (i = 0; i < numConfigs; i++) { + pI830ConfigPtrs[i] = &pI830Configs[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 = 0x00000000;; + 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; + + } + pI830->numVisualConfigs = numConfigs; + pI830->pVisualConfigs = pConfigs; + pI830->pVisualConfigsPriv = pI830Configs; + GlxSetVisualConfigs(numConfigs, pConfigs, (void **)pI830ConfigPtrs); + return TRUE; +} + +Bool +I830DRIScreenInit(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + DRIInfoPtr pDRIInfo; + I830DRIPtr pI830DRI; + + DPRINTF(PFX, "I830DRIScreenInit\n"); + /* Hardware 3D rendering only implemented for 16bpp and 32 bpp */ + if (((pScrn->bitsPerPixel / 8) != 2 && pScrn->depth != 16) && + (pScrn->bitsPerPixel / 8) != 4) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] Direct rendering only supported in 16 and 32 bpp modes\n"); + return FALSE; + } + + /* Check that the GLX, DRI, and DRM modules have been loaded by testing + * for known 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] %s failed (libdri.a too old)\n", "I830DRIScreenInit"); + 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] %s failed because of a version mismatch.\n" + "[dri] libDRI version is %d.%d.%d bug version 4.0.x is needed.\n" + "[dri] Disabling DRI.\n", + "I830DRIScreenInit", major, minor, patch); + return FALSE; + } + } + + pDRIInfo = DRICreateInfoRec(); + if (!pDRIInfo) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] DRICreateInfoRec failed. Disabling DRI.\n"); + return FALSE; + } + + pI830->pDRIInfo = pDRIInfo; + pI830->LockHeld = 0; + + pDRIInfo->drmDriverName = I830KernelDriverName; + pDRIInfo->clientDriverName = I830ClientDriverName; + pDRIInfo->busIdString = xalloc(64); + + sprintf(pDRIInfo->busIdString, "PCI:%d:%d:%d", + ((pciConfigPtr) pI830->PciInfo->thisCard)->busnum, + ((pciConfigPtr) pI830->PciInfo->thisCard)->devnum, + ((pciConfigPtr) pI830->PciInfo->thisCard)->funcnum); + pDRIInfo->ddxDriverMajorVersion = I830_MAJOR_VERSION; + pDRIInfo->ddxDriverMinorVersion = I830_MINOR_VERSION; + pDRIInfo->ddxDriverPatchVersion = I830_PATCHLEVEL; + pDRIInfo->frameBufferPhysicalAddress = pI830->LinearAddr + + pI830->FrontBuffer.Start; + pDRIInfo->frameBufferSize = ROUND_TO_PAGE(pScrn->displayWidth * + pScrn->virtualY * pI830->cpp); + pDRIInfo->frameBufferStride = pScrn->displayWidth * pI830->cpp; + pDRIInfo->ddxDrawableTableEntry = I830_MAX_DRAWABLES; + + if (SAREA_MAX_DRAWABLES < I830_MAX_DRAWABLES) + pDRIInfo->maxDrawableTableEntry = SAREA_MAX_DRAWABLES; + else + pDRIInfo->maxDrawableTableEntry = I830_MAX_DRAWABLES; + + if (sizeof(XF86DRISAREARec) + sizeof(I830SAREARec) > SAREA_MAX) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] Data does not fit in SAREA\n"); + return FALSE; + } + /* This is a hack for now. We have to have more than a 4k page here + * because of the size of the state. However, the state should be + * in a per-context mapping. This will be added in the Mesa 3.5 port + * of the I830 driver. + */ + pDRIInfo->SAREASize = SAREA_MAX; + + if (!(pI830DRI = (I830DRIPtr) xcalloc(sizeof(I830DRIRec), 1))) { + DRIDestroyInfoRec(pI830->pDRIInfo); + pI830->pDRIInfo = 0; + return FALSE; + } + pDRIInfo->devPrivate = pI830DRI; + pDRIInfo->devPrivateSize = sizeof(I830DRIRec); + pDRIInfo->contextSize = sizeof(I830DRIContextRec); + + pDRIInfo->CreateContext = I830CreateContext; + pDRIInfo->DestroyContext = I830DestroyContext; + pDRIInfo->SwapContext = I830DRISwapContext; + pDRIInfo->InitBuffers = I830DRIInitBuffers; + pDRIInfo->MoveBuffers = I830DRIMoveBuffers; + pDRIInfo->bufferRequests = DRI_ALL_WINDOWS; + pDRIInfo->OpenFullScreen = I830DRIOpenFullScreen; + pDRIInfo->CloseFullScreen = I830DRICloseFullScreen; + pDRIInfo->TransitionTo2d = I830DRITransitionTo2d; + pDRIInfo->TransitionTo3d = I830DRITransitionTo3d; + pDRIInfo->TransitionSingleToMulti3D = I830DRITransitionSingleToMulti3d; + pDRIInfo->TransitionMultiToSingle3D = I830DRITransitionMultiToSingle3d; + + if (!DRIScreenInit(pScreen, pDRIInfo, &pI830->drmSubFD)) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] DRIScreenInit failed. Disabling DRI.\n"); + xfree(pDRIInfo->devPrivate); + pDRIInfo->devPrivate = 0; + DRIDestroyInfoRec(pI830->pDRIInfo); + pI830->pDRIInfo = 0; + return FALSE; + } + + /* Check the i830 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(pI830->drmSubFD); + } 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(pI830->drmSubFD); + version->version_major = 1; + version->version_minor = 0; + version->version_patchlevel = 0; + } + +#define REQ_MAJ 1 +#define REQ_MIN 1 + if (version) { + if (version->version_major != REQ_MAJ || + version->version_minor < REQ_MIN) { + /* incompatible drm library version */ + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] I830DRIScreenInit failed because of a version mismatch.\n" + "[dri] libdrm.a module version is %d.%d.%d but version %d.%d.x is needed.\n" + "[dri] Disabling DRI.\n", + version->version_major, + version->version_minor, version->version_patchlevel, + REQ_MAJ, REQ_MIN); + drmFreeVersion(version); + I830DRICloseScreen(pScreen); + return FALSE; + } + drmFreeVersion(version); + } + + /* Check the i830 DRM version */ + version = drmGetVersion(pI830->drmSubFD); + if (version) { + if (version->version_major != 1 || version->version_minor < 3) { + /* incompatible drm version */ + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] %s failed because of a version mismatch.\n" + "[dri] i830.o kernel module version is %d.%d.%d but version 1.3 or greater is needed.\n" + "[dri] Disabling DRI.\n", + "I830DRIScreenInit", + version->version_major, + version->version_minor, version->version_patchlevel); + I830DRICloseScreen(pScreen); + drmFreeVersion(version); + return FALSE; + } + pI830->drmMinor = version->version_minor; + drmFreeVersion(version); + } + } + return TRUE; +} + +Bool +I830DRIDoMappings(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + DRIInfoPtr pDRIInfo = pI830->pDRIInfo; + I830DRIPtr pI830DRI = pDRIInfo->devPrivate; + int bufs; + + DPRINTF(PFX, "I830DRIDoMappings\n"); + pI830DRI->regsSize = I830_REG_SIZE; + if (drmAddMap(pI830->drmSubFD, (drmHandle)pI830->MMIOAddr, + pI830DRI->regsSize, DRM_REGISTERS, 0, &pI830DRI->regs) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, "[drm] drmAddMap(regs) failed\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] Registers = 0x%08lx\n", + pI830DRI->regs); + + /* + * The tile setup is now initiated from I830BIOSScreenInit(). + */ + + pI830->auxPitch = pScrn->displayWidth; + pI830->auxPitchBits = 0; + + pI830DRI->backbufferSize = pI830->BackBuffer.Size; + + if (drmAddMap(pI830->drmSubFD, + (drmHandle)pI830->BackBuffer.Start + pI830->LinearAddr, + pI830->BackBuffer.Size, DRM_AGP, 0, + &pI830DRI->backbuffer) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] drmAddMap(backbuffer) failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] Back Buffer = 0x%08lx\n", + pI830DRI->backbuffer); + + pI830DRI->depthbufferSize = pI830->DepthBuffer.Size; + if (drmAddMap(pI830->drmSubFD, + (drmHandle)pI830->DepthBuffer.Start + pI830->LinearAddr, + pI830->DepthBuffer.Size, DRM_AGP, 0, + &pI830DRI->depthbuffer) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] drmAddMap(depthbuffer) failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] Depth Buffer = 0x%08lx\n", + pI830DRI->depthbuffer); + + if (drmAddMap(pI830->drmSubFD, + (drmHandle)pI830->BufferMem.Start + pI830->LinearAddr, + pI830->BufferMem.Size, DRM_AGP, 0, + &pI830->buffer_map) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] drmAddMap(buffer_map) failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] DMA Buffers = 0x%08lx\n", + pI830->buffer_map); + + pI830DRI->agp_buffers = pI830->buffer_map; + pI830DRI->agp_buf_size = pI830->BufferMem.Size; + + if (drmAddMap(pI830->drmSubFD, + (drmHandle)pI830->LpRing.mem.Start + pI830->LinearAddr, + pI830->LpRing.mem.Size, DRM_AGP, 0, + &pI830->ring_map) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] drmAddMap(ring_map) failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] ring buffer = 0x%08lx\n", + pI830->ring_map); + + pI830DRI->textureSize = pI830->TexMem.Size; + pI830DRI->logTextureGranularity = pI830->TexGranularity; + + if (drmAddMap(pI830->drmSubFD, + (drmHandle)pI830->TexMem.Start + pI830->LinearAddr, + pI830->TexMem.Size, DRM_AGP, 0, + &pI830DRI->textures) < 0) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[drm] drmAddMap(textures) failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + xf86DrvMsg(pScreen->myNum, X_INFO, "[drm] textures = 0x%08lx\n", + pI830DRI->textures); + + if ((bufs = drmAddBufs(pI830->drmSubFD, + I830_DMA_BUF_NR, + I830_DMA_BUF_SZ, + DRM_AGP_BUFFER, pI830DRI->agp_buffers)) <= 0) { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "[drm] failure adding %d %d byte DMA buffers\n", + I830_DMA_BUF_NR, I830_DMA_BUF_SZ); + DRICloseScreen(pScreen); + return FALSE; + } + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "[drm] added %d %d byte DMA buffers\n", bufs, I830_DMA_BUF_SZ); + + I830InitDma(pScrn); + + if (pI830->PciInfo->chipType != PCI_CHIP_845_G && + pI830->PciInfo->chipType != PCI_CHIP_I830_M) { + I830SetParam(pScrn, I830_SETPARAM_USE_MI_BATCHBUFFER_START, 1 ); + } + + /* Okay now initialize the dma engine */ + if (!pI830DRI->irq) { + pI830DRI->irq = drmGetInterruptFromBusID(pI830->drmSubFD, + ((pciConfigPtr) pI830-> + PciInfo->thisCard)->busnum, + ((pciConfigPtr) pI830-> + PciInfo->thisCard)->devnum, + ((pciConfigPtr) pI830-> + PciInfo->thisCard)->funcnum); +#if 1 + if ((drmCtlInstHandler(pI830->drmSubFD, pI830DRI->irq)) != 0) { + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "[drm] failure adding irq handler, there is a device already using that irq\n" + "[drm] Consider rearranging your PCI cards\n"); + DRICloseScreen(pScreen); + return FALSE; + } +#endif + } + + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, + "[drm] dma control initialized, using IRQ %d\n", pI830DRI->irq); + + pI830DRI = (I830DRIPtr) pI830->pDRIInfo->devPrivate; + pI830DRI->deviceID = pI830->PciInfo->chipType; + pI830DRI->width = pScrn->virtualX; + pI830DRI->height = pScrn->virtualY; + pI830DRI->mem = pScrn->videoRam * 1024; + pI830DRI->cpp = pI830->cpp; + + pI830DRI->fbOffset = pI830->FrontBuffer.Start; + pI830DRI->fbStride = pI830->auxPitch; + + pI830DRI->bitsPerPixel = pScrn->bitsPerPixel; + + pI830DRI->textureOffset = pI830->TexMem.Start; + + pI830DRI->backOffset = pI830->BackBuffer.Start; + pI830DRI->depthOffset = pI830->DepthBuffer.Start; + + pI830DRI->ringOffset = pI830->LpRing.mem.Start; + pI830DRI->ringSize = pI830->LpRing.mem.Size; + + pI830DRI->auxPitch = pI830->auxPitch; + pI830DRI->auxPitchBits = pI830->auxPitchBits; + pI830DRI->sarea_priv_offset = sizeof(XF86DRISAREARec); + + if (!(I830InitVisualConfigs(pScreen))) { + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[dri] I830InitVisualConfigs failed. Disabling DRI\n"); + DRICloseScreen(pScreen); + return FALSE; + } + + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "[dri] visual configs initialized\n"); + pI830->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT; + + return TRUE; +} + +void +I830DRICloseScreen(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + + DPRINTF(PFX, "I830DRICloseScreen\n"); + + I830CleanupDma(pScrn); + + DRICloseScreen(pScreen); + + if (pI830->pDRIInfo) { + if (pI830->pDRIInfo->devPrivate) { + xfree(pI830->pDRIInfo->devPrivate); + pI830->pDRIInfo->devPrivate = 0; + } + DRIDestroyInfoRec(pI830->pDRIInfo); + pI830->pDRIInfo = 0; + } + if (pI830->pVisualConfigs) + xfree(pI830->pVisualConfigs); + if (pI830->pVisualConfigsPriv) + xfree(pI830->pVisualConfigsPriv); +} + +static Bool +I830CreateContext(ScreenPtr pScreen, VisualPtr visual, + drmContext hwContext, void *pVisualConfigPriv, + DRIContextType contextStore) +{ + return TRUE; +} + +static void +I830DestroyContext(ScreenPtr pScreen, drmContext hwContext, + DRIContextType contextStore) +{ +} + +Bool +I830DRIFinishScreenInit(ScreenPtr pScreen) +{ + I830SAREARec *sPriv = (I830SAREARec *) DRIGetSAREAPrivate(pScreen); + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + + DPRINTF(PFX, "I830DRIFinishScreenInit\n"); + + memset(sPriv, 0, sizeof(sPriv)); + + /* Have shadow run only while there is 3d active. + */ + if (pI830->allowPageFlip && pI830->drmMinor >= 3) { + shadowSetup(pScreen); + shadowAdd(pScreen, 0, I830DRIShadowUpdate, 0, 0, 0); + } + else + pI830->allowPageFlip = 0; + + return DRIFinishScreenInit(pScreen); +} + +void +I830DRISwapContext(ScreenPtr pScreen, DRISyncType syncType, + DRIContextType oldContextType, void *oldContext, + DRIContextType newContextType, void *newContext) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + + if (syncType == DRI_3D_SYNC && + oldContextType == DRI_2D_CONTEXT && newContextType == DRI_2D_CONTEXT) { + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + ErrorF("i830DRISwapContext (in)\n"); + + pI830->LockHeld = 1; + I830RefreshRing(pScrn); + } else if (syncType == DRI_2D_SYNC && + oldContextType == DRI_NO_CONTEXT && + newContextType == DRI_2D_CONTEXT) { + pI830->LockHeld = 0; + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + ErrorF("i830DRISwapContext (out)\n"); + } else if (I810_DEBUG & DEBUG_VERBOSE_DRI) + ErrorF("i830DRISwapContext (other)\n"); +} + +static void +I830DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index) +{ + ScreenPtr pScreen = pWin->drawable.pScreen; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + BoxPtr pbox = REGION_RECTS(prgn); + int nbox = REGION_NUM_RECTS(prgn); + + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + ErrorF("I830DRIInitBuffers\n"); + + I830SetupForSolidFill(pScrn, 0, GXcopy, -1); + while (nbox--) { + I830SelectBuffer(pScrn, I830_SELECT_BACK); + I830SubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1, + pbox->x2 - pbox->x1, pbox->y2 - pbox->y1); + pbox++; + } + + /* Clear the depth buffer - uses 0xffff rather than 0. + */ + pbox = REGION_RECTS(prgn); + nbox = REGION_NUM_RECTS(prgn); + + I830SelectBuffer(pScrn, I830_SELECT_DEPTH); + + switch (pScrn->bitsPerPixel) { + case 16: + I830SetupForSolidFill(pScrn, 0xffff, GXcopy, -1); + break; + case 32: + I830SetupForSolidFill(pScrn, 0xffffff, GXcopy, -1); + break; + } + + while (nbox--) { + I830SubsequentSolidFillRect(pScrn, pbox->x1, pbox->y1, + pbox->x2 - pbox->x1, pbox->y2 - pbox->y1); + pbox++; + } + + I830SelectBuffer(pScrn, I830_SELECT_FRONT); + pI830->AccelInfoRec->NeedToSync = TRUE; +} + +/* 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. + */ +static void +I830DRIMoveBuffers(WindowPtr pParent, DDXPointRec ptOldOrg, + RegionPtr prgnSrc, CARD32 index) +{ + ScreenPtr pScreen = pParent->drawable.pScreen; + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + BoxPtr pboxTmp, pboxNext, pboxBase; + DDXPointPtr pptTmp, pptNew2; + int xdir, ydir; + + int screenwidth = pScrn->virtualX; + int screenheight = pScrn->virtualY; + + BoxPtr pbox = REGION_RECTS(prgnSrc); + int nbox = REGION_NUM_RECTS(prgnSrc); + + BoxPtr pboxNew1 = 0; + BoxPtr pboxNew2 = 0; + DDXPointPtr pptNew1 = 0; + DDXPointPtr pptSrc = &ptOldOrg; + + int dx = pParent->drawable.x - ptOldOrg.x; + int 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; + } + + /* SelectBuffer isn't really a good concept for the i810. + */ + I830EmitFlush(pScrn); + I830SetupForScreenToScreenCopy(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; + + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + ErrorF("MoveBuffers %d,%d %dx%d dx: %d dy: %d\n", + x1, y1, w, h, dx, dy); + + I830SelectBuffer(pScrn, I830_SELECT_BACK); + I830SubsequentScreenToScreenCopy(pScrn, x1, y1, destx, desty, w, h); + I830SelectBuffer(pScrn, I830_SELECT_DEPTH); + I830SubsequentScreenToScreenCopy(pScrn, x1, y1, destx, desty, w, h); + } + I830SelectBuffer(pScrn, I830_SELECT_FRONT); + I830EmitFlush(pScrn); + + if (pboxNew2) { + DEALLOCATE_LOCAL(pptNew2); + DEALLOCATE_LOCAL(pboxNew2); + } + if (pboxNew1) { + DEALLOCATE_LOCAL(pptNew1); + DEALLOCATE_LOCAL(pboxNew1); + } + + pI830->AccelInfoRec->NeedToSync = TRUE; +} + +/* Completely Initialize the first context */ +void +I830EmitInvarientState(ScrnInfoPtr pScrn) +{ + I830Ptr pI830 = I830PTR(pScrn); + I830DRIPtr pI830DRI = (I830DRIPtr) pI830->pDRIInfo->devPrivate; + CARD32 ctx_addr, temp; + + BEGIN_LP_RING(128-2); + + ctx_addr = pI830->ContextMem.Start; + /* Align to a 2k boundry */ + ctx_addr = ((ctx_addr + 2048 - 1) / 2048) * 2048; + + OUT_RING(MI_SET_CONTEXT); + OUT_RING(ctx_addr | + CTXT_NO_RESTORE | + CTXT_PALETTE_SAVE_DISABLE | CTXT_PALETTE_RESTORE_DISABLE); + + OUT_RING(STATE3D_AA_CMD | + AA_LINE_ECAAR_WIDTH_ENABLE | + AA_LINE_ECAAR_WIDTH_1_0 | + AA_LINE_REGION_WIDTH_ENABLE | + AA_LINE_REGION_WIDTH_1_0 | AA_LINE_DISABLE); + + OUT_RING(STATE3D_BUF_INFO_CMD); + OUT_RING(BUF_3D_ID_COLOR_BACK | + BUF_3D_USE_FENCE | + BUF_3D_PITCH((pI830->cpp * pScrn->displayWidth) / 4)); + OUT_RING(BUF_3D_ADDR(pI830DRI->backOffset)); + + OUT_RING(STATE3D_BUF_INFO_CMD); + OUT_RING(BUF_3D_ID_DEPTH | + BUF_3D_USE_FENCE | + BUF_3D_PITCH((pI830->cpp * pScrn->displayWidth) / 4)); + OUT_RING(BUF_3D_ADDR(pI830DRI->depthOffset)); + + OUT_RING(STATE3D_COLOR_FACTOR); + OUT_RING(0); + + OUT_RING(STATE3D_COLOR_FACTOR_CMD(0)); + OUT_RING(0); + + OUT_RING(STATE3D_COLOR_FACTOR_CMD(1)); + OUT_RING(0); + + OUT_RING(STATE3D_COLOR_FACTOR_CMD(2)); + OUT_RING(0); + + OUT_RING(STATE3D_COLOR_FACTOR_CMD(3)); + OUT_RING(0); + + OUT_RING(STATE3D_CONST_BLEND_COLOR_CMD); + OUT_RING(0); + + OUT_RING(STATE3D_DFLT_DIFFUSE_CMD); + OUT_RING(0); + + OUT_RING(STATE3D_DFLT_SPEC_CMD); + OUT_RING(0); + + OUT_RING(STATE3D_DFLT_Z_CMD); + OUT_RING(0); + + switch (pScrn->bitsPerPixel) { + case 15: + temp = DEPTH_FRMT_16_FIXED | COLR_BUF_RGB555; + break; + case 16: + temp = DEPTH_FRMT_16_FIXED | COLR_BUF_RGB565; + break; + case 32: + temp = DEPTH_FRMT_24_FIXED_8_OTHER | COLR_BUF_ARGB8888; + break; + default: + temp = DEPTH_FRMT_16_FIXED | COLR_BUF_RGB565; + break; + } + + OUT_RING(STATE3D_DST_BUF_VARS_CMD); + OUT_RING(DSTORG_HORT_BIAS(0x8) | + DSTORG_VERT_BIAS(0x8) | DEPTH_IS_Z | temp); + + OUT_RING(STATE3D_DRAW_RECT_CMD); + OUT_RING(DRAW_RECT_DIS_DEPTH_OFS); + OUT_RING(0); + OUT_RING((pI830DRI->height << 16) | pI830DRI->width); + OUT_RING(0); + + OUT_RING(STATE3D_ENABLES_1_CMD | + DISABLE_LOGIC_OP | + DISABLE_STENCIL_TEST | + DISABLE_DEPTH_BIAS | + DISABLE_SPEC_ADD | + I830_DISABLE_FOG | + DISABLE_ALPHA_TEST | DISABLE_COLOR_BLEND | DISABLE_DEPTH_TEST); + + OUT_RING(STATE3D_ENABLES_2_CMD | + DISABLE_STENCIL_WRITE | + ENABLE_TEX_CACHE | + ENABLE_DITHER | + ENABLE_COLOR_MASK | ENABLE_COLOR_WRITE | ENABLE_DEPTH_WRITE); + + OUT_RING(STATE3D_FOG_COLOR_CMD | + FOG_COLOR_RED(0) | FOG_COLOR_GREEN(0) | FOG_COLOR_BLUE(0)); + + OUT_RING(STATE3D_FOG_MODE); + OUT_RING(FOG_MODE_VERTEX | + ENABLE_FOG_CONST | ENABLE_FOG_SOURCE | ENABLE_FOG_DENSITY); + OUT_RING(0); + OUT_RING(0); + + OUT_RING(STATE3D_INDPT_ALPHA_BLEND_CMD | + DISABLE_INDPT_ALPHA_BLEND | + ENABLE_ALPHA_BLENDFUNC | + ABLENDFUNC_ADD | + ENABLE_SRC_ABLEND_FACTOR | + SRC_ABLEND_FACT(BLENDFACT_ONE) | + ENABLE_DST_ABLEND_FACTOR | SRC_ABLEND_FACT(BLENDFACT_ZERO)); + + /* I need to come back to texture state */ + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(0) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(1) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(2) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(3) | + TEXPIPE_COLOR | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(0) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(1) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(2) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + OUT_RING(STATE3D_MAP_BLEND_ARG_CMD(3) | + TEXPIPE_ALPHA | + TEXBLEND_ARG1 | TEXBLENDARG_MODIFY_PARMS | TEXBLENDARG_DIFFUSE); + + OUT_RING(STATE3D_MAP_BLEND_OP_CMD(0) | + TEXPIPE_COLOR | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + DISABLE_TEX_CNTRL_STAGE | + TEXOP_SCALE_1X | + TEXOP_MODIFY_PARMS | TEXOP_LAST_STAGE | TEXBLENDOP_ARG1); + OUT_RING(STATE3D_MAP_BLEND_OP_CMD(0) | + TEXPIPE_ALPHA | + ENABLE_TEXOUTPUT_WRT_SEL | + TEXOP_OUTPUT_CURRENT | + TEXOP_SCALE_1X | TEXOP_MODIFY_PARMS | TEXBLENDOP_ARG1); + + OUT_RING(STATE3D_MAP_COORD_SETBIND_CMD); + OUT_RING(TEXBIND_SET3(TEXCOORDSRC_DEFAULT) | + TEXBIND_SET2(TEXCOORDSRC_DEFAULT) | + TEXBIND_SET1(TEXCOORDSRC_DEFAULT) | + TEXBIND_SET0(TEXCOORDSRC_DEFAULT)); + + OUT_RING(STATE3D_MAP_COORD_SET_CMD | + MAP_UNIT(0) | + TEXCOORDS_ARE_IN_TEXELUNITS | + TEXCOORDTYPE_CARTESIAN | + ENABLE_ADDR_V_CNTL | + ENABLE_ADDR_U_CNTL | + TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_CLAMP) | + TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_CLAMP)); + OUT_RING(STATE3D_MAP_COORD_SET_CMD | + MAP_UNIT(1) | + TEXCOORDS_ARE_IN_TEXELUNITS | + TEXCOORDTYPE_CARTESIAN | + ENABLE_ADDR_V_CNTL | + ENABLE_ADDR_U_CNTL | + TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_CLAMP) | + TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_CLAMP)); + OUT_RING(STATE3D_MAP_COORD_SET_CMD | + MAP_UNIT(2) | + TEXCOORDS_ARE_IN_TEXELUNITS | + TEXCOORDTYPE_CARTESIAN | + ENABLE_ADDR_V_CNTL | + ENABLE_ADDR_U_CNTL | + TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_CLAMP) | + TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_CLAMP)); + OUT_RING(STATE3D_MAP_COORD_SET_CMD | + MAP_UNIT(3) | + TEXCOORDS_ARE_IN_TEXELUNITS | + TEXCOORDTYPE_CARTESIAN | + ENABLE_ADDR_V_CNTL | + ENABLE_ADDR_U_CNTL | + TEXCOORD_ADDR_V_MODE(TEXCOORDMODE_CLAMP) | + TEXCOORD_ADDR_U_MODE(TEXCOORDMODE_CLAMP)); + + OUT_RING(STATE3D_MAP_TEX_STREAM_CMD | + MAP_UNIT(0) | + DISABLE_TEX_STREAM_BUMP | + ENABLE_TEX_STREAM_COORD_SET | + TEX_STREAM_COORD_SET(0) | + ENABLE_TEX_STREAM_MAP_IDX | TEX_STREAM_MAP_IDX(0)); + OUT_RING(STATE3D_MAP_TEX_STREAM_CMD | + MAP_UNIT(1) | + DISABLE_TEX_STREAM_BUMP | + ENABLE_TEX_STREAM_COORD_SET | + TEX_STREAM_COORD_SET(1) | + ENABLE_TEX_STREAM_MAP_IDX | TEX_STREAM_MAP_IDX(1)); + OUT_RING(STATE3D_MAP_TEX_STREAM_CMD | + MAP_UNIT(2) | + DISABLE_TEX_STREAM_BUMP | + ENABLE_TEX_STREAM_COORD_SET | + TEX_STREAM_COORD_SET(2) | + ENABLE_TEX_STREAM_MAP_IDX | TEX_STREAM_MAP_IDX(2)); + OUT_RING(STATE3D_MAP_TEX_STREAM_CMD | + MAP_UNIT(3) | + DISABLE_TEX_STREAM_BUMP | + ENABLE_TEX_STREAM_COORD_SET | + TEX_STREAM_COORD_SET(3) | + ENABLE_TEX_STREAM_MAP_IDX | TEX_STREAM_MAP_IDX(3)); + +#if 0 + OUT_RING(STATE3D_MAP_FILTER_CMD | + MAP_UNIT(0) | + ENABLE_CHROMA_KEY_PARAMS | + ENABLE_MIP_MODE_FILTER | + MIPFILTER_NEAREST | + ENABLE_MAG_MODE_FILTER | + ENABLE_MIN_MODE_FILTER | + MAG_FILTER(FILTER_NEAREST) | MIN_FILTER(FILTER_NEAREST)); + OUT_RING(STATE3D_MAP_FILTER_CMD | + MAP_UNIT(1) | + ENABLE_CHROMA_KEY_PARAMS | + ENABLE_MIP_MODE_FILTER | + MIPFILTER_NEAREST | + ENABLE_MAG_MODE_FILTER | + ENABLE_MIN_MODE_FILTER | + MAG_FILTER(FILTER_NEAREST) | MIN_FILTER(FILTER_NEAREST)); + OUT_RING(STATE3D_MAP_FILTER_CMD | + MAP_UNIT(2) | + ENABLE_CHROMA_KEY_PARAMS | + ENABLE_MIP_MODE_FILTER | + MIPFILTER_NEAREST | + ENABLE_MAG_MODE_FILTER | + ENABLE_MIN_MODE_FILTER | + MAG_FILTER(FILTER_NEAREST) | MIN_FILTER(FILTER_NEAREST)); + OUT_RING(STATE3D_MAP_FILTER_CMD | + MAP_UNIT(3) | + ENABLE_CHROMA_KEY_PARAMS | + ENABLE_MIP_MODE_FILTER | + MIPFILTER_NEAREST | + ENABLE_MAG_MODE_FILTER | + ENABLE_MIN_MODE_FILTER | + MAG_FILTER(FILTER_NEAREST) | MIN_FILTER(FILTER_NEAREST)); + + OUT_RING(STATE3D_MAP_INFO_COLR_CMD); + OUT_RING(MAP_INFO_TEX(0) | + MAPSURF_32BIT | + MT_32BIT_ARGB8888 | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | MAP_INFO_USE_FENCE); + OUT_RING(MAP_INFO_HEIGHT(0) | MAP_INFO_WIDTH(0)); + OUT_RING(MAP_INFO_BASEADDR(pI830->TexMem.Start)); + OUT_RING(MAP_INFO_DWORD_PITCH(31)); + OUT_RING(MAP_INFO_DFLT_COLR(0)); + + OUT_RING(STATE3D_MAP_INFO_COLR_CMD); + OUT_RING(MAP_INFO_TEX(1) | + MAPSURF_32BIT | + MT_32BIT_ARGB8888 | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | MAP_INFO_USE_FENCE); + OUT_RING(MAP_INFO_HEIGHT(0) | MAP_INFO_WIDTH(0)); + OUT_RING(MAP_INFO_BASEADDR(pI830->TexMem.Start)); + OUT_RING(MAP_INFO_DWORD_PITCH(31)); + OUT_RING(MAP_INFO_DFLT_COLR(0)); + + OUT_RING(STATE3D_MAP_INFO_COLR_CMD); + OUT_RING(MAP_INFO_TEX(2) | + MAPSURF_32BIT | + MT_32BIT_ARGB8888 | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | MAP_INFO_USE_FENCE); + OUT_RING(MAP_INFO_HEIGHT(0) | MAP_INFO_WIDTH(0)); + OUT_RING(MAP_INFO_BASEADDR(pI830->TexMem.Start)); + OUT_RING(MAP_INFO_DWORD_PITCH(31)); + OUT_RING(MAP_INFO_DFLT_COLR(0)); + + OUT_RING(STATE3D_MAP_INFO_COLR_CMD); + OUT_RING(MAP_INFO_TEX(3) | + MAPSURF_32BIT | + MT_32BIT_ARGB8888 | + MAP_INFO_OUTMUX_F0F1F2F3 | + MAP_INFO_VERTLINESTRIDEOFS_0 | + MAP_INFO_FORMAT_2D | MAP_INFO_USE_FENCE); + OUT_RING(MAP_INFO_HEIGHT(0) | MAP_INFO_WIDTH(0)); + OUT_RING(MAP_INFO_BASEADDR(pI830->TexMem.Start)); + OUT_RING(MAP_INFO_DWORD_PITCH(31)); + OUT_RING(MAP_INFO_DFLT_COLR(0)); + + OUT_RING(STATE3D_MAP_LOD_CNTL_CMD | + MAP_UNIT(0) | ENABLE_TEXLOD_BIAS | MAP_LOD_BIAS(0)); + OUT_RING(STATE3D_MAP_LOD_CNTL_CMD | + MAP_UNIT(1) | ENABLE_TEXLOD_BIAS | MAP_LOD_BIAS(0)); + OUT_RING(STATE3D_MAP_LOD_CNTL_CMD | + MAP_UNIT(2) | ENABLE_TEXLOD_BIAS | MAP_LOD_BIAS(0)); + OUT_RING(STATE3D_MAP_LOD_CNTL_CMD | + MAP_UNIT(3) | ENABLE_TEXLOD_BIAS | MAP_LOD_BIAS(0)); + + OUT_RING(STATE3D_MAP_LOD_LIMITS_CMD | + MAP_UNIT(0) | + ENABLE_MAX_MIP_LVL | + ENABLE_MIN_MIP_LVL | LOD_MAX(0) | LOD_MIN(0)); + OUT_RING(STATE3D_MAP_LOD_LIMITS_CMD | + MAP_UNIT(1) | + ENABLE_MAX_MIP_LVL | + ENABLE_MIN_MIP_LVL | LOD_MAX(0) | LOD_MIN(0)); + OUT_RING(STATE3D_MAP_LOD_LIMITS_CMD | + MAP_UNIT(2) | + ENABLE_MAX_MIP_LVL | + ENABLE_MIN_MIP_LVL | LOD_MAX(0) | LOD_MIN(0)); + OUT_RING(STATE3D_MAP_LOD_LIMITS_CMD | + MAP_UNIT(3) | + ENABLE_MAX_MIP_LVL | + ENABLE_MIN_MIP_LVL | LOD_MAX(0) | LOD_MIN(0)); +#endif + + OUT_RING(STATE3D_MAP_COORD_TRANSFORM); + OUT_RING(DISABLE_TEX_TRANSFORM | TEXTURE_SET(0)); + OUT_RING(STATE3D_MAP_COORD_TRANSFORM); + OUT_RING(DISABLE_TEX_TRANSFORM | TEXTURE_SET(1)); + OUT_RING(STATE3D_MAP_COORD_TRANSFORM); + OUT_RING(DISABLE_TEX_TRANSFORM | TEXTURE_SET(2)); + OUT_RING(STATE3D_MAP_COORD_TRANSFORM); + OUT_RING(DISABLE_TEX_TRANSFORM | TEXTURE_SET(3)); + + /* End texture state */ + + OUT_RING(STATE3D_MODES_1_CMD | + ENABLE_COLR_BLND_FUNC | + BLENDFUNC_ADD | + ENABLE_SRC_BLND_FACTOR | + ENABLE_DST_BLND_FACTOR | + SRC_BLND_FACT(BLENDFACT_ONE) | DST_BLND_FACT(BLENDFACT_ZERO)); + + OUT_RING(STATE3D_MODES_2_CMD | + ENABLE_GLOBAL_DEPTH_BIAS | + GLOBAL_DEPTH_BIAS(0) | + ENABLE_ALPHA_TEST_FUNC | + ALPHA_TEST_FUNC(COMPAREFUNC_ALWAYS) | ALPHA_REF_VALUE(0)); + + OUT_RING(STATE3D_MODES_3_CMD | + ENABLE_DEPTH_TEST_FUNC | + DEPTH_TEST_FUNC(COMPAREFUNC_LESS) | + ENABLE_ALPHA_SHADE_MODE | + ALPHA_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_FOG_SHADE_MODE | + FOG_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_SPEC_SHADE_MODE | + SPEC_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_COLOR_SHADE_MODE | + COLOR_SHADE_MODE(SHADE_MODE_LINEAR) | + ENABLE_CULL_MODE | CULLMODE_NONE); + + OUT_RING(STATE3D_MODES_4_CMD | + ENABLE_LOGIC_OP_FUNC | + LOGIC_OP_FUNC(LOGICOP_COPY) | + ENABLE_STENCIL_TEST_MASK | + STENCIL_TEST_MASK(0xff) | + ENABLE_STENCIL_WRITE_MASK | STENCIL_WRITE_MASK(0xff)); + + OUT_RING(STATE3D_MODES_5_CMD | + ENABLE_SPRITE_POINT_TEX | + SPRITE_POINT_TEX_OFF | + FLUSH_RENDER_CACHE | + FLUSH_TEXTURE_CACHE | + ENABLE_FIXED_LINE_WIDTH | + FIXED_LINE_WIDTH(0x2) | + ENABLE_FIXED_POINT_WIDTH | FIXED_POINT_WIDTH(1)); + + OUT_RING(STATE3D_RASTER_RULES_CMD | + ENABLE_POINT_RASTER_RULE | + OGL_POINT_RASTER_RULE | + ENABLE_LINE_STRIP_PROVOKE_VRTX | + ENABLE_TRI_FAN_PROVOKE_VRTX | + ENABLE_TRI_STRIP_PROVOKE_VRTX | + LINE_STRIP_PROVOKE_VRTX(1) | + TRI_FAN_PROVOKE_VRTX(2) | TRI_STRIP_PROVOKE_VRTX(2)); + + OUT_RING(STATE3D_SCISSOR_ENABLE_CMD | DISABLE_SCISSOR_RECT); + + OUT_RING(STATE3D_SCISSOR_RECT_0_CMD); + OUT_RING(0); + OUT_RING(0); + + OUT_RING(STATE3D_STENCIL_TEST_CMD | + ENABLE_STENCIL_PARMS | + STENCIL_FAIL_OP(STENCILOP_KEEP) | + STENCIL_PASS_DEPTH_FAIL_OP(STENCILOP_KEEP) | + STENCIL_PASS_DEPTH_PASS_OP(STENCILOP_KEEP) | + ENABLE_STENCIL_TEST_FUNC | + STENCIL_TEST_FUNC(COMPAREFUNC_ALWAYS) | + ENABLE_STENCIL_REF_VALUE | STENCIL_REF_VALUE(0)); + + OUT_RING(VRTX_FORMAT_NTEX(1)); + + OUT_RING(STATE3D_VERTEX_FORMAT_2_CMD | + VRTX_TEX_SET_0_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_1_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_2_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_3_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_4_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_5_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_6_FMT(TEXCOORDFMT_2D) | + VRTX_TEX_SET_7_FMT(TEXCOORDFMT_2D)); + + OUT_RING(STATE3D_VERTEX_TRANSFORM); + OUT_RING(DISABLE_VIEWPORT_TRANSFORM | DISABLE_PERSPECTIVE_DIVIDE); + + OUT_RING(STATE3D_W_STATE_CMD); + OUT_RING(MAGIC_W_STATE_DWORD1); + OUT_RING(0x3f800000 /* 1.0 in IEEE float */ ); + +#define GFX_OP_STIPPLE ((0x3<<29)|(0x1d<<24)|(0x83<<16)) + + OUT_RING(GFX_OP_STIPPLE); + OUT_RING(0); + + ADVANCE_LP_RING(); +} + +/* Fullscreen hooks. The DRI fullscreen mode can probably be removed + * as it adds little or nothing above the mechanism below. (and isn't + * widely used) + */ +static Bool +I830DRIOpenFullScreen(ScreenPtr pScreen) +{ + return TRUE; +} + +static Bool +I830DRICloseFullScreen(ScreenPtr pScreen) +{ + return TRUE; +} + + + +/* Use callbacks from dri.c to support pageflipping mode for a single + * 3d context without need for any specific full-screen extension. + * + * Also see tdfx driver for example of using these callbacks to + * allocate and free 3d-specific memory on demand. + */ + + + + + +/* Use the miext/shadow module to maintain a list of dirty rectangles. + * These are blitted to the back buffer to keep both buffers clean + * during page-flipping when the 3d application isn't fullscreen. + * + * Unlike most use of the shadow code, both buffers are in video + * memory. + * + * An alternative to this would be to organize for all on-screen + * drawing operations to be duplicated for the two buffers. That + * might be faster, but seems like a lot more work... + */ + + +/* This should be done *before* XAA syncs, + * Otherwise will have to sync again??? + */ +static void +I830DRIShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + RegionPtr damage = &pBuf->damage; + int i, num = REGION_NUM_RECTS(damage); + BoxPtr pbox = REGION_RECTS(damage); + I830SAREARec *pSAREAPriv = DRIGetSAREAPrivate(pScreen); + int cmd, br13; + + /* Don't want to do this when no 3d is active and pages are + * right-way-round : + */ + if (!pSAREAPriv->pf_active && pSAREAPriv->pf_current_page == 0) + return; + + br13 = (pScrn->displayWidth * pI830->cpp) | (0xcc << 16); + + if (pScrn->bitsPerPixel == 32) { + cmd = (XY_SRC_COPY_BLT_CMD | XY_SRC_COPY_BLT_WRITE_ALPHA | + XY_SRC_COPY_BLT_WRITE_RGB); + br13 |= 3 << 24; + } else { + cmd = (XY_SRC_COPY_BLT_CMD); + br13 |= 1 << 24; + } + + for (i = 0 ; i < num ; i++, pbox++) { + BEGIN_LP_RING(8); + OUT_RING(cmd); + OUT_RING(br13); + OUT_RING((pbox->y1 << 16) | pbox->x1); + OUT_RING((pbox->y2 << 16) | pbox->x2); + OUT_RING(pI830->BackBuffer.Start); + OUT_RING((pbox->y1 << 16) | pbox->x1); + OUT_RING(br13 & 0xffff); + OUT_RING(pI830->FrontBuffer.Start); + ADVANCE_LP_RING(); + } +} + + +static void +I830EnablePageFlip(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + I830SAREARec *pSAREAPriv = DRIGetSAREAPrivate(pScreen); + + pSAREAPriv->pf_enabled = pI830->allowPageFlip; + pSAREAPriv->pf_active = 0; + + if (pI830->allowPageFlip) { + int br13 = (pScrn->displayWidth * pI830->cpp) | (0xcc << 16); + + BEGIN_LP_RING(8); + if (pScrn->bitsPerPixel == 32) { + OUT_RING(XY_SRC_COPY_BLT_CMD | XY_SRC_COPY_BLT_WRITE_ALPHA | + XY_SRC_COPY_BLT_WRITE_RGB); + br13 |= 3 << 24; + } else { + OUT_RING(XY_SRC_COPY_BLT_CMD); + br13 |= 1 << 24; + } + + OUT_RING(br13); + OUT_RING(0); + OUT_RING((pScrn->virtualY << 16) | pScrn->virtualX); + OUT_RING(pI830->BackBuffer.Start); + OUT_RING(0); + OUT_RING(br13 & 0xffff); + OUT_RING(pI830->FrontBuffer.Start); + ADVANCE_LP_RING(); + + pSAREAPriv->pf_active = 1; + } +} + +static void +I830DisablePageFlip(ScreenPtr pScreen) +{ + I830SAREARec *pSAREAPriv = DRIGetSAREAPrivate(pScreen); + + pSAREAPriv->pf_active = 0; +} + + +static void +I830DRITransitionSingleToMulti3d(ScreenPtr pScreen) +{ + /* Tell the clients not to pageflip. How? + * -- Field in sarea, plus bumping the window counters. + * -- DRM needs to cope with Front-to-Back swapbuffers. + */ + I830DisablePageFlip(pScreen); +} + +static void +I830DRITransitionMultiToSingle3d(ScreenPtr pScreen) +{ + /* Let the remaining 3d app start page flipping again. + */ + I830EnablePageFlip(pScreen); +} + + +static void +I830DRITransitionTo3d(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + + I830EnablePageFlip(pScreen); + pI830->have3DWindows = 1; +} + + +static void +I830DRITransitionTo2d(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + I830Ptr pI830 = I830PTR(pScrn); + I830SAREARec *sPriv = (I830SAREARec *) DRIGetSAREAPrivate(pScreen); + + /* Shut down shadowing if we've made it back to the front page: + */ + if (sPriv->pf_current_page == 0) { + I830DisablePageFlip(pScreen); + } + + pI830->have3DWindows = 0; +} + + |