/*
* Internal stream APIs to server part of Transport Layer, declared in
* header tlintern.h. Direct pointers to stream objects are used here as
* these functions are internal.
*/
IMG_UINT32
TLStreamAcquireReadPos(PTL_STREAM psStream, IMG_UINT32* puiReadOffset)
{
IMG_UINT32 uiReadLen = 0;
IMG_UINT32 ui32LRead, ui32LWrite;
PVR_DPF_ENTERED;
PVR_ASSERT(psStream);
PVR_ASSERT(puiReadOffset);
/* Grab a local copy */
ui32LRead = psStream->ui32Read;
ui32LWrite = psStream->ui32Write;
/* No data available and CB defined - try and get data */
if ((ui32LRead == ui32LWrite) && psStream->pfProducerCallback)
{
PVRSRV_ERROR eRc;
IMG_UINT32 ui32Resp = 0;
eRc = ((TL_STREAM_SOURCECB)psStream->pfProducerCallback)(psStream, TL_SOURCECB_OP_CLIENT_EOS,
&ui32Resp, psStream->pvProducerUserData);
PVR_LOG_IF_ERROR(eRc, "TLStream->pfProducerCallback");
ui32LWrite = psStream->ui32Write;
}
/* No data available... */
if (ui32LRead == ui32LWrite)
{
PVR_DPF_RETURN_VAL(0);
}
/* Data is available to read... */
*puiReadOffset = ui32LRead;
/*PVR_DPF((PVR_DBG_VERBOSE,
* "TLStreamAcquireReadPos Start before: Write:%d, Read:%d, size:%d",
* ui32LWrite, ui32LRead, psStream->ui32Size));
*/
if ( ui32LRead > ui32LWrite )
{ /* CB has wrapped around.
* Return the first contiguous piece of memory, ie [ReadLen,EndOfBuffer]
* and let a subsequent AcquireReadPos read the rest of the Buffer */
/*PVR_DPF((PVR_DBG_VERBOSE, "TLStreamAcquireReadPos buffer has wrapped"));*/
uiReadLen = psStream->ui32Size - ui32LRead;
}
else
{ // CB has not wrapped
uiReadLen = ui32LWrite - ui32LRead;
}
PVR_DPF_RETURN_VAL(uiReadLen);
}
static IMG_VOID RemoveAndFreeStreamNode(PTL_SNODE psRemove)
{
TL_GLOBAL_DATA* psGD = TLGGD();
PTL_SNODE* last;
PTL_SNODE psn;
PVRSRV_ERROR eError;
PVR_DPF_ENTERED;
// Unlink the stream node from the master list
PVR_ASSERT(psGD->psHead);
last = &psGD->psHead;
for (psn = psGD->psHead; psn; psn=psn->psNext)
{
if (psn == psRemove)
{
/* Other calling code may have freed and zero'd the pointers */
if (psn->psRDesc)
{
OSFREEMEM(psn->psRDesc);
}
if (psn->psStream)
{
OSFREEMEM(psn->psStream);
}
*last = psn->psNext;
break;
}
last = &psn->psNext;
}
// Release the event list object owned by the stream node
if (psRemove->hDataEventObj)
{
eError = OSEventObjectDestroy(psRemove->hDataEventObj);
PVR_LOG_IF_ERROR(eError, "OSEventObjectDestroy");
psRemove->hDataEventObj = NULL;
}
// Release the memory of the stream node
OSFREEMEM(psRemove);
PVR_DPF_RETURN;
}
/*!
******************************************************************************
@Function PVRSRVSetDevicePowerStateKM
@Description Set the Device into a new state
@Input ui32DeviceIndex : device index
@Input eNewPowerState : New power state
@Input bForced : TRUE if the transition should not fail (e.g. OS request)
@Return PVRSRV_ERROR
******************************************************************************/
IMG_EXPORT
PVRSRV_ERROR PVRSRVSetDevicePowerStateKM(IMG_UINT32 ui32DeviceIndex,
PVRSRV_DEV_POWER_STATE eNewPowerState,
IMG_BOOL bForced)
{
PVRSRV_DATA* psPVRSRVData = PVRSRVGetPVRSRVData();
PVRSRV_ERROR eError;
PVRSRV_DEV_POWER_STATE eOldPowerState;
eError = PVRSRVGetDevicePowerState(ui32DeviceIndex, &eOldPowerState);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_WARNING, "PVRSRVSetDevicePowerStateKM: Couldn't read power state."));
eOldPowerState = PVRSRV_DEV_POWER_STATE_DEFAULT;
}
#if defined(PDUMP)
if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
{
/*
Pdump a power-up regardless of the default state.
Then disable pdump and transition to the default power state.
This ensures that a power-up is always present in the pdump when necessary.
*/
eError = PVRSRVDevicePrePowerStateKM(IMG_FALSE, ui32DeviceIndex, PVRSRV_DEV_POWER_STATE_ON, bForced);
if(eError != PVRSRV_OK)
{
goto Exit;
}
eError = PVRSRVDevicePostPowerStateKM(IMG_FALSE, ui32DeviceIndex, PVRSRV_DEV_POWER_STATE_ON, bForced);
if (eError != PVRSRV_OK)
{
goto Exit;
}
PDUMPPOWCMDSTART();
}
#endif /* PDUMP */
eError = PVRSRVDevicePrePowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState, bForced);
if(eError != PVRSRV_OK)
{
if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
{
PDUMPPOWCMDEND();
}
goto Exit;
}
eError = PVRSRVDevicePostPowerStateKM(IMG_FALSE, ui32DeviceIndex, eNewPowerState, bForced);
if (eNewPowerState == PVRSRV_DEV_POWER_STATE_DEFAULT)
{
PDUMPPOWCMDEND();
}
/* Signal Device Watchdog Thread about power mode change. */
if (eOldPowerState != eNewPowerState && eNewPowerState == PVRSRV_DEV_POWER_STATE_ON)
{
psPVRSRVData->ui32DevicesWatchdogPwrTrans++;
if (psPVRSRVData->ui32DevicesWatchdogTimeout == DEVICES_WATCHDOG_POWER_OFF_SLEEP_TIMEOUT)
{
if (psPVRSRVData->hDevicesWatchdogEvObj)
{
eError = OSEventObjectSignal(psPVRSRVData->hDevicesWatchdogEvObj);
PVR_LOG_IF_ERROR(eError, "OSEventObjectSignal");
}
}
}
Exit:
if (eError == PVRSRV_ERROR_DEVICE_POWER_CHANGE_DENIED)
{
PVR_DPF((PVR_DBG_MESSAGE,
"PVRSRVSetDevicePowerStateKM : Transition to %d was denied, Forced=%d", eNewPowerState, bForced));
}
else if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_WARNING,
"PVRSRVSetDevicePowerStateKM : Transition to %d FAILED (%s)", eNewPowerState, PVRSRVGetErrorStringKM(eError)));
}
return eError;
}
