void PVRSRVPerProcessDataDisconnect(u32 ui32PID)
{
enum PVRSRV_ERROR eError;
struct PVRSRV_PER_PROCESS_DATA *psPerProc;
PVR_ASSERT(psHashTab != NULL);
psPerProc = (struct PVRSRV_PER_PROCESS_DATA *)HASH_Retrieve(psHashTab,
(u32)ui32PID);
if (psPerProc == NULL) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVPerProcessDataDealloc: "
"Couldn't locate per-process data for PID %u",
ui32PID);
} else {
psPerProc->ui32RefCount--;
if (psPerProc->ui32RefCount == 0) {
PVR_DPF(PVR_DBG_MESSAGE,
"PVRSRVPerProcessDataDisconnect: "
"Last close from process 0x%x received",
ui32PID);
PVRSRVResManDisconnect(psPerProc->hResManContext,
IMG_FALSE);
eError = FreePerProcessData(psPerProc);
if (eError != PVRSRV_OK)
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVPerProcessDataDisconnect: "
"Error freeing per-process data");
}
}
}
/*!
******************************************************************************
@Function PVRSRVPerProcessDataDisconnect
@Description Decrement refcount for per-process data area,
and free the resources if necessary.
@Input ui32PID - process ID
@Return IMG_VOID
******************************************************************************/
IMG_VOID PVRSRVPerProcessDataDisconnect(IMG_UINT32 ui32PID)
{
PVRSRV_ERROR eError;
PVRSRV_PER_PROCESS_DATA *psPerProc;
PVR_ASSERT(psHashTab != IMG_NULL);
psPerProc = (PVRSRV_PER_PROCESS_DATA *)HASH_Retrieve(psHashTab, (IMG_UINTPTR_T)ui32PID);
if (psPerProc == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDealloc: Couldn't locate per-process data for PID %u", ui32PID));
}
else
{
psPerProc->ui32RefCount--;
if (psPerProc->ui32RefCount == 0)
{
PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVPerProcessDataDisconnect: "
"Last close from process 0x%x received", ui32PID));
/* Close the Resource Manager connection */
PVRSRVResManDisconnect(psPerProc->hResManContext, IMG_FALSE);
#if defined (TTRACE)
PVRSRVTimeTraceBufferDestroy(ui32PID);
#endif
/* Free the per-process data */
eError = FreePerProcessData(psPerProc);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDisconnect: Error freeing per-process data"));
}
}
}
eError = PVRSRVPurgeHandles(KERNEL_HANDLE_BASE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVPerProcessDataDisconnect: Purge of global handle pool failed (%d)", eError));
}
}
/* PVRSRVConnectionDisconnect */
IMG_VOID PVRSRVConnectionDisconnect(IMG_PVOID pvDataPtr)
{
PVRSRV_ERROR eError;
CONNECTION_DATA *psConnection = pvDataPtr;
/* Close the Resource Manager connection */
PVRSRVResManDisconnect(psConnection->hResManContext);
/* Free the connection data */
eError = FreeConnectionData(psConnection);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionDisconnect: Error freeing per-process data"));
}
/* FIXME: Is this still required? */
eError = PVRSRVPurgeHandles(KERNEL_HANDLE_BASE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionDisconnect: Purge of global handle pool failed (%d)", eError));
}
}
/* PVRSRVConnectionDisconnect */
IMG_VOID PVRSRVConnectionDisconnect(IMG_PVOID pvDataPtr)
{
PVRSRV_ERROR eError;
CONNECTION_DATA *psConnection = pvDataPtr;
/* Close the Resource Manager connection */
PVRSRVResManDisconnect(psConnection->hResManContext);
/*
Unregister with the sync core. Logically this is after resman to
ensure that any sync block that haven't been freed by the app will
be freed by resman 1st.
However, due to the fact the resman can defer the free the Sync core
needs to handle the case where the connection data is destroyed while
Sync blocks are still in it.
*/
SyncUnregisterConnection(psConnection->psSyncConnectionData);
/*
Unregister with the PDump core, see the note above about logical order
and refcounting as it also applies to the PDump connection data
*/
PDumpUnregisterConnection(psConnection->psPDumpConnectionData);
/* Free the connection data */
eError = FreeConnectionData(psConnection);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionDisconnect: Error freeing per-process data"));
}
eError = PVRSRVPurgeHandles(KERNEL_HANDLE_BASE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRVConnectionDisconnect: Purge of global handle pool failed (%d)", eError));
}
}
PVRSRV_ERROR IMG_CALLCONV PVRSRVDeinitialiseDevice(IMG_UINT32 ui32DevIndex)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
SysAcquireData(&psSysData);
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
&MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_TRUE);
if (!psDeviceNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: requested device %d is not present", ui32DevIndex));
return PVRSRV_ERROR_DEVICEID_NOT_FOUND;
}
eError = PVRSRVSetDevicePowerStateKM(ui32DevIndex,
PVRSRV_DEV_POWER_STATE_OFF,
KERNEL_ID,
IMG_FALSE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed PVRSRVSetDevicePowerStateKM call"));
return eError;
}
eError = ResManFreeResByCriteria(psDeviceNode->hResManContext,
RESMAN_CRITERIA_RESTYPE,
RESMAN_TYPE_DEVICEMEM_ALLOCATION,
IMG_NULL, 0);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed ResManFreeResByCriteria call"));
return eError;
}
if(psDeviceNode->pfnDeInitDevice != IMG_NULL)
{
eError = psDeviceNode->pfnDeInitDevice(psDeviceNode);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed DeInitDevice call"));
return eError;
}
}
PVRSRVResManDisconnect(psDeviceNode->hResManContext, IMG_TRUE);
psDeviceNode->hResManContext = IMG_NULL;
List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
(IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
return (PVRSRV_OK);
}
/*!
******************************************************************************
@Function PVRSRVDeinitialiseDevice
@Description
This De-inits device
@Input ui32DevIndex : Index to the required device
@Return PVRSRV_ERROR :
******************************************************************************/
PVRSRV_ERROR IMG_CALLCONV PVRSRVDeinitialiseDevice(IMG_UINT32 ui32DevIndex)
{
PVRSRV_DEVICE_NODE *psDeviceNode;
SYS_DATA *psSysData;
PVRSRV_ERROR eError;
SysAcquireData(&psSysData);
psDeviceNode = (PVRSRV_DEVICE_NODE*)
List_PVRSRV_DEVICE_NODE_Any_va(psSysData->psDeviceNodeList,
&MatchDeviceKM_AnyVaCb,
ui32DevIndex,
IMG_TRUE);
if (!psDeviceNode)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: requested device %d is not present", ui32DevIndex));
return PVRSRV_ERROR_DEVICEID_NOT_FOUND;
}
eError = PVRSRVPowerLock(KERNEL_ID, IMG_FALSE);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed PVRSRVPowerLock call"));
return eError;
}
/*
Power down the device if necessary.
*/
eError = PVRSRVSetDevicePowerStateKM(ui32DevIndex,
PVRSRV_DEV_POWER_STATE_OFF);
PVRSRVPowerUnlock(KERNEL_ID);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed PVRSRVSetDevicePowerStateKM call"));
return eError;
}
/*
Free the dissociated device memory.
*/
eError = ResManFreeResByCriteria(psDeviceNode->hResManContext,
RESMAN_CRITERIA_RESTYPE,
RESMAN_TYPE_DEVICEMEM_ALLOCATION,
IMG_NULL, 0);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed ResManFreeResByCriteria call"));
return eError;
}
/*
De-init the device.
*/
if(psDeviceNode->pfnDeInitDevice != IMG_NULL)
{
eError = psDeviceNode->pfnDeInitDevice(psDeviceNode);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeinitialiseDevice: Failed DeInitDevice call"));
return eError;
}
}
/*
Close the device's resource manager context.
*/
PVRSRVResManDisconnect(psDeviceNode->hResManContext, IMG_TRUE);
psDeviceNode->hResManContext = IMG_NULL;
/* remove node from list */
List_PVRSRV_DEVICE_NODE_Remove(psDeviceNode);
/* deallocate id and memory */
(IMG_VOID)FreeDeviceID(psSysData, ui32DevIndex);
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL);
/*not nulling pointer, out of scope*/
return (PVRSRV_OK);
}
enum PVRSRV_ERROR PVRSRVDeinitialiseDevice(u32 ui32DevIndex)
{
struct PVRSRV_DEVICE_NODE *psDeviceNode;
struct PVRSRV_DEVICE_NODE **ppsDevNode;
struct SYS_DATA *psSysData;
enum PVRSRV_ERROR eError;
eError = SysAcquireData(&psSysData);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDeinitialiseDevice: Failed to get SysData");
return eError;
}
ppsDevNode = &psSysData->psDeviceNodeList;
while (*ppsDevNode) {
if ((*ppsDevNode)->sDevId.ui32DeviceIndex == ui32DevIndex) {
psDeviceNode = *ppsDevNode;
goto FoundDevice;
}
ppsDevNode = &((*ppsDevNode)->psNext);
}
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDeinitialiseDevice: requested device %d is not present",
ui32DevIndex);
return PVRSRV_ERROR_GENERIC;
FoundDevice:
eError = PVRSRVSetDevicePowerStateKM(ui32DevIndex,
PVRSRV_POWER_STATE_D3,
KERNEL_ID, IMG_FALSE);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVDeinitialiseDevice: "
"Failed PVRSRVSetDevicePowerStateKM call");
return eError;
}
ResManFreeResByCriteria(psDeviceNode->hResManContext,
RESMAN_CRITERIA_RESTYPE,
RESMAN_TYPE_DEVICEMEM_ALLOCATION,
NULL, 0);
if (psDeviceNode->pfnDeInitDevice != NULL) {
eError = psDeviceNode->pfnDeInitDevice(psDeviceNode);
if (eError != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVDeinitialiseDevice: "
"Failed DeInitDevice call");
return eError;
}
}
PVRSRVResManDisconnect(psDeviceNode->hResManContext, IMG_TRUE);
psDeviceNode->hResManContext = NULL;
*ppsDevNode = psDeviceNode->psNext;
FreeDeviceID(psSysData, ui32DevIndex);
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct PVRSRV_DEVICE_NODE), psDeviceNode, NULL);
return PVRSRV_OK;
}
