/* Create the device specific screen private data struct. */ static sisScreenPtr sisCreateScreen( __DRIscreenPrivate *sPriv ) { sisScreenPtr sisScreen; SISDRIPtr sisDRIPriv = (SISDRIPtr)sPriv->pDevPriv; #ifndef USE_NEW_INTERFACE /* XXX Should this still be around for the old interface? */ if ( !driCheckDriDdxDrmVersions( sPriv, "SiS", 4, 0, 0, 1, 1, 0 ) ) return NULL; #endif /* Allocate the private area */ sisScreen = (sisScreenPtr)CALLOC( sizeof(*sisScreen) ); if ( sisScreen == NULL ) return NULL; sisScreen->screenX = sisDRIPriv->width; sisScreen->screenY = sisDRIPriv->height; sisScreen->cpp = sisDRIPriv->bytesPerPixel; sisScreen->irqEnabled = sisDRIPriv->bytesPerPixel; sisScreen->deviceID = sisDRIPriv->deviceID; sisScreen->AGPCmdBufOffset = sisDRIPriv->AGPCmdBufOffset; sisScreen->AGPCmdBufSize = sisDRIPriv->AGPCmdBufSize; sisScreen->sarea_priv_offset = sizeof(drm_sarea_t); sisScreen->mmio.handle = sisDRIPriv->regs.handle; sisScreen->mmio.size = sisDRIPriv->regs.size; if ( drmMap( sPriv->fd, sisScreen->mmio.handle, sisScreen->mmio.size, &sisScreen->mmio.map ) ) { FREE( sisScreen ); return NULL; } if (sisDRIPriv->agp.size) { sisScreen->agp.handle = sisDRIPriv->agp.handle; sisScreen->agp.size = sisDRIPriv->agp.size; if ( drmMap( sPriv->fd, sisScreen->agp.handle, sisScreen->agp.size, &sisScreen->agp.map ) ) { sisScreen->agp.size = 0; } } sisScreen->driScreen = sPriv; /* parse information in __driConfigOptions */ driParseOptionInfo(&sisScreen->optionCache, __driConfigOptions, __driNConfigOptions); return sisScreen; }
/** * DRI2 */ static __DRIscreen * dri2CreateNewScreen(int scrn, int fd, const __DRIextension **extensions, const __DRIconfig ***driver_configs, void *data) { static const __DRIextension *emptyExtensionList[] = { NULL }; __DRIscreen *psp; drmVersionPtr version; if (driDriverAPI.InitScreen2 == NULL) return NULL; psp = calloc(1, sizeof(*psp)); if (!psp) return NULL; setupLoaderExtensions(psp, extensions); version = drmGetVersion(fd); if (version) { psp->drm_version.major = version->version_major; psp->drm_version.minor = version->version_minor; psp->drm_version.patch = version->version_patchlevel; drmFreeVersion(version); } psp->extensions = emptyExtensionList; psp->fd = fd; psp->myNum = scrn; psp->dri2.enabled = GL_TRUE; psp->DriverAPI = driDriverAPI; psp->api_mask = (1 << __DRI_API_OPENGL); *driver_configs = driDriverAPI.InitScreen2(psp); if (*driver_configs == NULL) { free(psp); return NULL; } psp->DriverAPI = driDriverAPI; psp->loaderPrivate = data; driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions, __dri2NConfigOptions); driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum, "dri2"); return psp; }
static char *loader_get_dri_config_device_id(void) { driOptionCache defaultInitOptions; driOptionCache userInitOptions; char *prime = NULL; driParseOptionInfo(&defaultInitOptions, __driConfigOptionsLoader); driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, "loader"); if (driCheckOption(&userInitOptions, "device_id", DRI_STRING)) prime = strdup(driQueryOptionstr(&userInitOptions, "device_id")); driDestroyOptionCache(&userInitOptions); driDestroyOptionInfo(&defaultInitOptions); return prime; }
/** * This is the first entrypoint in the driver called by the DRI driver loader * after dlopen()ing it. * * It's used to create global state for the driver across contexts on the same * Display. */ static __DRIscreen * driCreateNewScreen2(int scrn, int fd, const __DRIextension **extensions, const __DRIextension **driver_extensions, const __DRIconfig ***driver_configs, void *data) { static const __DRIextension *emptyExtensionList[] = { NULL }; __DRIscreen *psp; psp = calloc(1, sizeof(*psp)); if (!psp) return NULL; /* By default, use the global driDriverAPI symbol (non-megadrivers). */ psp->driver = globalDriverAPI; /* If the driver exposes its vtable through its extensions list * (megadrivers), use that instead. */ if (driver_extensions) { for (int i = 0; driver_extensions[i]; i++) { if (strcmp(driver_extensions[i]->name, __DRI_DRIVER_VTABLE) == 0) { psp->driver = ((__DRIDriverVtableExtension *)driver_extensions[i])->vtable; } } } setupLoaderExtensions(psp, extensions); psp->loaderPrivate = data; psp->extensions = emptyExtensionList; psp->fd = fd; psp->myNum = scrn; *driver_configs = psp->driver->InitScreen(psp); if (*driver_configs == NULL) { free(psp); return NULL; } struct gl_constants consts = { 0 }; gl_api api; unsigned version; api = API_OPENGLES2; if (_mesa_override_gl_version_contextless(&consts, &api, &version)) psp->max_gl_es2_version = version; api = API_OPENGL_COMPAT; if (_mesa_override_gl_version_contextless(&consts, &api, &version)) { if (api == API_OPENGL_CORE) { psp->max_gl_core_version = version; } else { psp->max_gl_compat_version = version; } } psp->api_mask = 0; if (psp->max_gl_compat_version > 0) psp->api_mask |= (1 << __DRI_API_OPENGL); if (psp->max_gl_core_version > 0) psp->api_mask |= (1 << __DRI_API_OPENGL_CORE); if (psp->max_gl_es1_version > 0) psp->api_mask |= (1 << __DRI_API_GLES); if (psp->max_gl_es2_version > 0) psp->api_mask |= (1 << __DRI_API_GLES2); if (psp->max_gl_es2_version >= 30) psp->api_mask |= (1 << __DRI_API_GLES3); driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions); driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum, "dri2"); return psp; }
static HRESULT WINAPI drm_create_adapter( int fd, ID3DAdapter9 **ppAdapter ) { struct d3dadapter9drm_context *ctx = CALLOC_STRUCT(d3dadapter9drm_context); HRESULT hr; int i, different_device; const struct drm_conf_ret *throttle_ret = NULL; const struct drm_conf_ret *dmabuf_ret = NULL; driOptionCache defaultInitOptions; driOptionCache userInitOptions; int throttling_value_user = -2; #if !GALLIUM_STATIC_TARGETS const char *paths[] = { getenv("D3D9_DRIVERS_PATH"), getenv("D3D9_DRIVERS_DIR"), PIPE_SEARCH_DIR }; #endif if (!ctx) { return E_OUTOFMEMORY; } ctx->base.destroy = drm_destroy; fd = loader_get_user_preferred_fd(fd, &different_device); ctx->fd = fd; ctx->base.linear_framebuffer = !!different_device; #if GALLIUM_STATIC_TARGETS ctx->base.hal = dd_create_screen(fd); #else /* use pipe-loader to dlopen appropriate drm driver */ if (!pipe_loader_drm_probe_fd(&ctx->dev, fd, FALSE)) { ERR("Failed to probe drm fd %d.\n", fd); FREE(ctx); close(fd); return D3DERR_DRIVERINTERNALERROR; } /* use pipe-loader to create a drm screen (hal) */ ctx->base.hal = NULL; for (i = 0; !ctx->base.hal && i < Elements(paths); ++i) { if (!paths[i]) { continue; } ctx->base.hal = pipe_loader_create_screen(ctx->dev, paths[i]); } #endif if (!ctx->base.hal) { ERR("Unable to load requested driver.\n"); drm_destroy(&ctx->base); return D3DERR_DRIVERINTERNALERROR; } #if GALLIUM_STATIC_TARGETS dmabuf_ret = dd_configuration(DRM_CONF_SHARE_FD); throttle_ret = dd_configuration(DRM_CONF_THROTTLE); #else dmabuf_ret = pipe_loader_configuration(ctx->dev, DRM_CONF_SHARE_FD); throttle_ret = pipe_loader_configuration(ctx->dev, DRM_CONF_THROTTLE); #endif // GALLIUM_STATIC_TARGETS if (!dmabuf_ret || !dmabuf_ret->val.val_bool) { ERR("The driver is not capable of dma-buf sharing." "Abandon to load nine state tracker\n"); drm_destroy(&ctx->base); return D3DERR_DRIVERINTERNALERROR; } if (throttle_ret && throttle_ret->val.val_int != -1) { ctx->base.throttling = TRUE; ctx->base.throttling_value = throttle_ret->val.val_int; } else ctx->base.throttling = FALSE; driParseOptionInfo(&defaultInitOptions, __driConfigOptionsNine); driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, "nine"); if (driCheckOption(&userInitOptions, "throttle_value", DRI_INT)) { throttling_value_user = driQueryOptioni(&userInitOptions, "throttle_value"); if (throttling_value_user == -1) ctx->base.throttling = FALSE; else if (throttling_value_user >= 0) { ctx->base.throttling = TRUE; ctx->base.throttling_value = throttling_value_user; } } if (driCheckOption(&userInitOptions, "vblank_mode", DRI_ENUM)) ctx->base.vblank_mode = driQueryOptioni(&userInitOptions, "vblank_mode"); else ctx->base.vblank_mode = 1; if (driCheckOption(&userInitOptions, "thread_submit", DRI_BOOL)) { ctx->base.thread_submit = driQueryOptionb(&userInitOptions, "thread_submit"); if (ctx->base.thread_submit && (throttling_value_user == -2 || throttling_value_user == 0)) { ctx->base.throttling_value = 0; } else if (ctx->base.thread_submit) { DBG("You have set a non standard throttling value in combination with thread_submit." "We advise to use a throttling value of -2/0"); } if (ctx->base.thread_submit && !different_device) DBG("You have set thread_submit but do not use a different device than the server." "You should not expect any benefit."); } driDestroyOptionCache(&userInitOptions); driDestroyOptionInfo(&defaultInitOptions); #if GALLIUM_STATIC_TARGETS ctx->base.ref = ninesw_create_screen(ctx->base.hal); #else /* wrap it to create a software screen that can share resources */ if (pipe_loader_sw_probe_wrapped(&ctx->swdev, ctx->base.hal)) { ctx->base.ref = NULL; for (i = 0; !ctx->base.ref && i < Elements(paths); ++i) { if (!paths[i]) { continue; } ctx->base.ref = pipe_loader_create_screen(ctx->swdev, paths[i]); } } #endif if (!ctx->base.ref) { ERR("Couldn't wrap drm screen to swrast screen. Software devices " "will be unavailable.\n"); } /* read out PCI info */ read_descriptor(&ctx->base, fd); /* create and return new ID3DAdapter9 */ hr = NineAdapter9_new(&ctx->base, (struct NineAdapter9 **)ppAdapter); if (FAILED(hr)) { drm_destroy(&ctx->base); return hr; } return D3D_OK; }
static radeonScreenPtr radeonCreateScreen2(__DRIscreen *sPriv) { radeonScreenPtr screen; int i; int ret; uint32_t device_id = 0; /* Allocate the private area */ screen = calloc(1, sizeof(*screen)); if ( !screen ) { fprintf(stderr, "%s: Could not allocate memory for screen structure", __FUNCTION__); fprintf(stderr, "leaving here\n"); return NULL; } radeon_init_debug(); /* parse information in __driConfigOptions */ driParseOptionInfo (&screen->optionCache, radeon_config_options.xml); screen->chip_flags = 0; screen->irq = 1; ret = radeonGetParam(sPriv, RADEON_PARAM_DEVICE_ID, &device_id); if (ret) { free( screen ); fprintf(stderr, "drm_radeon_getparam_t (RADEON_PARAM_DEVICE_ID): %d\n", ret); return NULL; } ret = radeon_set_screen_flags(screen, device_id); if (ret == -1) { free(screen); return NULL; } if (getenv("RADEON_NO_TCL")) screen->chip_flags &= ~RADEON_CHIPSET_TCL; i = 0; screen->extensions[i++] = &dri2ConfigQueryExtension.base; #if defined(RADEON_R100) screen->extensions[i++] = &radeonTexBufferExtension.base; #elif defined(RADEON_R200) screen->extensions[i++] = &r200TexBufferExtension.base; #endif screen->extensions[i++] = &radeonFlushExtension.base; screen->extensions[i++] = &radeonImageExtension.base; screen->extensions[i++] = NULL; sPriv->extensions = screen->extensions; screen->driScreen = sPriv; screen->bom = radeon_bo_manager_gem_ctor(sPriv->fd); if (screen->bom == NULL) { free(screen); return NULL; } return screen; }
/** * This is the first entrypoint in the driver called by the DRI driver loader * after dlopen()ing it. * * It's used to create global state for the driver across contexts on the same * Display. */ static __DRIscreen * driCreateNewScreen2(int scrn, int fd, const __DRIextension **extensions, const __DRIextension **driver_extensions, const __DRIconfig ***driver_configs, void *data) { static const __DRIextension *emptyExtensionList[] = { NULL }; __DRIscreen *psp; psp = calloc(1, sizeof(*psp)); if (!psp) return NULL; /* By default, use the global driDriverAPI symbol (non-megadrivers). */ psp->driver = globalDriverAPI; /* If the driver exposes its vtable through its extensions list * (megadrivers), use that instead. */ if (driver_extensions) { for (int i = 0; driver_extensions[i]; i++) { if (strcmp(driver_extensions[i]->name, __DRI_DRIVER_VTABLE) == 0) { psp->driver = ((__DRIDriverVtableExtension *)driver_extensions[i])->vtable; } } } setupLoaderExtensions(psp, extensions); #ifndef __NOT_HAVE_DRM_H if (fd != -1) { drmVersionPtr version = drmGetVersion(fd); if (version) { psp->drm_version.major = version->version_major; psp->drm_version.minor = version->version_minor; psp->drm_version.patch = version->version_patchlevel; drmFreeVersion(version); } } #endif psp->loaderPrivate = data; psp->extensions = emptyExtensionList; psp->fd = fd; psp->myNum = scrn; *driver_configs = psp->driver->InitScreen(psp); if (*driver_configs == NULL) { free(psp); return NULL; } int gl_version_override = _mesa_get_gl_version_override(); if (gl_version_override >= 31) { psp->max_gl_core_version = MAX2(psp->max_gl_core_version, gl_version_override); } else { psp->max_gl_compat_version = MAX2(psp->max_gl_compat_version, gl_version_override); } psp->api_mask = (1 << __DRI_API_OPENGL); if (psp->max_gl_core_version > 0) psp->api_mask |= (1 << __DRI_API_OPENGL_CORE); if (psp->max_gl_es1_version > 0) psp->api_mask |= (1 << __DRI_API_GLES); if (psp->max_gl_es2_version > 0) psp->api_mask |= (1 << __DRI_API_GLES2); if (psp->max_gl_es2_version >= 30) psp->api_mask |= (1 << __DRI_API_GLES3); driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions); driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum, "dri2"); return psp; }
/* 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; }
static HRESULT WINAPI drm_create_adapter( int fd, ID3DAdapter9 **ppAdapter ) { struct d3dadapter9drm_context *ctx = CALLOC_STRUCT(d3dadapter9drm_context); HRESULT hr; bool different_device; driOptionCache defaultInitOptions; driOptionCache userInitOptions; int throttling_value_user = -2; int override_vendorid = -1; if (!ctx) { return E_OUTOFMEMORY; } ctx->base.destroy = drm_destroy; /* Although the fd is provided from external source, mesa/nine * takes ownership of it. */ fd = loader_get_user_preferred_fd(fd, &different_device); ctx->fd = fd; ctx->base.linear_framebuffer = different_device; if (!pipe_loader_drm_probe_fd(&ctx->dev, fd)) { ERR("Failed to probe drm fd %d.\n", fd); FREE(ctx); close(fd); return D3DERR_DRIVERINTERNALERROR; } ctx->base.hal = pipe_loader_create_screen(ctx->dev); if (!ctx->base.hal) { ERR("Unable to load requested driver.\n"); drm_destroy(&ctx->base); return D3DERR_DRIVERINTERNALERROR; } if (!ctx->base.hal->get_param(ctx->base.hal, PIPE_CAP_DMABUF)) { ERR("The driver is not capable of dma-buf sharing." "Abandon to load nine state tracker\n"); drm_destroy(&ctx->base); return D3DERR_DRIVERINTERNALERROR; } /* Previously was set to PIPE_CAP_MAX_FRAMES_IN_FLIGHT, * but the change of value of this cap to 1 seems to cause * regressions. */ ctx->base.throttling_value = 2; ctx->base.throttling = ctx->base.throttling_value > 0; driParseOptionInfo(&defaultInitOptions, __driConfigOptionsNine); driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, "nine", NULL); if (driCheckOption(&userInitOptions, "throttle_value", DRI_INT)) { throttling_value_user = driQueryOptioni(&userInitOptions, "throttle_value"); if (throttling_value_user == -1) ctx->base.throttling = FALSE; else if (throttling_value_user >= 0) { ctx->base.throttling = TRUE; ctx->base.throttling_value = throttling_value_user; } } if (driCheckOption(&userInitOptions, "vblank_mode", DRI_ENUM)) ctx->base.vblank_mode = driQueryOptioni(&userInitOptions, "vblank_mode"); else ctx->base.vblank_mode = 1; if (driCheckOption(&userInitOptions, "thread_submit", DRI_BOOL)) ctx->base.thread_submit = driQueryOptionb(&userInitOptions, "thread_submit"); else ctx->base.thread_submit = different_device; if (driCheckOption(&userInitOptions, "override_vendorid", DRI_INT)) { override_vendorid = driQueryOptioni(&userInitOptions, "override_vendorid"); } if (driCheckOption(&userInitOptions, "discard_delayed_release", DRI_BOOL)) ctx->base.discard_delayed_release = driQueryOptionb(&userInitOptions, "discard_delayed_release"); else ctx->base.discard_delayed_release = TRUE; if (driCheckOption(&userInitOptions, "tearfree_discard", DRI_BOOL)) ctx->base.tearfree_discard = driQueryOptionb(&userInitOptions, "tearfree_discard"); else ctx->base.tearfree_discard = FALSE; if (ctx->base.tearfree_discard && !ctx->base.discard_delayed_release) { ERR("tearfree_discard requires discard_delayed_release\n"); ctx->base.tearfree_discard = FALSE; } if (driCheckOption(&userInitOptions, "csmt_force", DRI_INT)) ctx->base.csmt_force = driQueryOptioni(&userInitOptions, "csmt_force"); else ctx->base.csmt_force = -1; if (driCheckOption(&userInitOptions, "dynamic_texture_workaround", DRI_BOOL)) ctx->base.dynamic_texture_workaround = driQueryOptionb(&userInitOptions, "dynamic_texture_workaround"); else ctx->base.dynamic_texture_workaround = FALSE; if (driCheckOption(&userInitOptions, "shader_inline_constants", DRI_BOOL)) ctx->base.shader_inline_constants = driQueryOptionb(&userInitOptions, "shader_inline_constants"); else ctx->base.shader_inline_constants = FALSE; driDestroyOptionCache(&userInitOptions); driDestroyOptionInfo(&defaultInitOptions); /* wrap it to create a software screen that can share resources */ if (pipe_loader_sw_probe_wrapped(&ctx->swdev, ctx->base.hal)) ctx->base.ref = pipe_loader_create_screen(ctx->swdev); if (!ctx->base.ref) { ERR("Couldn't wrap drm screen to swrast screen. Software devices " "will be unavailable.\n"); } /* read out PCI info */ read_descriptor(&ctx->base, fd, override_vendorid); /* create and return new ID3DAdapter9 */ hr = NineAdapter9_new(&ctx->base, (struct NineAdapter9 **)ppAdapter); if (FAILED(hr)) { drm_destroy(&ctx->base); return hr; } return D3D_OK; }
/* 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; }