void PVRSRVDeInit(struct SYS_DATA *psSysData)
{
enum PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(psSysData);
if (psSysData == NULL) {
PVR_DPF(PVR_DBG_ERROR, "PVRSRVDeInit: "
"PVRSRVHandleDeInit failed - invalid param");
return;
}
if (psSysData->psGlobalEventObject) {
OSEventObjectDestroy(psSysData->psGlobalEventObject);
OSFreeMem(PVRSRV_PAGEABLE_SELECT,
sizeof(struct PVRSRV_EVENTOBJECT),
psSysData->psGlobalEventObject, NULL);
}
eError = PVRSRVHandleDeInit();
if (eError != PVRSRV_OK)
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDeInit: PVRSRVHandleDeInit failed");
eError = PVRSRVPerProcessDataDeInit();
if (eError != PVRSRV_OK)
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDeInit: PVRSRVPerProcessDataDeInit failed");
ResManDeInit();
}
IMG_VOID
TLStreamClose(IMG_HANDLE hStream)
{
PTL_STREAM psTmp;
PVR_DPF_ENTERED;
if ( IMG_NULL == hStream )
{
PVR_DPF((PVR_DBG_WARNING,
"TLStreamClose failed as NULL stream handler passed, nothing done.\n"));
PVR_DPF_RETURN;
}
psTmp = (PTL_STREAM)hStream;
/* Decrement reference counter */
//Thread Safety: Not yet implemented OSLockAcquire(psTmp->hLock);
psTmp->uiRefCount--;
//Thread Safety: Not yet implemented OSLockRelease(psTmp->hLock);
/* The stream is still being used in other context(s) do not destroy anything */
if ( 0 != psTmp->uiRefCount )
{
PVR_DPF_RETURN;
}
else
{
if ( psTmp->bWaitForEmptyOnDestroy == IMG_TRUE )
{
while (psTmp->ui32Read != psTmp->ui32Write)
{
OSEventObjectWaitTimeout(psTmp->hProducerEvent,
EVENT_OBJECT_TIMEOUT_MS);
}
}
/* First remove it from the global structures to prevent access
* while it is being free'd. Lock it?
*/
TLRemoveStreamAndTryFreeStreamNode(psTmp->psNode);
//Thread Safety: Not yet implemented OSLockDestroy(psTmp->hLock);
// In block-while-reserve streams those not be NULL
if ( IMG_TRUE == psTmp->bBlock )
{
OSEventObjectClose(psTmp->hProducerEvent);
OSEventObjectDestroy(psTmp->hProducerEventObj);
}
DevmemUnexport(psTmp->psStreamMemDesc, &psTmp->sExportCookie);
DevmemReleaseCpuVirtAddr(psTmp->psStreamMemDesc);
DevmemFree(psTmp->psStreamMemDesc);
OSFREEMEM(psTmp);
PVR_DPF_RETURN;
}
}
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;
}
IMG_VOID IMG_CALLCONV PVRSRVDeInit(PSYS_DATA psSysData)
{
PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(psSysData);
if (psSysData == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed - invalid param"));
return;
}
if( (g_ui32InitFlags & INIT_DATA_ENABLE_PDUMPINIT) > 0)
{
PDUMPDEINIT();
}
if(psSysData->psGlobalEventObject)
{
OSEventObjectDestroy(psSysData->psGlobalEventObject);
OSFreeMem( PVRSRV_PAGEABLE_SELECT,
sizeof(PVRSRV_EVENTOBJECT),
psSysData->psGlobalEventObject,
0);
psSysData->psGlobalEventObject = IMG_NULL;
}
eError = PVRSRVHandleDeInit();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed"));
}
eError = PVRSRVPerProcessDataDeInit();
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVPerProcessDataDeInit failed"));
}
ResManDeInit();
}
IMG_VOID
TLDeInit(IMG_VOID)
{
PVR_DPF_ENTERED;
if (sTLGlobalData.uiClientCnt)
{
PVR_DPF((PVR_DBG_ERROR, "TLDeInit transport layer but %d client streams are still connected", sTLGlobalData.uiClientCnt));
sTLGlobalData.uiClientCnt = 0;
}
/* Clean up the SNODE list */
if (sTLGlobalData.psHead)
{
while (sTLGlobalData.psHead)
{
RemoveAndFreeStreamNode(sTLGlobalData.psHead);
}
/* Leave psHead NULL on loop exit */
}
/* Clean up the TL global event object */
if (sTLGlobalData.hTLEventObj)
{
OSEventObjectDestroy(sTLGlobalData.hTLEventObj);
sTLGlobalData.hTLEventObj = NULL;
}
/* Destroy the TL global data lock */
if (sTLGlobalData.hTLGDLock)
{
OSLockDestroy (sTLGlobalData.hTLGDLock);
sTLGlobalData.hTLGDLock = NULL;
}
sTLGlobalData.psRgxDevNode = NULL;
PVR_DPF_RETURN;
}
/*******************************************************************************
* TL Server public API implementation.
******************************************************************************/
PVRSRV_ERROR
TLStreamCreate(IMG_HANDLE *phStream,
IMG_CHAR *szStreamName,
IMG_UINT32 ui32Size,
IMG_UINT32 ui32StreamFlags,
TL_STREAM_SOURCECB pfProducerCB,
IMG_PVOID pvProducerUD)
{
PTL_STREAM psTmp;
PVRSRV_ERROR eError;
IMG_HANDLE hEventList;
PTL_SNODE psn = 0;
IMG_CHAR pszBufferLabel[PRVSRVTL_MAX_STREAM_NAME_SIZE+20];
DEVMEM_FLAGS_T uiMemFlags = PVRSRV_MEMALLOCFLAG_CPU_READABLE |
PVRSRV_MEMALLOCFLAG_CPU_WRITEABLE |
PVRSRV_MEMALLOCFLAG_GPU_READABLE |
PVRSRV_MEMALLOCFLAG_GPU_WRITEABLE |
PVRSRV_MEMALLOCFLAG_UNCACHED | /* GPU & CPU */
PVRSRV_MEMALLOCFLAG_ZERO_ON_ALLOC |
PVRSRV_MEMALLOCFLAG_CPU_WRITE_COMBINE;
PVR_DPF_ENTERED;
/* Sanity checks: */
/* non NULL handler required */
if ( NULL == phStream )
{
PVR_DPF_RETURN_RC(PVRSRV_ERROR_INVALID_PARAMS);
}
if (OSStringLength(szStreamName) >= PRVSRVTL_MAX_STREAM_NAME_SIZE)
{
PVR_DPF_RETURN_RC(PVRSRV_ERROR_INVALID_PARAMS);
}
/* Check if there already exists a stream with this name. */
psn = TLFindStreamNodeByName( szStreamName );
if ( IMG_NULL != psn )
{
PVR_DPF_RETURN_RC(PVRSRV_ERROR_ALREADY_EXISTS);
}
/* Allocate stream structure container (stream struct) for the new stream */
psTmp = OSAllocZMem(sizeof(TL_STREAM)) ;
if ( NULL == psTmp )
{
PVR_DPF_RETURN_RC(PVRSRV_ERROR_OUT_OF_MEMORY);
}
OSStringCopy(psTmp->szName, szStreamName);
if ( ui32StreamFlags & TL_FLAG_FORCE_FLUSH )
{
psTmp->bWaitForEmptyOnDestroy = IMG_TRUE;
}
psTmp->bNoSignalOnCommit = (ui32StreamFlags&TL_FLAG_NO_SIGNAL_ON_COMMIT) ? IMG_TRUE : IMG_FALSE;
if ( ui32StreamFlags & TL_FLAG_DROP_DATA )
{
if ( ui32StreamFlags & TL_FLAG_BLOCKING_RESERVE )
{
eError = PVRSRV_ERROR_INVALID_PARAMS;
goto e0;
}
psTmp->bDrop = IMG_TRUE;
}
else if ( ui32StreamFlags & TL_FLAG_BLOCKING_RESERVE )
{ /* Additional synchronization object required for this kind of stream */
psTmp->bBlock = IMG_TRUE;
eError = OSEventObjectCreate(NULL, &psTmp->hProducerEventObj);
if (eError != PVRSRV_OK)
{
goto e0;
}
/* Create an event handle for this kind of stream */
eError = OSEventObjectOpen(psTmp->hProducerEventObj, &psTmp->hProducerEvent);
if (eError != PVRSRV_OK)
{
goto e1;
}
}
/* Remember producer supplied CB and data for later */
psTmp->pfProducerCallback = (IMG_VOID(*)(IMG_VOID))pfProducerCB;
psTmp->pvProducerUserData = pvProducerUD;
/* Round the requested bytes to a multiple of array elements' size, eg round 3 to 4 */
psTmp->ui32Size = PVRSRVTL_ALIGN(ui32Size);
psTmp->ui32Read = 0;
psTmp->ui32Write = 0;
psTmp->ui32Pending = NOTHING_PENDING;
OSSNPrintf(pszBufferLabel, sizeof(pszBufferLabel), "TLStreamBuf-%s", szStreamName);
/* Allocate memory for the circular buffer and export it to user space. */
eError = DevmemAllocateExportable( IMG_NULL,
(IMG_HANDLE) TLGetGlobalRgxDevice(),
(IMG_DEVMEM_SIZE_T)psTmp->ui32Size,
(IMG_DEVMEM_ALIGN_T) OSGetPageSize(),
uiMemFlags | PVRSRV_MEMALLOCFLAG_KERNEL_CPU_MAPPABLE,
pszBufferLabel,
&psTmp->psStreamMemDesc);
PVR_LOGG_IF_ERROR(eError, "DevmemAllocateExportable", e2);
eError = DevmemAcquireCpuVirtAddr( psTmp->psStreamMemDesc, (IMG_VOID**) &psTmp->pbyBuffer );
PVR_LOGG_IF_ERROR(eError, "DevmemAcquireCpuVirtAddr", e3);
eError = DevmemExport(psTmp->psStreamMemDesc, &(psTmp->sExportCookie));
PVR_LOGG_IF_ERROR(eError, "DevmemExport", e4);
/* Synchronization object to synchronize with user side data transfers. */
eError = OSEventObjectCreate(psTmp->szName, &hEventList);
if (eError != PVRSRV_OK)
{
goto e5;
}
/* Stream created, now reset the reference count to 1 */
psTmp->uiRefCount = 1;
//Thread Safety: Not yet implemented eError = OSLockCreate(&psTmp->hLock, LOCK_TYPE_PASSIVE);
//Thread Safety: Not yet implemented if (eError != PVRSRV_OK)
//Thread Safety: Not yet implemented {
//Thread Safety: Not yet implemented goto e6;
//Thread Safety: Not yet implemented }
/* Now remember the stream in the global TL structures */
psn = TLMakeSNode(hEventList, (TL_STREAM *)psTmp, 0);
if (psn == NULL)
{
eError=PVRSRV_ERROR_OUT_OF_MEMORY;
goto e7;
}
TLAddStreamNode(psn);
/* Best effort signal, client wait timeout will ultimately let it find the
* new stream if this fails, acceptable to avoid cleanup as it is tricky
* at this point */
(void) OSEventObjectSignal(TLGGD()->hTLEventObj);
/* Pass the newly created stream handle back to caller */
*phStream = (IMG_HANDLE)psTmp;
PVR_DPF_RETURN_OK;
e7:
//Thread Safety: Not yet implemented OSLockDestroy(psTmp->hLock);
//Thread Safety: Not yet implemented e6:
OSEventObjectDestroy(hEventList);
e5:
DevmemUnexport(psTmp->psStreamMemDesc, &(psTmp->sExportCookie));
e4:
DevmemReleaseCpuVirtAddr( psTmp->psStreamMemDesc );
e3:
DevmemFree(psTmp->psStreamMemDesc);
e2:
OSEventObjectClose(psTmp->hProducerEvent);
e1:
OSEventObjectDestroy(psTmp->hProducerEventObj);
e0:
OSFREEMEM(psTmp);
PVR_DPF_RETURN_RC(eError);
}
