/** * Destroy the per-screen private information. * * \internal * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls * drmClose(), and finally frees \p screenPrivate. */ static void driDestroyScreen(__DRIscreen *psp) { if (psp) { /* No interaction with the X-server is possible at this point. This * routine is called after XCloseDisplay, so there is no protocol * stream open to the X-server anymore. */ _mesa_destroy_shader_compiler(); if (psp->DriverAPI.DestroyScreen) (*psp->DriverAPI.DestroyScreen)(psp); if (!psp->dri2.enabled) { (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX); (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize); (void)drmCloseOnce(psp->fd); } else { driDestroyOptionCache(&psp->optionCache); driDestroyOptionInfo(&psp->optionInfo); } free(psp); } }
/** * Destroy the per-screen private information. * * \internal * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls * drmClose(), and finally frees \p screenPrivate. */ static void driDestroyScreen(__DRIscreen *psp) { if (psp) { /* No interaction with the X-server is possible at this point. This * routine is called after XCloseDisplay, so there is no protocol * stream open to the X-server anymore. */ if (psp->DriverAPI.DestroyScreen) (*psp->DriverAPI.DestroyScreen)(psp); if (psp->dri2.enabled) { #ifdef TTM_API drmBOUnmap(psp->fd, &psp->dri2.sareaBO); drmBOUnreference(psp->fd, &psp->dri2.sareaBO); #endif } else { (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX); (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize); (void)drmCloseOnce(psp->fd); } _mesa_free(psp); } }
/* The screen is being closed, so clean up any state and free any resources used by the DRI. */ void R128DRICloseScreen(const DRIDriverContext *ctx) { R128InfoPtr info = ctx->driverPrivate; drm_r128_init_t drmInfo; /* Stop the CCE if it is still in use */ R128CCE_STOP(ctx, info); if (info->irq) { drmCtlUninstHandler(ctx->drmFD); info->irq = 0; } /* De-allocate vertex buffers */ if (info->buffers) { drmUnmapBufs(info->buffers); info->buffers = NULL; } /* De-allocate all kernel resources */ memset(&drmInfo, 0, sizeof(drmInfo)); drmInfo.func = R128_CLEANUP_CCE; drmCommandWrite(ctx->drmFD, DRM_R128_INIT, &drmInfo, sizeof(drmInfo)); /* De-allocate all AGP resources */ if (info->agpTex) { drmUnmap(info->agpTex, info->agpTexMapSize); info->agpTex = NULL; } if (info->buf) { drmUnmap(info->buf, info->bufMapSize); info->buf = NULL; } if (info->ringReadPtr) { drmUnmap(info->ringReadPtr, info->ringReadMapSize); info->ringReadPtr = NULL; } if (info->ring) { drmUnmap(info->ring, info->ringMapSize); info->ring = NULL; } if (info->agpMemHandle != DRM_AGP_NO_HANDLE) { drmAgpUnbind(ctx->drmFD, info->agpMemHandle); drmAgpFree(ctx->drmFD, info->agpMemHandle); info->agpMemHandle = 0; drmAgpRelease(ctx->drmFD); } if (info->pciMemHandle) { drmScatterGatherFree(ctx->drmFD, info->pciMemHandle); info->pciMemHandle = 0; } }
void intel_region_release(struct intel_region **region_handle) { struct intel_region *region = *region_handle; if (region == NULL) return; DBG("%s %p %d\n", __FUNCTION__, region, region->refcount - 1); ASSERT(region->refcount > 0); region->refcount--; if (region->refcount == 0) { assert(region->map_refcount == 0); if (region->pbo) region->pbo->region = NULL; region->pbo = NULL; dri_bo_unreference(region->buffer); if (region->classic_map != NULL) { drmUnmap(region->classic_map, region->pitch * region->cpp * region->height); } free(region); } *region_handle = NULL; }
/** * \brief The screen is being closed, so clean up any state and free any * resources used by the DRI. * * \param ctx display handle. * * Unmaps the SAREA, closes the DRM device file descriptor and frees the driver * private data. */ static void R128HaltFBDev( DRIDriverContext *ctx ) { drmUnmap( ctx->pSAREA, ctx->shared.SAREASize ); drmClose(ctx->drmFD); if (ctx->driverPrivate) { free(ctx->driverPrivate); ctx->driverPrivate = 0; } }
static void dri1Close(VADriverContextP ctx) { struct dri_state *dri_state = (struct dri_state *)ctx->drm_state; free_drawable_hashtable(ctx); VA_DRIDestroyContext(ctx->native_dpy, ctx->x11_screen, dri_state->hwContextID); assert(dri_state->pSAREA != MAP_FAILED); drmUnmap(dri_state->pSAREA, SAREA_MAX); assert(dri_state->base.fd >= 0); drmCloseOnce(dri_state->base.fd); VA_DRICloseConnection(ctx->native_dpy, ctx->x11_screen); }
/* Create the device specific screen private data struct. */ radeonScreenPtr radeonCreateScreen( __DRIscreenPrivate *sPriv ) { radeonScreenPtr radeonScreen; RADEONDRIPtr radeonDRIPriv = (RADEONDRIPtr)sPriv->pDevPriv; /* Check the DRI version */ { int major, minor, patch; if ( XF86DRIQueryVersion( sPriv->display, &major, &minor, &patch ) ) { if ( major != 4 || minor < 0 ) { __driUtilMessage( "Radeon DRI driver expected DRI version 4.0.x " "but got version %d.%d.%d", major, minor, patch ); return NULL; } } } /* Check that the DDX driver version is compatible */ if ( sPriv->ddxMajor != 4 || sPriv->ddxMinor < 0 ) { __driUtilMessage( "Radeon DRI driver expected DDX driver version 4.0.x " "but got version %d.%d.%d", sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch ); return NULL; } /* Check that the DRM driver version is compatible */ /* KW: Check minor number here too -- compatibility mode is broken * atm. */ if ( sPriv->drmMajor != 1 || sPriv->drmMinor < 3) { __driUtilMessage( "Radeon DRI driver expected DRM driver version 1.3.x " "or newer but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch ); return NULL; } /* Allocate the private area */ radeonScreen = (radeonScreenPtr) CALLOC( sizeof(*radeonScreen) ); if ( !radeonScreen ) { __driUtilMessage("%s: CALLOC radeonScreen struct failed", __FUNCTION__); return NULL; } if ( sPriv->drmMinor < 3 || getenv("RADEON_COMPAT")) { fprintf( stderr, "Radeon DRI driver:\n\t" "Compatibility mode for DRM driver version %d.%d.%d\n\t" "TCL will be disabled, expect reduced performance\n\t" "(prefer DRM radeon.o 1.3.x or newer)\n\t", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch ); } /* This is first since which regions we map depends on whether or * not we are using a PCI card. */ radeonScreen->IsPCI = radeonDRIPriv->IsPCI; if (sPriv->drmMinor >= 3) { int ret; drmRadeonGetParam gp; gp.param = RADEON_PARAM_AGP_BUFFER_OFFSET; gp.value = &radeonScreen->agp_buffer_offset; ret = drmCommandWriteRead( sPriv->fd, DRM_RADEON_GETPARAM, &gp, sizeof(gp)); if (ret) { FREE( radeonScreen ); fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_AGP_BUFFER_OFFSET): %d\n", ret); return NULL; } if (sPriv->drmMinor >= 6) { gp.param = RADEON_PARAM_IRQ_NR; gp.value = &radeonScreen->irq; ret = drmCommandWriteRead( sPriv->fd, DRM_RADEON_GETPARAM, &gp, sizeof(gp)); if (ret) { FREE( radeonScreen ); fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_IRQ_NR): %d\n", ret); return NULL; } } } radeonScreen->mmio.handle = radeonDRIPriv->registerHandle; radeonScreen->mmio.size = radeonDRIPriv->registerSize; if ( drmMap( sPriv->fd, radeonScreen->mmio.handle, radeonScreen->mmio.size, &radeonScreen->mmio.map ) ) { FREE( radeonScreen ); __driUtilMessage("radeonCreateScreen(): drmMap failed\n"); return NULL; } radeonScreen->status.handle = radeonDRIPriv->statusHandle; radeonScreen->status.size = radeonDRIPriv->statusSize; if ( drmMap( sPriv->fd, radeonScreen->status.handle, radeonScreen->status.size, &radeonScreen->status.map ) ) { drmUnmap( radeonScreen->mmio.map, radeonScreen->mmio.size ); FREE( radeonScreen ); __driUtilMessage("radeonCreateScreen(): drmMap (2) failed\n"); return NULL; } radeonScreen->scratch = (__volatile__ CARD32 *) ((GLubyte *)radeonScreen->status.map + RADEON_SCRATCH_REG_OFFSET); radeonScreen->buffers = drmMapBufs( sPriv->fd ); if ( !radeonScreen->buffers ) { drmUnmap( radeonScreen->status.map, radeonScreen->status.size ); drmUnmap( radeonScreen->mmio.map, radeonScreen->mmio.size ); FREE( radeonScreen ); __driUtilMessage("radeonCreateScreen(): drmMapBufs failed\n"); return NULL; } if ( !radeonScreen->IsPCI ) { radeonScreen->agpTextures.handle = radeonDRIPriv->agpTexHandle; radeonScreen->agpTextures.size = radeonDRIPriv->agpTexMapSize; if ( drmMap( sPriv->fd, radeonScreen->agpTextures.handle, radeonScreen->agpTextures.size, (drmAddressPtr)&radeonScreen->agpTextures.map ) ) { drmUnmapBufs( radeonScreen->buffers ); drmUnmap( radeonScreen->status.map, radeonScreen->status.size ); drmUnmap( radeonScreen->mmio.map, radeonScreen->mmio.size ); FREE( radeonScreen ); __driUtilMessage("radeonCreateScreen(): IsPCI failed\n"); return NULL; } } radeonScreen->chipset = 0; switch ( radeonDRIPriv->deviceID ) { default: fprintf(stderr, "unknown chip id, assuming full radeon support\n"); case PCI_CHIP_RADEON_QD: case PCI_CHIP_RADEON_QE: case PCI_CHIP_RADEON_QF: case PCI_CHIP_RADEON_QG: case PCI_CHIP_RV200_QW: case PCI_CHIP_RADEON_LW: radeonScreen->chipset |= RADEON_CHIPSET_TCL; case PCI_CHIP_RADEON_QY: case PCI_CHIP_RADEON_QZ: case PCI_CHIP_RADEON_LY: case PCI_CHIP_RADEON_LZ: break; } radeonScreen->cpp = radeonDRIPriv->bpp / 8; radeonScreen->AGPMode = radeonDRIPriv->AGPMode; radeonScreen->frontOffset = radeonDRIPriv->frontOffset; radeonScreen->frontPitch = radeonDRIPriv->frontPitch; radeonScreen->backOffset = radeonDRIPriv->backOffset; radeonScreen->backPitch = radeonDRIPriv->backPitch; radeonScreen->depthOffset = radeonDRIPriv->depthOffset; radeonScreen->depthPitch = radeonDRIPriv->depthPitch; radeonScreen->texOffset[RADEON_CARD_HEAP] = radeonDRIPriv->textureOffset; radeonScreen->texSize[RADEON_CARD_HEAP] = radeonDRIPriv->textureSize; radeonScreen->logTexGranularity[RADEON_CARD_HEAP] = radeonDRIPriv->log2TexGran; if ( radeonScreen->IsPCI ) { radeonScreen->numTexHeaps = RADEON_NR_TEX_HEAPS - 1; radeonScreen->texOffset[RADEON_AGP_HEAP] = 0; radeonScreen->texSize[RADEON_AGP_HEAP] = 0; radeonScreen->logTexGranularity[RADEON_AGP_HEAP] = 0; } else { radeonScreen->numTexHeaps = RADEON_NR_TEX_HEAPS; radeonScreen->texOffset[RADEON_AGP_HEAP] = radeonDRIPriv->agpTexOffset + RADEON_AGP_TEX_OFFSET; radeonScreen->texSize[RADEON_AGP_HEAP] = radeonDRIPriv->agpTexMapSize; radeonScreen->logTexGranularity[RADEON_AGP_HEAP] = radeonDRIPriv->log2AGPTexGran; } radeonScreen->driScreen = sPriv; radeonScreen->sarea_priv_offset = radeonDRIPriv->sarea_priv_offset; return radeonScreen; }
gammaScreenPtr gammaCreateScreen( __DRIscreenPrivate *sPriv ) { gammaScreenPtr gammaScreen; GLINTDRIPtr gDRIPriv = (GLINTDRIPtr)sPriv->pDevPriv; int i; if (sPriv->devPrivSize != sizeof(GLINTDRIRec)) { fprintf(stderr,"\nERROR! sizeof(GLINTDRIRec) does not match passed size from device driver\n"); return GL_FALSE; } #if 0 /* Check the DRI externsion version */ if ( sPriv->driMajor != 3 || sPriv->driMinor != 1 ) { __driUtilMessage( "Gamma DRI driver expected DRI version 4.0.x " "but got version %d.%d.%d", sPriv->driMajor, sPriv->driMinor, sPriv->driPatch ); return NULL; } /* Check that the DDX driver version is compatible */ if ( sPriv->ddxMajor != 4 || sPriv->ddxMinor != 0 || sPriv->ddxPatch < 0 ) { __driUtilMessage( "r128 DRI driver expected DDX driver version 4.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 != 2 || sPriv->drmMinor != 1 || sPriv->drmPatch < 0 ) { __driUtilMessage( "r128 DRI driver expected DRM driver version 2.1.x but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch ); return GL_FALSE; } #endif /* Allocate the private area */ gammaScreen = (gammaScreenPtr) CALLOC( sizeof(*gammaScreen) ); if ( !gammaScreen ) return NULL; gammaScreen->regionCount = 4; /* Magic number. Can we fix this? */ gammaScreen->regions = CALLOC(gammaScreen->regionCount * sizeof(gammaRegion)); gammaScreen->regions[0].handle = gDRIPriv->registers0.handle; gammaScreen->regions[0].size = gDRIPriv->registers0.size; gammaScreen->regions[1].handle = gDRIPriv->registers1.handle; gammaScreen->regions[1].size = gDRIPriv->registers1.size; gammaScreen->regions[2].handle = gDRIPriv->registers2.handle; gammaScreen->regions[2].size = gDRIPriv->registers2.size; gammaScreen->regions[3].handle = gDRIPriv->registers3.handle; gammaScreen->regions[3].size = gDRIPriv->registers3.size; /* Next, map all the regions */ for (i = 0; i < gammaScreen->regionCount; i++) { if (drmMap(sPriv->fd, gammaScreen->regions[i].handle, gammaScreen->regions[i].size, &gammaScreen->regions[i].map)) { while (--i > 0) { (void)drmUnmap(gammaScreen->regions[i].map, gammaScreen->regions[i].size); } return GL_FALSE; } } /* Get the list of dma buffers */ gammaScreen->bufs = drmMapBufs(sPriv->fd); if (!gammaScreen->bufs) { while (gammaScreen->regionCount > 0) { (void)drmUnmap(gammaScreen->regions[gammaScreen->regionCount].map, gammaScreen->regions[gammaScreen->regionCount].size); gammaScreen->regionCount--; } return GL_FALSE; } gammaScreen->textureSize = gDRIPriv->textureSize; gammaScreen->logTextureGranularity = gDRIPriv->logTextureGranularity; gammaScreen->cpp = gDRIPriv->cpp; gammaScreen->frontOffset = gDRIPriv->frontOffset; gammaScreen->frontPitch = gDRIPriv->frontPitch; gammaScreen->backOffset = gDRIPriv->backOffset; gammaScreen->backPitch = gDRIPriv->backPitch; gammaScreen->backX = gDRIPriv->backX; gammaScreen->backY = gDRIPriv->backY; gammaScreen->depthOffset = gDRIPriv->depthOffset; gammaScreen->depthPitch = gDRIPriv->depthPitch; gammaScreen->driScreen = sPriv; return gammaScreen; }
/* Create the device specific screen private data struct. */ static mach64ScreenRec * mach64CreateScreen( __DRIscreenPrivate *sPriv ) { mach64ScreenPtr mach64Screen; ATIDRIPtr serverInfo = (ATIDRIPtr)sPriv->pDevPriv; int i; if (sPriv->devPrivSize != sizeof(ATIDRIRec)) { fprintf(stderr,"\nERROR! sizeof(ATIDRIRec) does not match passed size from device driver\n"); return GL_FALSE; } if ( MACH64_DEBUG & DEBUG_VERBOSE_DRI ) fprintf( stderr, "%s\n", __FUNCTION__ ); /* Allocate the private area */ mach64Screen = (mach64ScreenPtr) CALLOC( sizeof(*mach64Screen) ); if ( !mach64Screen ) return NULL; /* parse information in __driConfigOptions */ driParseOptionInfo (&mach64Screen->optionCache, __driConfigOptions, __driNConfigOptions); mach64Screen->IsPCI = serverInfo->IsPCI; { drm_mach64_getparam_t gp; int ret; gp.param = MACH64_PARAM_IRQ_NR; gp.value = (void *) &mach64Screen->irq; ret = drmCommandWriteRead( sPriv->fd, DRM_MACH64_GETPARAM, &gp, sizeof(gp)); if (ret) { fprintf(stderr, "DRM_MACH64_GETPARAM (MACH64_PARAM_IRQ_NR): %d\n", ret); FREE( mach64Screen ); return NULL; } } mach64Screen->mmio.handle = serverInfo->regs; mach64Screen->mmio.size = serverInfo->regsSize; if ( drmMap( sPriv->fd, mach64Screen->mmio.handle, mach64Screen->mmio.size, (drmAddressPtr)&mach64Screen->mmio.map ) != 0 ) { FREE( mach64Screen ); return NULL; } mach64Screen->buffers = drmMapBufs( sPriv->fd ); if ( !mach64Screen->buffers ) { drmUnmap( (drmAddress)mach64Screen->mmio.map, mach64Screen->mmio.size ); FREE( mach64Screen ); return NULL; } if ( !mach64Screen->IsPCI ) { mach64Screen->agpTextures.handle = serverInfo->agp; mach64Screen->agpTextures.size = serverInfo->agpSize; if ( drmMap( sPriv->fd, mach64Screen->agpTextures.handle, mach64Screen->agpTextures.size, (drmAddressPtr)&mach64Screen->agpTextures.map ) ) { drmUnmapBufs( mach64Screen->buffers ); drmUnmap( (drmAddress)mach64Screen->mmio.map, mach64Screen->mmio.size ); FREE( mach64Screen ); return NULL; } } mach64Screen->AGPMode = serverInfo->AGPMode; mach64Screen->chipset = serverInfo->chipset; mach64Screen->width = serverInfo->width; mach64Screen->height = serverInfo->height; mach64Screen->mem = serverInfo->mem; mach64Screen->cpp = serverInfo->cpp; mach64Screen->frontOffset = serverInfo->frontOffset; mach64Screen->frontPitch = serverInfo->frontPitch; mach64Screen->backOffset = serverInfo->backOffset; mach64Screen->backPitch = serverInfo->backPitch; mach64Screen->depthOffset = serverInfo->depthOffset; mach64Screen->depthPitch = serverInfo->depthPitch; mach64Screen->texOffset[MACH64_CARD_HEAP] = serverInfo->textureOffset; mach64Screen->texSize[MACH64_CARD_HEAP] = serverInfo->textureSize; mach64Screen->logTexGranularity[MACH64_CARD_HEAP] = serverInfo->logTextureGranularity; if ( mach64Screen->IsPCI ) { mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS - 1; mach64Screen->firstTexHeap = MACH64_CARD_HEAP; mach64Screen->texOffset[MACH64_AGP_HEAP] = 0; mach64Screen->texSize[MACH64_AGP_HEAP] = 0; mach64Screen->logTexGranularity[MACH64_AGP_HEAP] = 0; } else { if (serverInfo->textureSize > 0) { mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS; mach64Screen->firstTexHeap = MACH64_CARD_HEAP; } else { mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS - 1; mach64Screen->firstTexHeap = MACH64_AGP_HEAP; } mach64Screen->texOffset[MACH64_AGP_HEAP] = serverInfo->agpTextureOffset; mach64Screen->texSize[MACH64_AGP_HEAP] = serverInfo->agpSize; mach64Screen->logTexGranularity[MACH64_AGP_HEAP] = serverInfo->logAgpTextureGranularity; } mach64Screen->driScreen = sPriv; i = 0; mach64Screen->extensions[i++] = &driFrameTrackingExtension.base; if ( mach64Screen->irq != 0 ) { mach64Screen->extensions[i++] = &driSwapControlExtension.base; mach64Screen->extensions[i++] = &driMediaStreamCounterExtension.base; } mach64Screen->extensions[i++] = NULL; sPriv->extensions = mach64Screen->extensions; return mach64Screen; }
/* Create the device specific screen private data struct. */ static r128ScreenPtr r128CreateScreen( __DRIscreen *sPriv ) { r128ScreenPtr r128Screen; R128DRIPtr r128DRIPriv = (R128DRIPtr)sPriv->pDevPriv; int i; if (sPriv->devPrivSize != sizeof(R128DRIRec)) { fprintf(stderr,"\nERROR! sizeof(R128DRIRec) does not match passed size from device driver\n"); return GL_FALSE; } /* Allocate the private area */ r128Screen = (r128ScreenPtr) CALLOC( sizeof(*r128Screen) ); if ( !r128Screen ) return NULL; /* parse information in __driConfigOptions */ driParseOptionInfo (&r128Screen->optionCache, __driConfigOptions, __driNConfigOptions); /* This is first since which regions we map depends on whether or * not we are using a PCI card. */ r128Screen->IsPCI = r128DRIPriv->IsPCI; r128Screen->sarea_priv_offset = r128DRIPriv->sarea_priv_offset; if (sPriv->drm_version.minor >= 3) { drm_r128_getparam_t gp; int ret; gp.param = R128_PARAM_IRQ_NR; gp.value = &r128Screen->irq; ret = drmCommandWriteRead( sPriv->fd, DRM_R128_GETPARAM, &gp, sizeof(gp)); if (ret) { fprintf(stderr, "drmR128GetParam (R128_PARAM_IRQ_NR): %d\n", ret); FREE( r128Screen ); return NULL; } } r128Screen->mmio.handle = r128DRIPriv->registerHandle; r128Screen->mmio.size = r128DRIPriv->registerSize; if ( drmMap( sPriv->fd, r128Screen->mmio.handle, r128Screen->mmio.size, (drmAddressPtr)&r128Screen->mmio.map ) ) { FREE( r128Screen ); return NULL; } r128Screen->buffers = drmMapBufs( sPriv->fd ); if ( !r128Screen->buffers ) { drmUnmap( (drmAddress)r128Screen->mmio.map, r128Screen->mmio.size ); FREE( r128Screen ); return NULL; } if ( !r128Screen->IsPCI ) { r128Screen->agpTextures.handle = r128DRIPriv->agpTexHandle; r128Screen->agpTextures.size = r128DRIPriv->agpTexMapSize; if ( drmMap( sPriv->fd, r128Screen->agpTextures.handle, r128Screen->agpTextures.size, (drmAddressPtr)&r128Screen->agpTextures.map ) ) { drmUnmapBufs( r128Screen->buffers ); drmUnmap( (drmAddress)r128Screen->mmio.map, r128Screen->mmio.size ); FREE( r128Screen ); return NULL; } } switch ( r128DRIPriv->deviceID ) { case PCI_CHIP_RAGE128RE: case PCI_CHIP_RAGE128RF: case PCI_CHIP_RAGE128RK: case PCI_CHIP_RAGE128RL: r128Screen->chipset = R128_CARD_TYPE_R128; break; case PCI_CHIP_RAGE128PF: r128Screen->chipset = R128_CARD_TYPE_R128_PRO; break; case PCI_CHIP_RAGE128LE: case PCI_CHIP_RAGE128LF: r128Screen->chipset = R128_CARD_TYPE_R128_MOBILITY; break; default: r128Screen->chipset = R128_CARD_TYPE_R128; break; } r128Screen->cpp = r128DRIPriv->bpp / 8; r128Screen->AGPMode = r128DRIPriv->AGPMode; r128Screen->frontOffset = r128DRIPriv->frontOffset; r128Screen->frontPitch = r128DRIPriv->frontPitch; r128Screen->backOffset = r128DRIPriv->backOffset; r128Screen->backPitch = r128DRIPriv->backPitch; r128Screen->depthOffset = r128DRIPriv->depthOffset; r128Screen->depthPitch = r128DRIPriv->depthPitch; r128Screen->spanOffset = r128DRIPriv->spanOffset; if ( r128DRIPriv->textureSize == 0 ) { r128Screen->texOffset[R128_LOCAL_TEX_HEAP] = r128DRIPriv->agpTexOffset + R128_AGP_TEX_OFFSET; r128Screen->texSize[R128_LOCAL_TEX_HEAP] = r128DRIPriv->agpTexMapSize; r128Screen->logTexGranularity[R128_LOCAL_TEX_HEAP] = r128DRIPriv->log2AGPTexGran; } else { r128Screen->texOffset[R128_LOCAL_TEX_HEAP] = r128DRIPriv->textureOffset; r128Screen->texSize[R128_LOCAL_TEX_HEAP] = r128DRIPriv->textureSize; r128Screen->logTexGranularity[R128_LOCAL_TEX_HEAP] = r128DRIPriv->log2TexGran; } if ( !r128Screen->agpTextures.map || r128DRIPriv->textureSize == 0 ) { r128Screen->numTexHeaps = R128_NR_TEX_HEAPS - 1; r128Screen->texOffset[R128_AGP_TEX_HEAP] = 0; r128Screen->texSize[R128_AGP_TEX_HEAP] = 0; r128Screen->logTexGranularity[R128_AGP_TEX_HEAP] = 0; } else { r128Screen->numTexHeaps = R128_NR_TEX_HEAPS; r128Screen->texOffset[R128_AGP_TEX_HEAP] = r128DRIPriv->agpTexOffset + R128_AGP_TEX_OFFSET; r128Screen->texSize[R128_AGP_TEX_HEAP] = r128DRIPriv->agpTexMapSize; r128Screen->logTexGranularity[R128_AGP_TEX_HEAP] = r128DRIPriv->log2AGPTexGran; } r128Screen->driScreen = sPriv; i = 0; r128Screen->extensions[i++] = &driFrameTrackingExtension.base; if ( r128Screen->irq != 0 ) { r128Screen->extensions[i++] = &driSwapControlExtension.base; r128Screen->extensions[i++] = &driMediaStreamCounterExtension.base; } r128Screen->extensions[i++] = NULL; sPriv->extensions = r128Screen->extensions; return r128Screen; }
/* Create the device specific screen private data struct. */ static r128ScreenPtr r128CreateScreen( __DRIscreenPrivate *sPriv ) { r128ScreenPtr r128Screen; R128DRIPtr r128DRIPriv = (R128DRIPtr)sPriv->pDevPriv; PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension = (PFNGLXSCRENABLEEXTENSIONPROC) (*dri_interface->getProcAddress("glxEnableExtension")); void * const psc = sPriv->psc->screenConfigs; if (sPriv->devPrivSize != sizeof(R128DRIRec)) { fprintf(stderr,"\nERROR! sizeof(R128DRIRec) does not match passed size from device driver\n"); return GL_FALSE; } /* Allocate the private area */ r128Screen = (r128ScreenPtr) CALLOC( sizeof(*r128Screen) ); if ( !r128Screen ) return NULL; /* parse information in __driConfigOptions */ driParseOptionInfo (&r128Screen->optionCache, __driConfigOptions, __driNConfigOptions); /* This is first since which regions we map depends on whether or * not we are using a PCI card. */ r128Screen->IsPCI = r128DRIPriv->IsPCI; r128Screen->sarea_priv_offset = r128DRIPriv->sarea_priv_offset; if (sPriv->drmMinor >= 3) { drm_r128_getparam_t gp; int ret; gp.param = R128_PARAM_IRQ_NR; gp.value = &r128Screen->irq; ret = drmCommandWriteRead( sPriv->fd, DRM_R128_GETPARAM, &gp, sizeof(gp)); if (ret) { fprintf(stderr, "drmR128GetParam (R128_PARAM_IRQ_NR): %d\n", ret); FREE( r128Screen ); return NULL; } } r128Screen->mmio.handle = r128DRIPriv->registerHandle; r128Screen->mmio.size = r128DRIPriv->registerSize; if ( drmMap( sPriv->fd, r128Screen->mmio.handle, r128Screen->mmio.size, (drmAddressPtr)&r128Screen->mmio.map ) ) { FREE( r128Screen ); return NULL; } r128Screen->buffers = drmMapBufs( sPriv->fd ); if ( !r128Screen->buffers ) { drmUnmap( (drmAddress)r128Screen->mmio.map, r128Screen->mmio.size ); FREE( r128Screen ); return NULL; } if ( !r128Screen->IsPCI ) { r128Screen->agpTextures.handle = r128DRIPriv->agpTexHandle; r128Screen->agpTextures.size = r128DRIPriv->agpTexMapSize; if ( drmMap( sPriv->fd, r128Screen->agpTextures.handle, r128Screen->agpTextures.size, (drmAddressPtr)&r128Screen->agpTextures.map ) ) { drmUnmapBufs( r128Screen->buffers ); drmUnmap( (drmAddress)r128Screen->mmio.map, r128Screen->mmio.size ); FREE( r128Screen ); return NULL; } } switch ( r128DRIPriv->deviceID ) { case PCI_CHIP_RAGE128RE: case PCI_CHIP_RAGE128RF: case PCI_CHIP_RAGE128RK: case PCI_CHIP_RAGE128RL: r128Screen->chipset = R128_CARD_TYPE_R128; break; case PCI_CHIP_RAGE128PF: r128Screen->chipset = R128_CARD_TYPE_R128_PRO; break; case PCI_CHIP_RAGE128LE: case PCI_CHIP_RAGE128LF: r128Screen->chipset = R128_CARD_TYPE_R128_MOBILITY; break; default: r128Screen->chipset = R128_CARD_TYPE_R128; break; } r128Screen->cpp = r128DRIPriv->bpp / 8; r128Screen->AGPMode = r128DRIPriv->AGPMode; r128Screen->frontOffset = r128DRIPriv->frontOffset; r128Screen->frontPitch = r128DRIPriv->frontPitch; r128Screen->backOffset = r128DRIPriv->backOffset; r128Screen->backPitch = r128DRIPriv->backPitch; r128Screen->depthOffset = r128DRIPriv->depthOffset; r128Screen->depthPitch = r128DRIPriv->depthPitch; r128Screen->spanOffset = r128DRIPriv->spanOffset; if ( r128DRIPriv->textureSize == 0 ) { r128Screen->texOffset[R128_LOCAL_TEX_HEAP] = r128DRIPriv->agpTexOffset + R128_AGP_TEX_OFFSET; r128Screen->texSize[R128_LOCAL_TEX_HEAP] = r128DRIPriv->agpTexMapSize; r128Screen->logTexGranularity[R128_LOCAL_TEX_HEAP] = r128DRIPriv->log2AGPTexGran; } else { r128Screen->texOffset[R128_LOCAL_TEX_HEAP] = r128DRIPriv->textureOffset; r128Screen->texSize[R128_LOCAL_TEX_HEAP] = r128DRIPriv->textureSize; r128Screen->logTexGranularity[R128_LOCAL_TEX_HEAP] = r128DRIPriv->log2TexGran; } if ( !r128Screen->agpTextures.map || r128DRIPriv->textureSize == 0 ) { r128Screen->numTexHeaps = R128_NR_TEX_HEAPS - 1; r128Screen->texOffset[R128_AGP_TEX_HEAP] = 0; r128Screen->texSize[R128_AGP_TEX_HEAP] = 0; r128Screen->logTexGranularity[R128_AGP_TEX_HEAP] = 0; } else { r128Screen->numTexHeaps = R128_NR_TEX_HEAPS; r128Screen->texOffset[R128_AGP_TEX_HEAP] = r128DRIPriv->agpTexOffset + R128_AGP_TEX_OFFSET; r128Screen->texSize[R128_AGP_TEX_HEAP] = r128DRIPriv->agpTexMapSize; r128Screen->logTexGranularity[R128_AGP_TEX_HEAP] = r128DRIPriv->log2AGPTexGran; } r128Screen->driScreen = sPriv; if ( glx_enable_extension != NULL ) { if ( r128Screen->irq != 0 ) { (*glx_enable_extension)( psc, "GLX_SGI_swap_control" ); (*glx_enable_extension)( psc, "GLX_SGI_video_sync" ); (*glx_enable_extension)( psc, "GLX_MESA_swap_control" ); } (*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" ); } return r128Screen; }
static struct intel_region * intel_recreate_static(struct intel_context *intel, const char *name, struct intel_region *region, intelRegion *region_desc) { intelScreenPrivate *intelScreen = intel->intelScreen; int ret; if (region == NULL) { region = calloc(sizeof(*region), 1); region->refcount = 1; } if (intel->ctx.Visual.rgbBits == 24) region->cpp = 4; else region->cpp = intel->ctx.Visual.rgbBits / 8; region->pitch = intelScreen->pitch; region->width = intelScreen->width; region->height = intelScreen->height; if (region->buffer != NULL) { dri_bo_unreference(region->buffer); region->buffer = NULL; } if (intel->ttm) { assert(region_desc->bo_handle != -1); region->buffer = intel_bo_gem_create_from_name(intel->bufmgr, name, region_desc->bo_handle); ret = dri_bo_get_tiling(region->buffer, ®ion->tiling, ®ion->bit_6_swizzle); if (ret != 0) { fprintf(stderr, "Couldn't get tiling of buffer %d (%s): %s\n", region_desc->bo_handle, name, strerror(-ret)); intel_region_release(®ion); return NULL; } } else { if (region->classic_map != NULL) { drmUnmap(region->classic_map, region->pitch * region->cpp * region->height); region->classic_map = NULL; } ret = drmMap(intel->driFd, region_desc->handle, region->pitch * region->cpp * region->height, ®ion->classic_map); if (ret != 0) { fprintf(stderr, "Failed to drmMap %s buffer\n", name); free(region); return NULL; } region->buffer = intel_bo_fake_alloc_static(intel->bufmgr, name, region_desc->offset, region->pitch * region->cpp * region->height, region->classic_map); /* The sarea just gives us a boolean for whether it's tiled or not, * instead of which tiling mode it is. Guess. */ if (region_desc->tiled) { if (IS_965(intel->intelScreen->deviceID) && region_desc == &intelScreen->depth) region->tiling = I915_TILING_Y; else region->tiling = I915_TILING_X; } else { region->tiling = I915_TILING_NONE; } region->bit_6_swizzle = I915_BIT_6_SWIZZLE_NONE; } assert(region->buffer != NULL); return region; }
Bool isDRI1Connected(VADriverContextP ctx, char **driver_name) { struct dri_state *dri_state = (struct dri_state *)ctx->drm_state; int direct_capable; int driver_major; int driver_minor; int driver_patch; int newlyopened; char *BusID; drm_magic_t magic; *driver_name = NULL; dri_state->base.fd = -1; dri_state->pSAREA = MAP_FAILED; dri_state->base.auth_type = VA_NONE; if (!VA_DRIQueryDirectRenderingCapable(ctx->native_dpy, ctx->x11_screen, &direct_capable)) goto err_out0; if (!direct_capable) goto err_out0; if (!VA_DRIGetClientDriverName(ctx->native_dpy, ctx->x11_screen, &driver_major, &driver_minor, &driver_patch, driver_name)) goto err_out0; if (!VA_DRIOpenConnection(ctx->native_dpy, ctx->x11_screen, &dri_state->hSAREA, &BusID)) goto err_out0; dri_state->base.fd = drmOpenOnce(NULL, BusID, &newlyopened); XFree(BusID); if (dri_state->base.fd < 0) goto err_out1; if (drmGetMagic(dri_state->base.fd, &magic)) goto err_out1; if (newlyopened && !VA_DRIAuthConnection(ctx->native_dpy, ctx->x11_screen, magic)) goto err_out1; if (drmMap(dri_state->base.fd, dri_state->hSAREA, SAREA_MAX, &dri_state->pSAREA)) goto err_out1; if (!VA_DRICreateContext(ctx->native_dpy, ctx->x11_screen, DefaultVisual(ctx->native_dpy, ctx->x11_screen), &dri_state->hwContextID, &dri_state->hwContext)) goto err_out1; dri_state->base.auth_type = VA_DRI1; dri_state->createDrawable = dri1CreateDrawable; dri_state->destroyDrawable = dri1DestroyDrawable; dri_state->swapBuffer = dri1SwapBuffer; dri_state->getRenderingBuffer = dri1GetRenderingBuffer; dri_state->close = dri1Close; return True; err_out1: if (dri_state->pSAREA != MAP_FAILED) drmUnmap(dri_state->pSAREA, SAREA_MAX); if (dri_state->base.fd >= 0) drmCloseOnce(dri_state->base.fd); VA_DRICloseConnection(ctx->native_dpy, ctx->x11_screen); err_out0: if (*driver_name) XFree(*driver_name); dri_state->pSAREA = MAP_FAILED; dri_state->base.fd = -1; *driver_name = NULL; return False; }