PVRSRV_ERROR SysSystemPrePowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
{
PVRSRV_ERROR eError = PVRSRV_OK;
if (eNewPowerState == PVRSRV_SYS_POWER_STATE_D3)
{
PVR_TRACE(("SysSystemPrePowerState: Entering state D3"));
#if defined(SYS_USING_INTERRUPTS)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR))
{
#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
IMG_BOOL bWrapped = WrapSystemPowerChange(&gsSysSpecificData);
#endif
eError = OSUninstallDeviceLISR(gpsSysData);
#if defined(SYS_CUSTOM_POWERLOCK_WRAP)
if (bWrapped)
{
UnwrapSystemPowerChange(&gsSysSpecificData);
}
#endif
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPrePowerState: OSUninstallDeviceLISR failed (%d)", eError));
return eError;
}
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
}
#endif
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS))
{
DisableSystemClocks(gpsSysData);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_DISABLE_SYSCLOCKS);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_SYSCLOCKS);
}
}
return eError;
}
static PVRSRV_ERROR SysMapInRegisters(IMG_VOID)
{
PVRSRV_DEVICE_NODE *psDeviceNodeList;
psDeviceNodeList = gpsSysData->psDeviceNodeList;
while (psDeviceNodeList)
{
switch(psDeviceNodeList->sDevId.eDeviceType)
{
case PVRSRV_DEVICE_TYPE_SGX:
{
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNodeList->pvDevice;
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS))
{
psDevInfo->pvRegsBaseKM = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvRegsBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map in SGX registers\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS);
}
psDevInfo->ui32RegSize = gsSGXDeviceMap.ui32RegsSize;
psDevInfo->sRegsPhysBase = gsSGXDeviceMap.sRegsSysPBase;
#if defined(SGX_FEATURE_HOST_PORT)
if (gsSGXDeviceMap.ui32Flags & SGX_HOSTPORT_PRESENT)
{
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_HP))
{
psDevInfo->pvHostPortBaseKM = OSMapPhysToLin(gsSGXDeviceMap.sHPCpuPBase,
gsSGXDeviceMap.ui32HPSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvHostPortBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map in host port\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_HP);
}
psDevInfo->ui32HPSize = gsSGXDeviceMap.ui32HPSize;
psDevInfo->sHPSysPAddr = gsSGXDeviceMap.sHPSysPBase;
}
#endif
break;
}
default:
break;
}
psDeviceNodeList = psDeviceNodeList->psNext;
}
return PVRSRV_OK;
}
/*!
******************************************************************************
@Function SysSystemPostPowerState
@Description Perform system-level processing required after a system power
transition
@Input eNewPowerState :
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
{
PVRSRV_ERROR eError = PVRSRV_OK;
if (eNewPowerState != gpsSysData->eCurrentPowerState)
{
if ((gpsSysData->eCurrentPowerState == PVRSRV_SYS_POWER_STATE_D3) &&
(eNewPowerState < PVRSRV_SYS_POWER_STATE_D3))
{
#ifdef __linux__
eError = OSPCIResumeDev(gsSysSpecificData.hSGXPCI);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSPCIResumeDev failed (%d)", eError));
}
#endif
/*
Returning from D3 state.
Find the device again as it may have been remapped.
*/
eError = SysLocateDevices(gpsSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: Failed to locate devices"));
return eError;
}
/*
* Since this is a local memory architecture system, any local memory
* which is currently in use must be restored before power up.
*/
SysSaveRestoreArenaLiveSegments(IMG_FALSE);
/*
* Map the system-level registers.
*/
eError = SysMapInRegisters();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: Failed to map in registers"));
return eError;
}
/* Reset Atlas. */
eError = SysInitRegisters();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: Failed to Initialise registers"));
return eError;
}
#if defined(SYS_USING_INTERRUPTS)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))
{
eError = OSInstallSystemLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallSystemLISR failed to install ISR (%d)", eError));
}
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_LISR);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
}
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE))
{
SysEnableInterrupts(gpsSysData);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_IRQ);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE);
}
#endif /* defined(SYS_USING_INTERRUPTS) */
}
}
return eError;
}
static PVRSRV_ERROR SysUnmapRegisters(IMG_VOID)
{
PVRSRV_DEVICE_NODE *psDeviceNodeList;
psDeviceNodeList = gpsSysData->psDeviceNodeList;
while (psDeviceNodeList)
{
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNodeList->pvDevice;
if (psDeviceNodeList->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_SGX)
{
#if !(defined(NO_HARDWARE) && defined(__linux__))
/* Unmap Regs */
if (psDevInfo->pvRegsBaseKM)
{
OSUnMapPhysToLin(psDevInfo->pvRegsBaseKM,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS);
}
#endif /* #if !(defined(NO_HARDWARE) && defined(__linux__)) */
psDevInfo->pvRegsBaseKM = IMG_NULL;
psDevInfo->ui32RegSize = 0;
psDevInfo->sRegsPhysBase.uiAddr = 0;
#if defined(SGX_FEATURE_HOST_PORT)
if (gsSGXDeviceMap.ui32Flags & SGX_HOSTPORT_PRESENT)
{
/* Unmap Host Port */
if (psDevInfo->pvHostPortBaseKM)
{
OSUnMapPhysToLin(psDevInfo->pvHostPortBaseKM,
gsSGXDeviceMap.ui32HPSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_HP);
psDevInfo->pvHostPortBaseKM = IMG_NULL;
}
psDevInfo->ui32HPSize = 0;
psDevInfo->sHPSysPAddr.uiAddr = 0;
}
#endif /* #if defined(SGX_FEATURE_HOST_PORT) */
}
psDeviceNodeList = psDeviceNodeList->psNext;
}
#if defined(NO_HARDWARE)
PVR_ASSERT(gsSGXRegsCPUVAddr);
OSBaseFreeContigMemory(SYS_SGX_REG_SIZE, gsSGXRegsCPUVAddr, gsSGXDeviceMap.sRegsCpuPBase);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_ENABLE_REG_MEM);
gsSGXRegsCPUVAddr = IMG_NULL;
#endif
/* Unmap the Atlas and PDP registers */
if (gpsSysData->pvSOCRegsBase)
{
OSUnMapPhysToLin(gpsSysData->pvSOCRegsBase,
SYS_ATLAS_REG_REGION_SIZE,
PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
IMG_NULL);
gpsSysData->pvSOCRegsBase = IMG_NULL;
}
return PVRSRV_OK;
}
static PVRSRV_ERROR SysMapInRegisters(IMG_VOID)
{
PVRSRV_DEVICE_NODE *psDeviceNodeList;
/*
Map the Atlas and PDP registers.
*/
gpsSysData->pvSOCRegsBase = OSMapPhysToLin(gsSOCRegsCpuPBase,
SYS_ATLAS_REG_REGION_SIZE,
PVRSRV_HAP_UNCACHED|PVRSRV_HAP_KERNEL_ONLY,
IMG_NULL);
if (gpsSysData->pvSOCRegsBase == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR,"SysPrePowerState: Failed to map SOC Register base"));
return PVRSRV_ERROR_REGISTER_BASE_NOT_SET;
}
psDeviceNodeList = gpsSysData->psDeviceNodeList;
while (psDeviceNodeList)
{
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)psDeviceNodeList->pvDevice;
if (psDeviceNodeList->sDevId.eDeviceType == PVRSRV_DEVICE_TYPE_SGX)
{
#if defined(NO_HARDWARE) && defined(__linux__)
/*
* SysLocateDevices will have reallocated the dummy
* registers.
*/
PVR_ASSERT(gsSGXRegsCPUVAddr);
psDevInfo->pvRegsBaseKM = gsSGXRegsCPUVAddr;
#else
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS))
{
/* Remap Regs */
psDevInfo->pvRegsBaseKM = OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvRegsBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map in regs\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS);
}
#endif /* #if defined(NO_HARDWARE) && defined(__linux__) */
psDevInfo->ui32RegSize = gsSGXDeviceMap.ui32RegsSize;
psDevInfo->sRegsPhysBase = gsSGXDeviceMap.sRegsSysPBase;
#if defined(SGX_FEATURE_HOST_PORT)
if (gsSGXDeviceMap.ui32Flags & SGX_HOSTPORT_PRESENT)
{
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_HP))
{
/* Map Host Port */
psDevInfo->pvHostPortBaseKM = OSMapPhysToLin(gsSGXDeviceMap.sHPCpuPBase,
gsSGXDeviceMap.ui32HPSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvHostPortBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map in host port\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_HP);
}
psDevInfo->ui32HPSize = gsSGXDeviceMap.ui32HPSize;
psDevInfo->sHPSysPAddr = gsSGXDeviceMap.sHPSysPBase;
}
#endif /* #if defined(SGX_FEATURE_HOST_PORT) */
}
psDeviceNodeList = psDeviceNodeList->psNext;
}
return PVRSRV_OK;
}
/***********************************************************************//**
* Map the CPU physical backing for the registers to CPU virtual memory
* so we can write to it from the host
*
* @returns PVRSRV_OK for success, or failure code
**************************************************************************/
static PVRSRV_ERROR SysMapInRegisters(void)
{
PVRSRV_DEVICE_NODE *psDeviceNodeList;
psDeviceNodeList = gpsSysData->psDeviceNodeList;
while (psDeviceNodeList)
{
switch (psDeviceNodeList->sDevId.eDeviceType)
{
case PVRSRV_DEVICE_TYPE_SGX:
{
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)
psDeviceNodeList->pvDevice;
#if !defined(NO_HARDWARE)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS))
{
/* Remap Regs */
psDevInfo->pvRegsBaseKM =
OSMapPhysToLin(gsSGXDeviceMap.sRegsCpuPBase,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvRegsBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map in regs\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS);
}
#else /* !defined(NO_HARDWARE) */
/*
* SysLocateDevices will have reallocated the dummy
* registers.
*/
psDevInfo->pvRegsBaseKM = gsSGXDeviceMap.pvRegsCpuVBase;
#endif /* !defined(NO_HARDWARE) */
psDevInfo->ui32RegSize = gsSGXDeviceMap.ui32RegsSize;
psDevInfo->sRegsPhysBase = gsSGXDeviceMap.sRegsSysPBase;
break;
}
#if defined(SUPPORT_MSVDX)
case PVRSRV_DEVICE_TYPE_MSVDX:
{
PVRSRV_MSVDXDEV_INFO *psDevInfo = (PVRSRV_MSVDXDEV_INFO *)
psDeviceNodeList->pvDevice;
#if !defined(NO_HARDWARE)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_MSVDX_REGS))
{
/* Remap registers */
psDevInfo->pvRegsBaseKM =
OSMapPhysToLin(gsMSVDXDeviceMap.sRegsCpuPBase,
gsMSVDXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
if (!psDevInfo->pvRegsBaseKM)
{
PVR_DPF((PVR_DBG_ERROR,"SysMapInRegisters : Failed to map MSVDX registers\n"));
return PVRSRV_ERROR_BAD_MAPPING;
}
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_MSVDX_REGS);
}
#else /* !defined(NO_HARDWARE) */
/*
* SysLocateDevices will have reallocated the dummy
* registers.
*/
psDevInfo->pvRegsBaseKM = gsMSVDXDeviceMap.sRegsCpuVBase;
#endif /* !defined(NO_HARDWARE) */
psDevInfo->ui32RegSize = gsMSVDXDeviceMap.ui32RegsSize;
psDevInfo->sRegsPhysBase = gsMSVDXDeviceMap.sRegsSysPBase;
break;
}
#endif /* SUPPORT_MSVDX */
default:
/* Ignore any other (unknown) devices */
break;
}
psDeviceNodeList = psDeviceNodeList->psNext;
}
return PVRSRV_OK;
}
/***********************************************************************//**
* Deinitialise the system for unloading the driver
*
* @returns PVRSRV_OK for success, or failure code
**************************************************************************/
PVRSRV_ERROR SysDeinitialise (SYS_DATA *psSysData)
{
SYS_SPECIFIC_DATA * psSysSpecData;
PVRSRV_ERROR eError;
if (psSysData == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "SysDeinitialise: NULL SYS_DATA pointer."));
return PVRSRV_OK;
}
psSysSpecData = (SYS_SPECIFIC_DATA *) psSysData->pvSysSpecificData;
#if defined(SYS_USING_INTERRUPTS)
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_IRQ_ENABLED))
{
SysDisableInterrupts(psSysData);
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_IRQ_ENABLED);
}
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_LISR_INSTALLED))
{
eError = OSUninstallSystemLISR(psSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallSystemLISR failed"));
return eError;
}
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_LISR_INSTALLED);
}
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_MISR_INSTALLED))
{
eError = OSUninstallMISR(psSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: OSUninstallMISR failed"));
return eError;
}
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_MISR_INSTALLED);
}
#endif /* #if defined(SYS_USING_INTERRUPTS) */
#if defined(SUPPORT_MSVDX)
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_INITVXDDEV))
{
/* de-initialise all services managed devices */
eError = PVRSRVDeinitialiseDevice(gui32MSVDXDeviceID);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
return eError;
}
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_INITVXDDEV);
}
#endif
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_INITSGXDEV))
{
/* de-initialise all services managed devices */
eError = PVRSRVDeinitialiseDevice(gui32SGXDeviceID);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init the device"));
return eError;
}
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_INITSGXDEV);
}
SysFreeVersionString(psSysData);
PCIDeInitDev(psSysData);
SysDeinitialiseCommon(gpsSysData);
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_ENVDATA))
{
eError = OSDeInitEnvData(gpsSysData->pvEnvSpecificData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysDeinitialise: failed to de-init env structure"));
return eError;
}
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_ENVDATA);
}
#if defined(NO_HARDWARE)
#if defined(SUPPORT_MSVDX)
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_DUMMY_MSVDX_REGS))
{
OSBaseFreeContigMemory(MSVDX_REG_SIZE,
gsMSVDXDeviceMap.sRegsCpuVBase,
gsMSVDXDeviceMap.sRegsCpuPBase);
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData,
SYS_SPECIFIC_DATA_DUMMY_MSVDX_REGS);
}
#endif
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_DUMMY_SGX_REGS))
{
OSBaseFreeContigMemory(SYS_SGX_REG_SIZE,
gsSGXDeviceMap.pvRegsCpuVBase,
gsSGXDeviceMap.sRegsCpuPBase);
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData,
SYS_SPECIFIC_DATA_DUMMY_SGX_REGS);
}
#endif
#if !defined(NO_HARDWARE)
if (SYS_SPECIFIC_DATA_TEST(psSysSpecData, SYS_SPECIFIC_DATA_SOC_REGS_MAPPED))
{
OSUnMapPhysToLin(gsSOCDeviceMap.sRegsCpuVBase,
SYS_SOC_REG_SIZE,
PVRSRV_HAP_KERNEL_ONLY | PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_CLEAR(psSysSpecData, SYS_SPECIFIC_DATA_SOC_REGS_MAPPED);
}
#endif
psSysSpecData->ui32SysSpecificData = 0;
gpsSysData = IMG_NULL;
return PVRSRV_OK;
}
/***********************************************************************//**
* Unmap the CPU virtual memory from the registers
*
* @returns PVRSRV_OK for success, or failure code
**************************************************************************/
static PVRSRV_ERROR SysUnmapRegisters(void)
{
PVRSRV_DEVICE_NODE *psDeviceNodeList;
psDeviceNodeList = gpsSysData->psDeviceNodeList;
while (psDeviceNodeList)
{
switch (psDeviceNodeList->sDevId.eDeviceType)
{
case PVRSRV_DEVICE_TYPE_SGX:
{
PVRSRV_SGXDEV_INFO *psDevInfo = (PVRSRV_SGXDEV_INFO *)
psDeviceNodeList->pvDevice;
#if !defined(NO_HARDWARE)
/* Unmap Regs */
if (psDevInfo->pvRegsBaseKM)
{
OSUnMapPhysToLin(psDevInfo->pvRegsBaseKM,
gsSGXDeviceMap.ui32RegsSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_SGX_REGS);
}
#endif
psDevInfo->pvRegsBaseKM = IMG_NULL;
psDevInfo->ui32RegSize = 0;
psDevInfo->sRegsPhysBase.uiAddr = 0;
break;
}
#ifdef SUPPORT_MSVDX
case PVRSRV_DEVICE_TYPE_MSVDX:
{
PVRSRV_MSVDXDEV_INFO *psDevInfo = (PVRSRV_MSVDXDEV_INFO *)
psDeviceNodeList->pvDevice;
#if !defined(NO_HARDWARE)
if (psDevInfo->pvRegsBaseKM)
{
OSUnMapPhysToLin(psDevInfo->pvRegsBaseKM,
psDevInfo->ui32RegSize,
PVRSRV_HAP_KERNEL_ONLY|PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNMAP_MSVDX_REGS);
}
#endif
psDevInfo->pvRegsBaseKM = IMG_NULL;
psDevInfo->ui32RegSize = 0;
psDevInfo->sRegsPhysBase.uiAddr = 0;
break;
}
#endif /* SUPPORT_MSVDX */
default:
/* Ignore unknowns */
break;
}
psDeviceNodeList = psDeviceNodeList->psNext;
}
#if defined(NO_HARDWARE)
#if defined(SUPPORT_MSVDX)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_DUMMY_MSVDX_REGS))
{
PVR_ASSERT(gsMSVDXDeviceMap);
OSBaseFreeContigMemory(MSVDX_REG_SIZE,
gsMSVDXDeviceMap.sRegsCpuVBase,
gsMSVDXDeviceMap.sRegsCpuPBase);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_DUMMY_MSVDX_REGS);
}
#endif /* defined(SUPPORT_MSVDX) */
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_DUMMY_SGX_REGS))
{
OSBaseFreeContigMemory(SYS_SGX_REG_SIZE,
gsSGXDeviceMap.pvRegsCpuVBase,
gsSGXDeviceMap.sRegsCpuPBase);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_DUMMY_SGX_REGS);
}
#endif /* defined(NO_HARDWARE) */
#if !defined(NO_HARDWARE)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_SOC_REGS_MAPPED))
{
OSUnMapPhysToLin(gsSOCDeviceMap.sRegsCpuVBase,
SYS_SOC_REG_SIZE,
PVRSRV_HAP_KERNEL_ONLY | PVRSRV_HAP_UNCACHED,
IMG_NULL);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_SOC_REGS_MAPPED);
}
#endif
return PVRSRV_OK;
}
PVRSRV_ERROR SysSystemPostPowerState(PVRSRV_SYS_POWER_STATE eNewPowerState)
{
#if !defined(SUPPORT_DRI_DRM_EXT)
PVRSRV_ERROR eError = PVRSRV_OK;
if (eNewPowerState != gpsSysData->eCurrentPowerState)
{
if ((gpsSysData->eCurrentPowerState == PVRSRV_SYS_POWER_STATE_D3) &&
(eNewPowerState < PVRSRV_SYS_POWER_STATE_D3))
{
eError = OSPCIResumeDev(gsSysSpecificData.hSGXPCI);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSPCIResumeDev failed (%d)", eError));
return eError;
}
eError = SysLocateDevices(gpsSysData);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: Failed to locate devices"));
return eError;
}
eError = SysMapInRegisters();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: Failed to map in registers"));
return eError;
}
#if defined(SYS_USING_INTERRUPTS)
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR))
{
eError = OSInstallSystemLISR(gpsSysData, gsSGXDeviceMap.ui32IRQ);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"SysSystemPostPowerState: OSInstallSystemLISR failed to install ISR (%d)", eError));
}
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_LISR_INSTALLED);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_UNINSTALL_LISR);
}
#endif
if (SYS_SPECIFIC_DATA_TEST(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE))
{
SysEnableInterrupts(gpsSysData);
SYS_SPECIFIC_DATA_SET(&gsSysSpecificData, SYS_SPECIFIC_DATA_IRQ_ENABLED);
SYS_SPECIFIC_DATA_CLEAR(&gsSysSpecificData, SYS_SPECIFIC_DATA_PM_IRQ_DISABLE);
}
}
}
return eError;
#else
PVR_UNREFERENCED_PARAMETER(eNewPowerState);
return PVRSRV_ERROR_NOT_SUPPORTED;
#endif
}
