PVRSRV_ERROR SysPowerLockWrap(IMG_VOID)
{
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
PowerLockWrap(psSysData->pvSysSpecificData);
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function SysCreateVersionString
@Description Read the version string
@Return IMG_CHAR * : Version string
******************************************************************************/
static IMG_CHAR *SysCreateVersionString(void)
{
static IMG_CHAR aszVersionString[100];
SYS_DATA *psSysData;
IMG_UINT32 ui32SGXRevision;
IMG_INT32 i32Count;
#if !defined(NO_HARDWARE)
IMG_VOID *pvRegsLinAddr;
pvRegsLinAddr = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
IMG_NULL);
if(!pvRegsLinAddr)
{
return IMG_NULL;
}
#if SGX_CORE_REV == 105
ui32SGXRevision = 0x10005;
#else
ui32SGXRevision = OSReadHWReg((IMG_PVOID)((IMG_PBYTE)pvRegsLinAddr),
EUR_CR_CORE_REVISION);
#endif
#else
ui32SGXRevision = 0;
#endif
SysAcquireData(&psSysData);
i32Count = OSSNPrintf(aszVersionString, 100,
"SGX revision = %u.%u.%u",
(IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAJOR_MASK)
>> EUR_CR_CORE_REVISION_MAJOR_SHIFT),
(IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MINOR_MASK)
>> EUR_CR_CORE_REVISION_MINOR_SHIFT),
(IMG_UINT)((ui32SGXRevision & EUR_CR_CORE_REVISION_MAINTENANCE_MASK)
>> EUR_CR_CORE_REVISION_MAINTENANCE_SHIFT)
);
#if !defined(NO_HARDWARE)
OSUnMapPhysToLin(pvRegsLinAddr,
SYS_OMAP5430_SGX_REGS_SIZE,
PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
IMG_NULL);
#endif
if(i32Count == -1)
{
return IMG_NULL;
}
return aszVersionString;
}
/*!
******************************************************************************
@Function PVRSRVScheduleDeviceCallbacks
@Description Schedule all device callbacks
@Return IMG_VOID
******************************************************************************/
IMG_VOID PVRSRVScheduleDeviceCallbacks(IMG_VOID)
{
SYS_DATA *psSysData;
/* PVRSRV_DEVICE_NODE *psDeviceNode;*/
SysAcquireData(&psSysData);
/*for all the device, invoke the callback function*/
List_PVRSRV_DEVICE_NODE_ForEach(psSysData->psDeviceNodeList,
&PVRSRVCommandCompleteCallbacks_ForEachCb);
}
PVRSRV_ERROR SysPowerLockWrap(IMG_BOOL bTryLock)
{
#if 0
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
return PowerLockWrap(psSysData->pvSysSpecificData, bTryLock);
#else
return PVRSRV_OK;
#endif
}
static enum PVRSRV_ERROR PVRSRVRemoveBCDeviceKM(u32 ui32DevIndex)
{
struct SYS_DATA *psSysData;
struct PVRSRV_DEVICE_NODE **ppsDevNode, *psDevNode;
struct PVRSRV_BUFFERCLASS_INFO *psBCInfo;
if (SysAcquireData(&psSysData) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVRemoveBCDeviceKM: Failed to get SysData");
return PVRSRV_ERROR_GENERIC;
}
ppsDevNode = &psSysData->psDeviceNodeList;
while (*ppsDevNode) {
switch ((*ppsDevNode)->sDevId.eDeviceClass) {
case PVRSRV_DEVICE_CLASS_BUFFER:
{
if ((*ppsDevNode)->sDevId.ui32DeviceIndex ==
ui32DevIndex)
goto FoundDevice;
break;
}
default:
{
break;
}
}
ppsDevNode = &(*ppsDevNode)->psNext;
}
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVRemoveBCDeviceKM: requested device %d not present",
ui32DevIndex);
return PVRSRV_ERROR_GENERIC;
FoundDevice:
psDevNode = *(ppsDevNode);
*ppsDevNode = psDevNode->psNext;
FreeDeviceID(psSysData, ui32DevIndex);
psBCInfo = (struct PVRSRV_BUFFERCLASS_INFO *)psDevNode->pvDevice;
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_BC_SRV2BUFFER_KMJTABLE),
psBCInfo->psFuncTable,
NULL);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_BUFFERCLASS_INFO), psBCInfo, NULL);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct PVRSRV_DEVICE_NODE),
psDevNode, NULL);
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function PVRSRVInitialiseDevice
@Description
initialises device by index
@Input ui32DevIndex : Index to the required device
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR IMG_CALLCONV PVRSRVInitialiseDevice (IMG_UINT32 ui32DevIndex)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVInitialiseDevice"));
SysAcquireData(&psSysData);
/* Find device in the list */
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
&MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_TRUE);
if(!psDeviceNode)
{
/* Devinfo not in the list */
PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: requested device is not present"));
return PVRSRV_ERROR_INIT_FAILURE;
}
/*
FoundDevice:
*/
PVR_ASSERT (psDeviceNode->ui32RefCount > 0);
/*
Create the device's resource manager context.
*/
eError = PVRSRVResManConnect(IMG_NULL, &psDeviceNode->hResManContext);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: Failed PVRSRVResManConnect call"));
return eError;
}
/* Initialise the device */
if(psDeviceNode->pfnInitDevice != IMG_NULL)
{
eError = psDeviceNode->pfnInitDevice(psDeviceNode);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVInitialiseDevice: Failed InitDevice call"));
return eError;
}
}
return PVRSRV_OK;
}
static int PVRSRVDriverRemove(LDM_DEV *pDevice)
{
struct SYS_DATA *psSysData;
PVR_TRACE("PVRSRVDriverRemove(pDevice=%p)", pDevice);
if (SysAcquireData(&psSysData) == PVRSRV_OK) {
SysDeinitialise(psSysData);
gpsPVRLDMDev = NULL;
}
return 0;
}
static struct PVRSRV_DEVICE_NODE *get_sgx_node(void)
{
struct SYS_DATA *sysdata;
struct PVRSRV_DEVICE_NODE *node;
if (SysAcquireData(&sysdata) != PVRSRV_OK)
return NULL;
for (node = sysdata->psDeviceNodeList; node; node = node->psNext)
if (node->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_SGX)
break;
return node;
}
PVRSRV_ERROR PVRSRVDevicePreClockSpeedChange(IMG_UINT32 ui32DeviceIndex,
IMG_BOOL bIdleDevice,
IMG_VOID *pvInfo)
{
PVRSRV_ERROR eError = PVRSRV_OK;
SYS_DATA *psSysData;
PVRSRV_POWER_DEV *psPowerDevice;
PVR_UNREFERENCED_PARAMETER(pvInfo);
SysAcquireData(&psSysData);
if (bIdleDevice)
{
eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVDevicePreClockSpeedChange : failed to acquire lock, error:0x%lx", eError));
return eError;
}
}
psPowerDevice = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
if (psPowerDevice && psPowerDevice->pfnPostClockSpeedChange)
{
eError = psPowerDevice->pfnPreClockSpeedChange(psPowerDevice->hDevCookie,
bIdleDevice,
psPowerDevice->eCurrentPowerState);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,
"PVRSRVDevicePreClockSpeedChange : Device %lu failed, error:0x%lx",
ui32DeviceIndex, eError));
}
}
if (bIdleDevice && eError != PVRSRV_OK)
{
PVRSRVPowerUnlock(KERNEL_ID);
}
return eError;
}
enum PVRSRV_ERROR PVRSRVInitialiseDevice(u32 ui32DevIndex)
{
struct PVRSRV_DEVICE_NODE *psDeviceNode;
struct SYS_DATA *psSysData;
enum PVRSRV_ERROR eError;
PVR_DPF(PVR_DBG_MESSAGE, "PVRSRVInitialiseDevice");
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVInitialiseDevice: Failed to get SysData");
return eError;
}
psDeviceNode = psSysData->psDeviceNodeList;
while (psDeviceNode) {
if (psDeviceNode->sDevId.ui32DeviceIndex == ui32DevIndex)
goto FoundDevice;
psDeviceNode = psDeviceNode->psNext;
}
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVInitialiseDevice: requested device is not present");
return PVRSRV_ERROR_INIT_FAILURE;
FoundDevice:
PVR_ASSERT(psDeviceNode->ui32RefCount > 0);
eError = PVRSRVResManConnect(NULL, &psDeviceNode->hResManContext);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVInitialiseDevice: "
"Failed PVRSRVResManConnect call");
return eError;
}
if (psDeviceNode->pfnInitDevice != NULL) {
eError = psDeviceNode->pfnInitDevice(psDeviceNode);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVInitialiseDevice: "
"Failed InitDevice call");
return eError;
}
}
return PVRSRV_OK;
}
PVRSRV_ERROR IMG_CALLCONV PVRSRVFinaliseSystem(IMG_BOOL bInitSuccessful)
{
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVFinaliseSystem"));
SysAcquireData(&psSysData);
if (bInitSuccessful)
{
eError = SysFinalise();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVFinaliseSystem: SysFinalise failed (%d)", eError));
return eError;
}
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
PVRSRVFinaliseSystem_SetPowerState_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
}
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
PVRSRVFinaliseSystem_CompatCheck_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
}
}
#if !defined(SUPPORT_DRI_DRM)
PDUMPENDINITPHASE();
#endif
return PVRSRV_OK;
}
enum PVRSRV_ERROR PVRSRVSystemPrePowerStateKM(
enum PVR_POWER_STATE eNewPowerState)
{
enum PVRSRV_ERROR eError;
struct SYS_DATA *psSysData;
enum PVR_POWER_STATE eNewDevicePowerState;
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK)
return eError;
eError = PVRSRVPowerLock(KERNEL_ID, IMG_TRUE);
if (eError != PVRSRV_OK)
return eError;
if (_IsSystemStatePowered(eNewPowerState) !=
_IsSystemStatePowered(psSysData->eCurrentPowerState)) {
if (_IsSystemStatePowered(eNewPowerState))
eNewDevicePowerState = PVRSRV_POWER_Unspecified;
else
eNewDevicePowerState = PVRSRV_POWER_STATE_D3;
eError = PVRSRVDevicePrePowerStateKM(IMG_TRUE, 0,
eNewDevicePowerState);
if (eError != PVRSRV_OK)
goto ErrorExit;
}
if (eNewPowerState != psSysData->eCurrentPowerState) {
eError = SysSystemPrePowerState(eNewPowerState);
if (eError != PVRSRV_OK)
goto ErrorExit;
}
return eError;
ErrorExit:
PVR_DPF(PVR_DBG_ERROR, "PVRSRVSystemPrePowerStateKM: "
"Transition from %d to %d FAILED 0x%x",
psSysData->eCurrentPowerState, eNewPowerState, eError);
psSysData->eFailedPowerState = eNewPowerState;
PVRSRVPowerUnlock(KERNEL_ID);
return eError;
}
enum PVRSRV_ERROR PVRSRVAcquireDeviceDataKM(u32 ui32DevIndex,
enum PVRSRV_DEVICE_TYPE eDeviceType,
void **phDevCookie)
{
struct PVRSRV_DEVICE_NODE *psDeviceNode;
struct SYS_DATA *psSysData;
enum PVRSRV_ERROR eError;
PVR_DPF(PVR_DBG_MESSAGE, "PVRSRVAcquireDeviceDataKM");
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVAcquireDeviceDataKM: Failed to get SysData");
return eError;
}
psDeviceNode = psSysData->psDeviceNodeList;
if (eDeviceType != PVRSRV_DEVICE_TYPE_UNKNOWN) {
while (psDeviceNode) {
if (psDeviceNode->sDevId.eDeviceType == eDeviceType)
goto FoundDevice;
psDeviceNode = psDeviceNode->psNext;
}
} else {
while (psDeviceNode) {
if (psDeviceNode->sDevId.ui32DeviceIndex ==
ui32DevIndex) {
goto FoundDevice;
}
psDeviceNode = psDeviceNode->psNext;
}
}
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVAcquireDeviceDataKM: requested device is not present");
return PVRSRV_ERROR_INIT_FAILURE;
FoundDevice:
PVR_ASSERT(psDeviceNode->ui32RefCount > 0);
if (phDevCookie)
*phDevCookie = (void *) psDeviceNode;
return PVRSRV_OK;
}
enum PVRSRV_ERROR PVRSRVSystemPostPowerStateKM(
enum PVR_POWER_STATE eNewPowerState)
{
enum PVRSRV_ERROR eError;
struct SYS_DATA *psSysData;
enum PVR_POWER_STATE eNewDevicePowerState;
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK)
goto Exit;
if (eNewPowerState != psSysData->eCurrentPowerState) {
eError = SysSystemPostPowerState(eNewPowerState);
if (eError != PVRSRV_OK)
goto Exit;
}
if (_IsSystemStatePowered(eNewPowerState) !=
_IsSystemStatePowered(psSysData->eCurrentPowerState)) {
if (_IsSystemStatePowered(eNewPowerState))
eNewDevicePowerState = PVRSRV_POWER_Unspecified;
else
eNewDevicePowerState = PVRSRV_POWER_STATE_D3;
eError =
PVRSRVDevicePostPowerStateKM(IMG_TRUE, 0,
eNewDevicePowerState);
if (eError != PVRSRV_OK)
goto Exit;
}
PVR_DPF(PVR_DBG_WARNING, "PVRSRVSystemPostPowerStateKM: "
"System Power Transition from %d to %d OK",
psSysData->eCurrentPowerState, eNewPowerState);
psSysData->eCurrentPowerState = eNewPowerState;
Exit:
PVRSRVPowerUnlock(KERNEL_ID);
if (_IsSystemStatePowered(eNewPowerState) &&
PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL))
PVRSRVCommandCompleteCallbacks();
return eError;
}
enum PVRSRV_ERROR PVRSRVRegisterPowerDevice(u32 ui32DeviceIndex,
enum PVRSRV_ERROR (*pfnPrePower)(void *, enum PVR_POWER_STATE,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPostPower)(void *, enum PVR_POWER_STATE,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPreClockSpeedChange)(void *, IMG_BOOL,
enum PVR_POWER_STATE),
enum PVRSRV_ERROR (*pfnPostClockSpeedChange)(void *, IMG_BOOL,
enum PVR_POWER_STATE),
void *hDevCookie, enum PVR_POWER_STATE eCurrentPowerState,
enum PVR_POWER_STATE eDefaultPowerState)
{
enum PVRSRV_ERROR eError;
struct SYS_DATA *psSysData;
struct PVRSRV_POWER_DEV *psPowerDevice;
if (pfnPrePower == NULL && pfnPostPower == NULL)
return PVRSRVRemovePowerDevice(ui32DeviceIndex);
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK)
return eError;
eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
sizeof(struct PVRSRV_POWER_DEV),
(void **) &psPowerDevice, NULL);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVRegisterPowerDevice: "
"Failed to alloc struct PVRSRV_POWER_DEV");
return eError;
}
psPowerDevice->pfnPrePower = pfnPrePower;
psPowerDevice->pfnPostPower = pfnPostPower;
psPowerDevice->pfnPreClockSpeedChange = pfnPreClockSpeedChange;
psPowerDevice->pfnPostClockSpeedChange = pfnPostClockSpeedChange;
psPowerDevice->hDevCookie = hDevCookie;
psPowerDevice->ui32DeviceIndex = ui32DeviceIndex;
psPowerDevice->eCurrentPowerState = eCurrentPowerState;
psPowerDevice->eDefaultPowerState = eDefaultPowerState;
psPowerDevice->psNext = psSysData->psPowerDeviceList;
psSysData->psPowerDeviceList = psPowerDevice;
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVRegisterPowerDevice(IMG_UINT32 ui32DeviceIndex,
PFN_PRE_POWER pfnPrePower,
PFN_POST_POWER pfnPostPower,
PFN_PRE_CLOCKSPEED_CHANGE pfnPreClockSpeedChange,
PFN_POST_CLOCKSPEED_CHANGE pfnPostClockSpeedChange,
IMG_HANDLE hDevCookie,
PVRSRV_DEV_POWER_STATE eCurrentPowerState,
PVRSRV_DEV_POWER_STATE eDefaultPowerState)
{
PVRSRV_ERROR eError;
SYS_DATA *psSysData;
PVRSRV_POWER_DEV *psPowerDevice;
if (pfnPrePower == IMG_NULL &&
pfnPostPower == IMG_NULL)
{
return PVRSRVRemovePowerDevice(ui32DeviceIndex);
}
SysAcquireData(&psSysData);
eError = OSAllocMem( PVRSRV_OS_PAGEABLE_HEAP,
sizeof(PVRSRV_POWER_DEV),
(IMG_VOID **)&psPowerDevice, IMG_NULL,
"Power Device");
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterPowerDevice: Failed to alloc PVRSRV_POWER_DEV"));
return eError;
}
psPowerDevice->pfnPrePower = pfnPrePower;
psPowerDevice->pfnPostPower = pfnPostPower;
psPowerDevice->pfnPreClockSpeedChange = pfnPreClockSpeedChange;
psPowerDevice->pfnPostClockSpeedChange = pfnPostClockSpeedChange;
psPowerDevice->hDevCookie = hDevCookie;
psPowerDevice->ui32DeviceIndex = ui32DeviceIndex;
psPowerDevice->eCurrentPowerState = eCurrentPowerState;
psPowerDevice->eDefaultPowerState = eDefaultPowerState;
List_PVRSRV_POWER_DEV_Insert(&(psSysData->psPowerDeviceList), psPowerDevice);
return (PVRSRV_OK);
}
static int PVRSRVDriverProbe(LDM_DEV *pDevice)
{
struct SYS_DATA *psSysData;
PVR_TRACE("PVRSRVDriverProbe(pDevice=%p)", pDevice);
pDevice->dev.driver_data = NULL;
if (SysAcquireData(&psSysData) != PVRSRV_OK) {
gpsPVRLDMDev = pDevice;
if (SysInitialise() != PVRSRV_OK)
return -ENODEV;
}
return 0;
}
enum PVRSRV_ERROR PVRSRVDevicePreClockSpeedChange(u32 ui32DeviceIndex,
IMG_BOOL bIdleDevice,
void *pvInfo)
{
enum PVRSRV_ERROR eError = PVRSRV_OK;
struct SYS_DATA *psSysData;
struct PVRSRV_POWER_DEV *psPowerDevice;
PVR_UNREFERENCED_PARAMETER(pvInfo);
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK)
return eError;
psPowerDevice = psSysData->psPowerDeviceList;
while (psPowerDevice) {
if (ui32DeviceIndex == psPowerDevice->ui32DeviceIndex)
if (psPowerDevice->pfnPreClockSpeedChange) {
eError =
psPowerDevice->
pfnPreClockSpeedChange(psPowerDevice->
hDevCookie,
bIdleDevice,
psPowerDevice->
eCurrentPowerState);
if (eError != PVRSRV_OK) {
pr_err
("pfnPreClockSpeedChange failed\n");
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDevicePreClockSpeedChange : "
"Device %lu failed, error:0x%lx",
ui32DeviceIndex, eError);
break;
}
}
psPowerDevice = psPowerDevice->psNext;
}
if (bIdleDevice && eError != PVRSRV_OK)
PVRSRVPowerUnlock(KERNEL_ID);
return eError;
}
static
PVRSRV_ERROR PVRSRVDevicePostPowerStateKM(IMG_BOOL bAllDevices,
IMG_UINT32 ui32DeviceIndex,
PVRSRV_DEV_POWER_STATE eNewPowerState)
{
PVRSRV_ERROR eError;
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
eError = List_PVRSRV_POWER_DEV_PVRSRV_ERROR_Any_va(psSysData->psPowerDeviceList,
PVRSRVDevicePostPowerStateKM_AnyVaCb,
bAllDevices,
ui32DeviceIndex,
eNewPowerState);
return eError;
}
static void __exit PVRCore_Cleanup(void)
{
struct SYS_DATA *psSysData;
PVR_TRACE("PVRCore_Cleanup");
SysAcquireData(&psSysData);
unregister_chrdev(AssignedMajorNumber, DRVNAME);
platform_device_unregister(&powervr_device);
platform_driver_unregister(&powervr_driver);
PVRMMapCleanup();
LinuxMMCleanup();
LinuxBridgeDeInit();
RemoveProcEntries();
PVR_TRACE("PVRCore_Cleanup: unloading");
}
/*!
******************************************************************************
@Function PVRSRVFinaliseSystem
@Description
Final part of system initialisation.
@Input ui32DevIndex : Index to the required device
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR IMG_CALLCONV PVRSRVFinaliseSystem(IMG_BOOL bInitSuccessful)
{
/* PVRSRV_DEVICE_NODE *psDeviceNode;*/
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVFinaliseSystem"));
SysAcquireData(&psSysData);
if (bInitSuccessful)
{
eError = SysFinalise();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVFinaliseSystem: SysFinalise failed (%d)", eError));
return eError;
}
/* Place all devices into their default power state. */
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
&PVRSRVFinaliseSystem_SetPowerState_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
}
/* Verify microkernel compatibility for devices */
eError = List_PVRSRV_DEVICE_NODE_PVRSRV_ERROR_Any(psSysData->psDeviceNodeList,
&PVRSRVFinaliseSystem_CompatCheck_AnyCb);
if (eError != PVRSRV_OK)
{
return eError;
}
}
/* Some platforms call this too early in the boot phase. */
PDUMPENDINITPHASE();
return PVRSRV_OK;
}
IMG_EXPORT
IMG_BOOL PVRSRVIsDevicePowered(IMG_UINT32 ui32DeviceIndex)
{
SYS_DATA *psSysData;
PVRSRV_POWER_DEV *psPowerDevice;
SysAcquireData(&psSysData);
if (OSIsResourceLocked(&psSysData->sPowerStateChangeResource, KERNEL_ID) ||
OSIsResourceLocked(&psSysData->sPowerStateChangeResource, ISR_ID))
{
return IMG_FALSE;
}
psPowerDevice = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
return (psPowerDevice && (psPowerDevice->eCurrentPowerState == PVRSRV_DEV_POWER_STATE_ON))
? IMG_TRUE : IMG_FALSE;
}
/*!
******************************************************************************
@Function PVRSRVEnumerateDevicesKM
@Description
This function will enumerate all the devices supported by the
PowerVR services within the target system.
The function returns a list of the device ID strcutres stored either in
the services or constructed in the user mode glue component in certain
environments. The number of devices in the list is also returned.
In a binary layered component which does not support dynamic runtime selection,
the glue code should compile to return the supported devices statically,
e.g. multiple instances of the same device if multiple devices are supported,
or the target combination of MBX and display device.
In the case of an environment (for instance) where one MBX1 may connect to two
display devices this code would enumerate all three devices and even
non-dynamic MBX1 selection code should retain the facility to parse the list
to find the index of the MBX device
@output pui32NumDevices : On success, contains the number of devices present
in the system
@output psDevIdList : Pointer to called supplied buffer to receive the
list of PVRSRV_DEVICE_IDENTIFIER
@return PVRSRV_ERROR : PVRSRV_NO_ERROR
******************************************************************************/
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevicesKM(IMG_UINT32 *pui32NumDevices,
PVRSRV_DEVICE_IDENTIFIER *psDevIdList)
{
SYS_DATA *psSysData;
/* PVRSRV_DEVICE_NODE *psDeviceNode; */
IMG_UINT32 i;
if (!pui32NumDevices || !psDevIdList)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDevicesKM: Invalid params"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
/*
setup input buffer to be `empty'
*/
for (i=0; i<PVRSRV_MAX_DEVICES; i++)
{
psDevIdList[i].eDeviceType = PVRSRV_DEVICE_TYPE_UNKNOWN;
}
/* and zero device count */
*pui32NumDevices = 0;
/*
Search through the device list for services managed devices
return id info for each device and the number of devices
available
*/
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
&PVRSRVEnumerateDevicesKM_ForEachVaCb,
pui32NumDevices,
&psDevIdList);
return PVRSRV_OK;
}
PVRSRV_ERROR PVRSRVRemovePowerDevice (IMG_UINT32 ui32DeviceIndex)
{
SYS_DATA *psSysData;
PVRSRV_POWER_DEV *psPowerDev;
SysAcquireData(&psSysData);
psPowerDev = (PVRSRV_POWER_DEV*)
List_PVRSRV_POWER_DEV_Any_va(psSysData->psPowerDeviceList,
MatchPowerDeviceIndex_AnyVaCb,
ui32DeviceIndex);
if (psPowerDev)
{
List_PVRSRV_POWER_DEV_Remove(psPowerDev);
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_POWER_DEV), psPowerDev, IMG_NULL);
}
return (PVRSRV_OK);
}
static PVRSRV_DEVICE_NODE* MTKGetDevNode(PVRSRV_DEVICE_TYPE eDeviceType)
{
SYS_DATA *psSysData;
SysAcquireData(&psSysData);
if (psSysData)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
psDeviceNode = psSysData->psDeviceNodeList;
while(psDeviceNode)
{
if (psDeviceNode->sDevId.eDeviceType == eDeviceType)
{
return psDeviceNode;
}
psDeviceNode = psDeviceNode->psNext;
}
}
return NULL;
}
enum PVRSRV_ERROR PVRSRVEnumerateDevicesKM(u32 *pui32NumDevices,
struct PVRSRV_DEVICE_IDENTIFIER *psDevIdList)
{
enum PVRSRV_ERROR eError;
struct SYS_DATA *psSysData;
struct PVRSRV_DEVICE_NODE *psDeviceNode;
u32 i;
if (!pui32NumDevices || !psDevIdList) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVEnumerateDevicesKM: Invalid params");
return PVRSRV_ERROR_INVALID_PARAMS;
}
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVEnumerateDevicesKM: Failed to get SysData");
return eError;
}
for (i = 0; i < PVRSRV_MAX_DEVICES; i++)
psDevIdList[i].eDeviceType = PVRSRV_DEVICE_TYPE_UNKNOWN;
*pui32NumDevices = 0;
psDeviceNode = psSysData->psDeviceNodeList;
for (i = 0; psDeviceNode != NULL; i++) {
if (psDeviceNode->sDevId.eDeviceType !=
PVRSRV_DEVICE_TYPE_EXT) {
*psDevIdList++ = psDeviceNode->sDevId;
(*pui32NumDevices)++;
}
psDeviceNode = psDeviceNode->psNext;
}
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function PVRSRVAcquireDeviceDataKM
@Description
Returns device information
@Input ui32DevIndex : Index to the required device obtained from the
PVRSRVEnumerateDevice function
@Input eDeviceType : Required device type. If type is unknown use ui32DevIndex
to locate device data
@Output *phDevCookie : Dev Cookie
@Return PVRSRV_ERROR :
******************************************************************************/
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVAcquireDeviceDataKM (IMG_UINT32 ui32DevIndex,
PVRSRV_DEVICE_TYPE eDeviceType,
IMG_HANDLE *phDevCookie)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVAcquireDeviceDataKM"));
SysAcquireData(&psSysData);
/* Find device in the list */
psDeviceNode = List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
&PVRSRVAcquireDeviceDataKM_Match_AnyVaCb,
eDeviceType,
ui32DevIndex);
if (!psDeviceNode)
{
/* device can't be found in the list so it isn't in the system */
PVR_DPF((PVR_DBG_ERROR,"PVRSRVAcquireDeviceDataKM: requested device is not present"));
return PVRSRV_ERROR_INIT_FAILURE;
}
/*FoundDevice:*/
PVR_ASSERT (psDeviceNode->ui32RefCount > 0);
/* return the dev cookie? */
if (phDevCookie)
{
*phDevCookie = (IMG_HANDLE)psDeviceNode;
}
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function SysCreateVersionString
@Description Read the version string
@Return IMG_CHAR * : Version string
******************************************************************************/
static IMG_CHAR *SysCreateVersionString(void)
{
static IMG_CHAR aszVersionString[100];
IMG_UINT32 ui32MaxStrLen;
SYS_DATA *psSysData;
IMG_UINT32 ui32SGXRevision;
IMG_INT32 i32Count;
SysAcquireData(&psSysData);
ui32SGXRevision = SGX_CORE_REV;
ui32MaxStrLen = 99;
i32Count = OSSNPrintf(aszVersionString, ui32MaxStrLen + 1,
"SGX revision = %u",
(IMG_UINT)(ui32SGXRevision));
if(i32Count == -1)
{
return IMG_NULL;
}
return aszVersionString;
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevicesKM(IMG_UINT32 *pui32NumDevices,
PVRSRV_DEVICE_IDENTIFIER *psDevIdList)
{
SYS_DATA *psSysData;
IMG_UINT32 i;
if (!pui32NumDevices || !psDevIdList)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVEnumerateDevicesKM: Invalid params"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
SysAcquireData(&psSysData);
for (i=0; i<PVRSRV_MAX_DEVICES; i++)
{
psDevIdList[i].eDeviceType = PVRSRV_DEVICE_TYPE_UNKNOWN;
}
*pui32NumDevices = 0;
List_PVRSRV_DEVICE_NODE_ForEach_va(psSysData->psDeviceNodeList,
&PVRSRVEnumerateDevicesKM_ForEachVaCb,
pui32NumDevices,
&psDevIdList);
return PVRSRV_OK;
}
static enum PVRSRV_ERROR PVRSRVRegisterSystemISRHandler(
IMG_BOOL (*pfnISRHandler)(void *),
void *pvISRHandlerData,
u32 ui32ISRSourceMask,
u32 ui32DeviceID)
{
struct SYS_DATA *psSysData;
struct PVRSRV_DEVICE_NODE *psDevNode;
PVR_UNREFERENCED_PARAMETER(ui32ISRSourceMask);
if (SysAcquireData(&psSysData) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVRegisterSystemISRHandler: "
"Failed to get SysData");
return PVRSRV_ERROR_GENERIC;
}
psDevNode = psSysData->psDeviceNodeList;
while (psDevNode) {
if (psDevNode->sDevId.ui32DeviceIndex == ui32DeviceID)
break;
psDevNode = psDevNode->psNext;
}
if (psDevNode == NULL) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVRegisterSystemISRHandler: "
"Failed to get psDevNode");
PVR_DBG_BREAK;
return PVRSRV_ERROR_GENERIC;
}
psDevNode->pvISRData = (void *) pvISRHandlerData;
psDevNode->pfnDeviceISR = pfnISRHandler;
return PVRSRV_OK;
}
