/** * Utility function used by drivers to test the verions of other components. * * If one of the version requirements is not met, a message is logged using * \c __driUtilMessage. * * \param driver_name Name of the driver. Used in error messages. * \param driActual Actual DRI version supplied __driCreateNewScreen. * \param driExpected Minimum DRI version required by the driver. * \param ddxActual Actual DDX version supplied __driCreateNewScreen. * \param ddxExpected Minimum DDX minor and range of DDX major version required by the driver. * \param drmActual Actual DRM version supplied __driCreateNewScreen. * \param drmExpected Minimum DRM version required by the driver. * * \returns \c GL_TRUE if all version requirements are met. Otherwise, * \c GL_FALSE is returned. * * \sa __driCreateNewScreen, driCheckDriDdxDrmVersions2, __driUtilMessage * * \todo * Now that the old \c driCheckDriDdxDrmVersions function is gone, this * function and \c driCheckDriDdxDrmVersions2 should be renamed. */ GLboolean driCheckDriDdxDrmVersions3(const char * driver_name, const __DRIversion * driActual, const __DRIversion * driExpected, const __DRIversion * ddxActual, const __DRIutilversion2 * ddxExpected, const __DRIversion * drmActual, const __DRIversion * drmExpected) { static const char format[] = "%s DRI driver expected %s version %d.%d.x " "but got version %d.%d.%d"; static const char format2[] = "%s DRI driver expected %s version %d-%d.%d.x " "but got version %d.%d.%d"; /* Check the DRI version */ if ( (driActual->major != driExpected->major) || (driActual->minor < driExpected->minor) ) { __driUtilMessage(format, driver_name, "DRI", driExpected->major, driExpected->minor, driActual->major, driActual->minor, driActual->patch); return GL_FALSE; } /* Check that the DDX driver version is compatible */ if ( (ddxActual->major < ddxExpected->major_min) || (ddxActual->major > ddxExpected->major_max) || (ddxActual->minor < ddxExpected->minor) ) { __driUtilMessage(format2, driver_name, "DDX", ddxExpected->major_min, ddxExpected->major_max, ddxExpected->minor, ddxActual->major, ddxActual->minor, ddxActual->patch); return GL_FALSE; } /* Check that the DRM driver version is compatible */ if ( (drmActual->major != drmExpected->major) || (drmActual->minor < drmExpected->minor) ) { __driUtilMessage(format, driver_name, "DRM", drmExpected->major, drmExpected->minor, drmActual->major, drmActual->minor, drmActual->patch); return GL_FALSE; } return GL_TRUE; }
/** * Utility function used by drivers to test the verions of other components. * * \deprecated * All drivers using the new interface should use \c driCheckDriDdxVersions2 * instead. This function is implemented using a call that is not available * to drivers using the new interface. Furthermore, the information gained * by this call (the DRI and DDX version information) is already provided to * the driver via the new interface. */ GLboolean driCheckDriDdxDrmVersions(__DRIscreenPrivate *sPriv, const char * driver_name, int dri_major, int dri_minor, int ddx_major, int ddx_minor, int drm_major, int drm_minor) { static const char format[] = "%s DRI driver expected %s version %d.%d.x " "but got version %d.%d.%d"; int major, minor, patch; /* Check the DRI version */ if (XF86DRIQueryVersion(sPriv->display, &major, &minor, &patch)) { if (major != dri_major || minor < dri_minor) { __driUtilMessage(format, driver_name, "DRI", dri_major, dri_minor, major, minor, patch); return GL_FALSE; } } /* Check that the DDX driver version is compatible */ if (sPriv->ddxMajor != ddx_major || sPriv->ddxMinor < ddx_minor) { __driUtilMessage(format, driver_name, "DDX", ddx_major, ddx_minor, sPriv->ddxMajor, sPriv->ddxMinor, sPriv->ddxPatch); return GL_FALSE; } /* Check that the DRM driver version is compatible */ if (sPriv->drmMajor != drm_major || sPriv->drmMinor < drm_minor) { __driUtilMessage(format, driver_name, "DRM", drm_major, drm_minor, sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch); return GL_FALSE; } return GL_TRUE; }
/* 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; }