static PVRSRV_ERROR
_ContiguousPDumpBytes(const IMG_CHAR *pszSymbolicName,
IMG_UINT32 ui32SymAddrOffset,
IMG_BOOL bFlush,
IMG_UINT32 uiNumBytes,
IMG_VOID *pvBytes,
IMG_UINT32 ui32Flags)
{
static const IMG_CHAR *pvBeyondLastPointer;
static const IMG_CHAR *pvBasePointer;
static IMG_UINT32 ui32BeyondLastOffset;
static IMG_UINT32 ui32BaseOffset;
static IMG_UINT32 uiAccumulatedBytes = 0;
IMG_UINT32 ui32ParamOutPos;
PVRSRV_ERROR eErr = PVRSRV_OK;
PDUMP_GET_SCRIPT_AND_FILE_STRING();
PVR_UNREFERENCED_PARAMETER(ui32MaxLenFileName);
if (!bFlush && uiAccumulatedBytes > 0)
{
/* do some tests for contiguity. If it fails, we flush anyway */
if (pvBeyondLastPointer != pvBytes ||
ui32SymAddrOffset != ui32BeyondLastOffset
/* NB: ought to check that symbolic name agrees too, but
we know this always to be the case in the current use-case */
)
{
bFlush = IMG_TRUE;
}
}
/* Flush if necessary */
if (bFlush && uiAccumulatedBytes > 0)
{
eErr = PDumpWriteParameter((IMG_UINT8 *)(IMG_UINTPTR_T)pvBasePointer,
uiAccumulatedBytes, ui32Flags,
&ui32ParamOutPos, pszFileName);
PVR_LOGG_IF_ERROR(eErr, "PDumpWriteParameter", ErrOut);
eErr = PDumpOSBufprintf(hScript, ui32MaxLenScript,
"LDB %s:0x%X 0x%X 0x%X %s",
/* dest */
pszSymbolicName,
ui32BaseOffset,
/* size */
uiAccumulatedBytes,
/* file offset */
ui32ParamOutPos,
/* filename */
pszFileName);
PVR_LOGG_IF_ERROR(eErr, "PDumpOSBufprintf", ErrOut);
PDumpWriteScript(hScript, ui32Flags);
uiAccumulatedBytes = 0;
}
/* Initialise offsets and pointers if necessary */
if (uiAccumulatedBytes == 0)
{
ui32BaseOffset = ui32BeyondLastOffset = ui32SymAddrOffset;
pvBeyondLastPointer = pvBasePointer = (const IMG_CHAR *)pvBytes;
}
/* Accumulate some bytes */
ui32BeyondLastOffset += uiNumBytes;
pvBeyondLastPointer += uiNumBytes;
uiAccumulatedBytes += uiNumBytes;
ErrOut:
return eErr;
}
IMG_INTERNAL
PVRSRV_ERROR TLClientOpenStream(IMG_HANDLE hSrvHandle,
IMG_PCHAR pszName,
IMG_UINT32 ui32Mode,
IMG_HANDLE* phSD)
{
PVRSRV_ERROR eError = PVRSRV_OK;
TL_STREAM_DESC* psSD = 0;
DEVMEM_SERVER_EXPORTCOOKIE hServerExportCookie;
PVR_ASSERT(hSrvHandle);
PVR_ASSERT(pszName);
PVR_ASSERT(phSD);
*phSD = NULL;
/* Allocate memory for the stream descriptor object, initialise with
* "no data read" yet. */
psSD = OSAllocZMem(sizeof(TL_STREAM_DESC));
if (psSD == NULL)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
PVR_DPF((PVR_DBG_ERROR, "BridgeTLOpenStream: KM returned %d", eError));
goto e0;
}
psSD->uiReadLen = psSD->uiReadOffset = NO_ACQUIRE;
/* Send open stream request to kernel server to get stream handle and
* buffer cookie so we can get access to the buffer in this process. */
eError = BridgeTLOpenStream(hSrvHandle, pszName, ui32Mode,
&psSD->hServerSD, &hServerExportCookie);
if (eError != PVRSRV_OK)
{
if ((ui32Mode & PVRSRV_STREAM_FLAG_OPEN_WAIT) &&
(eError == PVRSRV_ERROR_TIMEOUT))
{
goto e1;
}
PVR_LOGG_IF_ERROR(eError, "BridgeTLOpenStream", e1);
}
/* Convert server export cookie into a cookie for use by this client */
eError = DevmemMakeServerExportClientExport(hSrvHandle,
hServerExportCookie, &psSD->sExportCookie);
PVR_LOGG_IF_ERROR(eError, "DevmemMakeServerExportClientExport", e2);
/* Now convert client cookie into a client handle on the buffer's
* physical memory region */
eError = DevmemImport(hSrvHandle, &psSD->sExportCookie,
PVRSRV_MEMALLOCFLAG_CPU_READABLE, "TLClientCookie", &psSD->psUMmemDesc);
PVR_LOGG_IF_ERROR(eError, "DevmemImport", e3);
/* Now map the memory into the virtual address space of this process. */
eError = DevmemAcquireCpuVirtAddr(psSD->psUMmemDesc, (IMG_PVOID *)
&psSD->pBaseAddr);
PVR_LOGG_IF_ERROR(eError, "DevmemAcquireCpuVirtAddr", e4);
/* Return client descriptor handle to caller */
*phSD = psSD;
return PVRSRV_OK;
/* Clean up post buffer setup */
e4:
DevmemFree(psSD->psUMmemDesc);
e3:
(void) DevmemUnmakeServerExportClientExport(hSrvHandle,
&psSD->sExportCookie);
/* Clean up post stream open */
e2:
BridgeTLCloseStream(hSrvHandle, psSD->hServerSD);
/* Cleanup post allocation of the descriptor object */
e1:
OSFreeMem(psSD);
e0:
return eError;
}
/*******************************************************************************
* 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);
}
