static Bool
ms_platform_probe(DriverPtr driver,
int entity_num, int flags, struct xf86_platform_device *dev, intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
const char *path = xf86_get_platform_device_attrib(dev, ODEV_ATTRIB_PATH);
int scr_flags = 0;
if (flags & PLATFORM_PROBE_GPU_SCREEN)
scr_flags = XF86_ALLOCATE_GPU_SCREEN;
if (probe_hw(path, dev)) {
scrn = xf86AllocateScreen(driver, scr_flags);
xf86AddEntityToScreen(scrn, entity_num);
scrn->driverName = "modesetting";
scrn->name = "modesetting";
scrn->PreInit = PreInit;
scrn->ScreenInit = ScreenInit;
scrn->SwitchMode = SwitchMode;
scrn->AdjustFrame = AdjustFrame;
scrn->EnterVT = EnterVT;
scrn->LeaveVT = LeaveVT;
scrn->FreeScreen = FreeScreen;
scrn->ValidMode = ValidMode;
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"using drv %s\n", path ? path : "default device");
}
return scrn != NULL;
}
static Bool
intel_platform_probe(DriverPtr driver,
int entity_num, int flags,
struct xf86_platform_device *dev,
intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
char *path = xf86_get_platform_device_attrib(dev, ODEV_ATTRIB_PATH);
unsigned scrn_flags = 0;
if (!dev->pdev)
return FALSE;
if (!has_kernel_mode_setting(dev->pdev))
return FALSE;
/* Allow ourselves to act as a slaved output if not primary */
if (flags & PLATFORM_PROBE_GPU_SCREEN) {
flags &= ~PLATFORM_PROBE_GPU_SCREEN;
scrn_flags |= XF86_ALLOCATE_GPU_SCREEN;
}
/* if we get any flags we don't understand fail to probe for now */
if (flags)
return FALSE;
scrn = xf86AllocateScreen(driver, scrn_flags);
if (scrn == NULL)
return FALSE;
scrn->driverVersion = INTEL_VERSION;
scrn->driverName = INTEL_DRIVER_NAME;
scrn->name = INTEL_NAME;
scrn->driverPrivate = (void *)(match_data | 1);
scrn->Probe = NULL;
if (xf86IsEntitySharable(entity_num))
xf86SetEntityShared(entity_num);
xf86AddEntityToScreen(scrn, entity_num);
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"using device path '%s'\n", path ? path : "Default device");
#if !UMS_ONLY
switch (get_accel_method()) {
#if USE_SNA
case SNA: return sna_init_scrn(scrn, entity_num);
#endif
#if USE_UXA
case UXA: return intel_init_scrn(scrn);
#endif
default: break;
}
#endif
return FALSE;
}
/* Mandatory */
static Bool
DUMMYProbe(DriverPtr drv, int flags)
{
Bool foundScreen = FALSE;
int numDevSections, numUsed;
GDevPtr *devSections;
int i;
if (flags & PROBE_DETECT)
return FALSE;
/*
* Find the config file Device sections that match this
* driver, and return if there are none.
*/
if ((numDevSections = xf86MatchDevice(DUMMY_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
numUsed = numDevSections;
if (numUsed > 0) {
for (i = 0; i < numUsed; i++) {
ScrnInfoPtr pScrn = NULL;
int entityIndex =
xf86ClaimNoSlot(drv,DUMMY_CHIP,devSections[i],TRUE);
/* Allocate a ScrnInfoRec and claim the slot */
if ((pScrn = xf86AllocateScreen(drv,0 ))) {
xf86AddEntityToScreen(pScrn,entityIndex);
pScrn->driverVersion = VERSION;
pScrn->driverName = DUMMY_DRIVER_NAME;
pScrn->name = DUMMY_NAME;
pScrn->Probe = DUMMYProbe;
pScrn->PreInit = DUMMYPreInit;
pScrn->ScreenInit = DUMMYScreenInit;
pScrn->SwitchMode = DUMMYSwitchMode;
pScrn->AdjustFrame = DUMMYAdjustFrame;
pScrn->EnterVT = DUMMYEnterVT;
pScrn->LeaveVT = DUMMYLeaveVT;
pScrn->FreeScreen = DUMMYFreeScreen;
pScrn->ValidMode = DUMMYValidMode;
foundScreen = TRUE;
}
}
}
return foundScreen;
}
static Bool
NestedProbe(DriverPtr drv, int flags) {
Bool foundScreen = FALSE;
int numDevSections;
GDevPtr *devSections;
int i;
ScrnInfoPtr pScrn;
int entityIndex;
if (flags & PROBE_DETECT)
return FALSE;
if ((numDevSections = xf86MatchDevice(NESTED_DRIVER_NAME,
&devSections)) <= 0) {
return FALSE;
}
if (numDevSections > 0) {
for(i = 0; i < numDevSections; i++) {
pScrn = NULL;
entityIndex = xf86ClaimNoSlot(drv, NESTED_CHIP, devSections[i],
TRUE);
pScrn = xf86AllocateScreen(drv, 0);
if (pScrn) {
xf86AddEntityToScreen(pScrn, entityIndex);
pScrn->driverVersion = NESTED_VERSION;
pScrn->driverName = NESTED_DRIVER_NAME;
pScrn->name = NESTED_NAME;
pScrn->Probe = NestedProbe;
pScrn->PreInit = NestedPreInit;
pScrn->ScreenInit = NestedScreenInit;
pScrn->SwitchMode = NestedSwitchMode;
pScrn->AdjustFrame = NestedAdjustFrame;
pScrn->EnterVT = NestedEnterVT;
pScrn->LeaveVT = NestedLeaveVT;
pScrn->FreeScreen = NestedFreeScreen;
pScrn->ValidMode = NestedValidMode;
foundScreen = TRUE;
}
}
}
return foundScreen;
}
static Bool
intel_scrn_create(DriverPtr driver,
int entity_num,
intptr_t match_data,
unsigned flags)
{
ScrnInfoPtr scrn;
scrn = xf86AllocateScreen(driver, flags);
if (scrn == NULL)
return FALSE;
scrn->driverVersion = INTEL_VERSION;
scrn->driverName = INTEL_DRIVER_NAME;
scrn->name = INTEL_NAME;
scrn->driverPrivate = (void *)(match_data | 1);
scrn->Probe = NULL;
if (xf86IsEntitySharable(entity_num))
xf86SetEntityShared(entity_num);
xf86AddEntityToScreen(scrn, entity_num);
#if !KMS_ONLY
if ((unsigned)((struct intel_device_info *)match_data)->gen < 020)
return lg_i810_init(scrn);
#endif
#if !UMS_ONLY
switch (get_accel_method()) {
#if USE_SNA
case SNA: return sna_init_scrn(scrn, entity_num);
#endif
#if USE_UXA
case UXA: return intel_init_scrn(scrn);
#endif
default: break;
}
#endif
return FALSE;
}
static Bool
VMwarePlatformProbe(DriverPtr drv, int entity, int flags,
struct xf86_platform_device *dev, intptr_t match_data)
{
ScrnInfoPtr pScrn;
int scrnFlag = 0;
if (!dev->pdev)
return FALSE;
if (flags & PLATFORM_PROBE_GPU_SCREEN)
scrnFlag = XF86_ALLOCATE_GPU_SCREEN;
pScrn = xf86AllocateScreen(drv, scrnFlag);
if (!pScrn)
return FALSE;
if (xf86IsEntitySharable(entity))
xf86SetEntityShared(entity);
xf86AddEntityToScreen(pScrn, entity);
pScrn->driverVersion = VMWARE_DRIVER_VERSION;
pScrn->driverName = VMWARE_DRIVER_NAME;
pScrn->name = VMWARE_NAME;
pScrn->Probe = NULL;
#ifdef BUILD_VMWGFX
vmwgfx_hookup(pScrn);
#else
vmwlegacy_hookup(pScrn);
#endif
pScrn->driverPrivate = pScrn->PreInit;
pScrn->PreInit = VMwarePreinitStub;
return TRUE;
}
static Bool
ms_platform_probe(DriverPtr driver,
int entity_num, int flags, struct xf86_platform_device *dev,
intptr_t match_data)
{
ScrnInfoPtr scrn = NULL;
const char *path = xf86_platform_device_odev_attributes(dev)->path;
int scr_flags = 0;
if (flags & PLATFORM_PROBE_GPU_SCREEN)
scr_flags = XF86_ALLOCATE_GPU_SCREEN;
if (probe_hw(path, dev)) {
scrn = xf86AllocateScreen(driver, scr_flags);
xf86AddEntityToScreen(scrn, entity_num);
ms_setup_scrn_hooks(scrn);
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"using drv %s\n", path ? path : "default device");
}
return scrn != NULL;
}
/* Mandatory */
static Bool
BW2Probe(DriverPtr drv, int flags)
{
int i;
GDevPtr *devSections;
int *usedChips;
int numDevSections;
int numUsed;
Bool foundScreen = FALSE;
EntityInfoPtr pEnt;
/*
* The aim here is to find all cards that this driver can handle,
* and for the ones not already claimed by another driver, claim the
* slot, and allocate a ScrnInfoRec.
*
* This should be a minimal probe, and it should under no circumstances
* change the state of the hardware. Because a device is found, don't
* assume that it will be used. Don't do any initialisations other than
* the required ScrnInfoRec initialisations. Don't allocate any new
* data structures.
*/
/*
* Next we check, if there has been a chipset override in the config file.
* For this we must find out if there is an active device section which
* is relevant, i.e., which has no driver specified or has THIS driver
* specified.
*/
if ((numDevSections = xf86MatchDevice(BW2_DRIVER_NAME,
&devSections)) <= 0) {
/*
* There's no matching device section in the config file, so quit
* now.
*/
return FALSE;
}
/*
* We need to probe the hardware first. We then need to see how this
* fits in with what is given in the config file, and allow the config
* file info to override any contradictions.
*/
numUsed = xf86MatchSbusInstances(BW2_NAME, SBUS_DEVICE_BW2,
devSections, numDevSections,
drv, &usedChips);
xfree(devSections);
if (numUsed <= 0)
return FALSE;
if (flags & PROBE_DETECT)
foundScreen = TRUE;
else for (i = 0; i < numUsed; i++) {
pEnt = xf86GetEntityInfo(usedChips[i]);
/*
* Check that nothing else has claimed the slots.
*/
if(pEnt->active) {
ScrnInfoPtr pScrn;
/* Allocate a ScrnInfoRec and claim the slot */
pScrn = xf86AllocateScreen(drv, 0);
/* Fill in what we can of the ScrnInfoRec */
pScrn->driverVersion = VERSION;
pScrn->driverName = BW2_DRIVER_NAME;
pScrn->name = BW2_NAME;
pScrn->Probe = BW2Probe;
pScrn->PreInit = BW2PreInit;
pScrn->ScreenInit = BW2ScreenInit;
pScrn->SwitchMode = BW2SwitchMode;
pScrn->AdjustFrame = BW2AdjustFrame;
pScrn->EnterVT = BW2EnterVT;
pScrn->LeaveVT = BW2LeaveVT;
pScrn->FreeScreen = BW2FreeScreen;
pScrn->ValidMode = BW2ValidMode;
xf86AddEntityToScreen(pScrn, pEnt->index);
foundScreen = TRUE;
}
xfree(pEnt);
}
xfree(usedChips);
return foundScreen;
}
static Bool
radeon_platform_probe(DriverPtr pDriver,
int entity_num, int flags,
struct xf86_platform_device *dev,
intptr_t match_data)
{
ScrnInfoPtr pScrn;
int scr_flags = 0;
EntityInfoPtr pEnt;
if (!dev->pdev)
return FALSE;
if (flags & PLATFORM_PROBE_GPU_SCREEN)
scr_flags = XF86_ALLOCATE_GPU_SCREEN;
pScrn = xf86AllocateScreen(pDriver, scr_flags);
if (xf86IsEntitySharable(entity_num))
xf86SetEntityShared(entity_num);
xf86AddEntityToScreen(pScrn, entity_num);
if (!radeon_kernel_mode_enabled(pScrn, dev->pdev))
return FALSE;
pScrn->driverVersion = RADEON_VERSION_CURRENT;
pScrn->driverName = RADEON_DRIVER_NAME;
pScrn->name = RADEON_NAME;
pScrn->Probe = NULL;
pScrn->PreInit = RADEONPreInit_KMS;
pScrn->ScreenInit = RADEONScreenInit_KMS;
pScrn->SwitchMode = RADEONSwitchMode_KMS;
pScrn->AdjustFrame = RADEONAdjustFrame_KMS;
pScrn->EnterVT = RADEONEnterVT_KMS;
pScrn->LeaveVT = RADEONLeaveVT_KMS;
pScrn->FreeScreen = RADEONFreeScreen_KMS;
pScrn->ValidMode = RADEONValidMode;
pEnt = xf86GetEntityInfo(entity_num);
/* Create a RADEONEntity for all chips, even with old single head
* Radeon, need to use pRADEONEnt for new monitor detection routines.
*/
{
DevUnion *pPriv;
RADEONEntPtr pRADEONEnt;
xf86SetEntitySharable(entity_num);
if (gRADEONEntityIndex == -1)
gRADEONEntityIndex = xf86AllocateEntityPrivateIndex();
pPriv = xf86GetEntityPrivate(pEnt->index,
gRADEONEntityIndex);
xf86SetEntityInstanceForScreen(pScrn, pEnt->index, xf86GetNumEntityInstances(pEnt->index) - 1);
if (!pPriv->ptr) {
pPriv->ptr = xnfcalloc(sizeof(RADEONEntRec), 1);
pRADEONEnt = pPriv->ptr;
} else {
pRADEONEnt = pPriv->ptr;
}
pRADEONEnt->platform_dev = dev;
}
free(pEnt);
return TRUE;
}
