IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMemKM(IMG_HANDLE hDevCookie,
PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
PVRSRV_ERROR eError;
PVR_UNREFERENCED_PARAMETER(hDevCookie);
if (!psMemInfo)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
if (psMemInfo->sMemBlk.hResItem != IMG_NULL)
{
eError = ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem, CLEANUP_WITH_POLL);
}
else
{
eError = FreeDeviceMemCallBack(psMemInfo, 0, CLEANUP_WITH_POLL);
}
return eError;
}
IMG_EXPORT PVRSRV_ERROR
SGXUnrefSharedPBDescKM(IMG_HANDLE hSharedPBDesc)
{
PVR_ASSERT(hSharedPBDesc != IMG_NULL);
return ResManFreeResByPtr(hSharedPBDesc, CLEANUP_WITH_POLL);
}
enum PVRSRV_ERROR SGXUnrefSharedPBDescKM(void *hSharedPBDesc)
{
PVR_ASSERT(hSharedPBDesc != NULL);
ResManFreeResByPtr(hSharedPBDesc);
return PVRSRV_OK;
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVUnwrapExtMemoryKM (PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
if (!psMemInfo)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
return ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem, CLEANUP_WITH_POLL);
}
IMG_EXPORT
PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceMemoryKM (PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
if (!psMemInfo)
{
return PVRSRV_ERROR_INVALID_PARAMS;
}
return ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
}
enum PVRSRV_ERROR PVRSRVUnmapDeviceMemoryKM(
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
if (!psMemInfo)
return PVRSRV_ERROR_INVALID_PARAMS;
ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
return PVRSRV_OK;
}
static PVRSRV_ERROR
PMRSecureUnexportPMRResManProxy(IMG_HANDLE hResmanItem)
{
PVRSRV_ERROR eError;
eError = ResManFreeResByPtr(hResmanItem);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
return eError;
}
static PVRSRV_ERROR UnmapDeviceMemoryCallBack(IMG_PVOID pvParam,
IMG_UINT32 ui32Param)
{
PVRSRV_ERROR eError;
RESMAN_MAP_DEVICE_MEM_DATA *psMapData = pvParam;
PVR_UNREFERENCED_PARAMETER(ui32Param);
if(psMapData->psMemInfo->sMemBlk.psIntSysPAddr)
{
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMapData->psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL);
psMapData->psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL;
}
eError = FreeDeviceMem(psMapData->psMemInfo);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free DST meminfo"));
return eError;
}
psMapData->psSrcMemInfo->ui32RefCount--;
if (psMapData->psSrcMemInfo->ui32RefCount == 1 &&
psMapData->psSrcMemInfo->bPendingFree == IMG_TRUE)
{
if (psMapData->psSrcMemInfo->sMemBlk.hResItem != IMG_NULL)
{
eError = ResManFreeResByPtr(psMapData->psSrcMemInfo->sMemBlk.hResItem);
if (eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR,"UnmapDeviceMemoryCallBack: Failed to free SRC meminfo"));
PVR_DBG_BREAK;
}
}
else
{
eError = FreeDeviceMemCallBack(psMapData->psSrcMemInfo, 0);
}
}
OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_MAP_DEVICE_MEM_DATA), psMapData, IMG_NULL);
return eError;
}
static PVRSRV_ERROR
SyncPrimOpDestroyResManProxy(IMG_HANDLE hResmanItem)
{
PVRSRV_ERROR eError;
eError = ResManFreeResByPtr(hResmanItem);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
return eError;
}
enum PVRSRV_ERROR PVRSRVFreeSharedSysMemoryKM(
struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo)
{
enum PVRSRV_ERROR eError = PVRSRV_OK;
if (psKernelMemInfo->sMemBlk.hResItem)
ResManFreeResByPtr(psKernelMemInfo->sMemBlk.hResItem);
else
eError = FreeSharedSysMemCallBack(psKernelMemInfo, 0);
return eError;
}
static PVRSRV_ERROR
RIDeleteMEMDESCEntryResManProxy(IMG_HANDLE hResmanItem)
{
PVRSRV_ERROR eError;
eError = ResManFreeResByPtr(hResmanItem);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
return eError;
}
static PVRSRV_ERROR
ReleaseGlobalEventObjectResManProxy(IMG_HANDLE hResmanItem)
{
PVRSRV_ERROR eError;
eError = ResManFreeResByPtr(hResmanItem);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
return eError;
}
enum PVRSRV_ERROR PVRSRVCloseDCDeviceKM(void *hDeviceKM,
IMG_BOOL bResManCallback)
{
struct PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
PVR_UNREFERENCED_PARAMETER(bResManCallback);
psDCPerContextInfo = (struct PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *)
hDeviceKM;
ResManFreeResByPtr(psDCPerContextInfo->hResItem);
return PVRSRV_OK;
}
enum PVRSRV_ERROR PVRSRVFreeDeviceMemKM(void *hDevCookie,
struct PVRSRV_KERNEL_MEM_INFO *psMemInfo)
{
PVR_UNREFERENCED_PARAMETER(hDevCookie);
if (!psMemInfo)
return PVRSRV_ERROR_INVALID_PARAMS;
if (psMemInfo->sMemBlk.hResItem != NULL)
ResManFreeResByPtr(psMemInfo->sMemBlk.hResItem);
else
FreeDeviceMemCallBack(psMemInfo, 0);
return PVRSRV_OK;
}
enum PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(void *hSwapChain)
{
struct PVRSRV_DC_SWAPCHAIN *psSwapChain;
if (!hSwapChain) {
PVR_DPF(PVR_DBG_ERROR,
"PVRSRVDestroyDCSwapChainKM: Invalid parameters");
return PVRSRV_ERROR_INVALID_PARAMS;
}
psSwapChain = hSwapChain;
ResManFreeResByPtr(psSwapChain->hResItem);
return PVRSRV_OK;
}
IMG_EXPORT PVRSRV_ERROR
PVRSRVFreeSharedSysMemoryKM(PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo)
{
PVRSRV_ERROR eError;
if(psKernelMemInfo->sMemBlk.hResItem)
{
eError = ResManFreeResByPtr(psKernelMemInfo->sMemBlk.hResItem);
}
else
{
eError = FreeSharedSysMemCallBack(psKernelMemInfo, 0);
}
return eError;
}
IMG_EXPORT
PVRSRV_ERROR PVRSRVCloseDCDeviceKM (IMG_HANDLE hDeviceKM,
IMG_BOOL bResManCallback)
{
PVRSRV_ERROR eError;
PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *psDCPerContextInfo;
PVR_UNREFERENCED_PARAMETER(bResManCallback);
psDCPerContextInfo = (PVRSRV_DISPLAYCLASS_PERCONTEXT_INFO *)hDeviceKM;
eError = ResManFreeResByPtr(psDCPerContextInfo->hResItem);
return eError;
}
IMG_EXPORT
PVRSRV_ERROR PVRSRVDestroyDCSwapChainKM(IMG_HANDLE hSwapChain)
{
PVRSRV_ERROR eError;
PVRSRV_DC_SWAPCHAIN *psSwapChain;
if(!hSwapChain)
{
PVR_DPF((PVR_DBG_ERROR,"PVRSRVDestroyDCSwapChainKM: Invalid parameters"));
return PVRSRV_ERROR_INVALID_PARAMS;
}
psSwapChain = hSwapChain;
eError = ResManFreeResByPtr(psSwapChain->hResItem);
return eError;
}
void BM_DestroyContext(void *hBMContext)
{
struct BM_CONTEXT *pBMContext = (struct BM_CONTEXT *)hBMContext;
struct BM_HEAP *psBMHeap;
PVR_DPF(PVR_DBG_MESSAGE, "BM_DestroyContext");
for (psBMHeap = pBMContext->psBMHeap;
psBMHeap != NULL; psBMHeap = psBMHeap->psNext)
if (psBMHeap->ui32Attribs &
(PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG |
PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG))
if (psBMHeap->pImportArena) {
IMG_BOOL bTestDelete =
RA_TestDelete(psBMHeap->pImportArena);
BUG_ON(!bTestDelete);
}
ResManFreeResByPtr(pBMContext->hResItem);
}
/*!
******************************************************************************
@Function LinuxEventObjectDelete
@Description
Linux wait object removal
@Input hOSEventObjectList : Event object list handle
@Input hOSEventObject : Event object handle
@Input bResManCallback : Called from the resman
@Return PVRSRV_ERROR : Error code
******************************************************************************/
PVRSRV_ERROR LinuxEventObjectDelete(IMG_HANDLE hOSEventObjectList, IMG_HANDLE hOSEventObject)
{
if(hOSEventObjectList)
{
if(hOSEventObject)
{
PVRSRV_LINUX_EVENT_OBJECT *psLinuxEventObject = (PVRSRV_LINUX_EVENT_OBJECT *)hOSEventObject;
#if defined(DEBUG)
PVR_DPF((PVR_DBG_MESSAGE, "LinuxEventObjectListDelete: Event object waits: %u", psLinuxEventObject->ui32Stats));
#endif
if(ResManFreeResByPtr(psLinuxEventObject->hResItem, CLEANUP_WITH_POLL) != PVRSRV_OK)
{
return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
}
return PVRSRV_OK;
}
}
return PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT;
}
IMG_EXPORT PVRSRV_ERROR
SGXAddSharedPBDescKM(PVRSRV_PER_PROCESS_DATA *psPerProc,
IMG_HANDLE hDevCookie,
PVRSRV_KERNEL_MEM_INFO *psSharedPBDescKernelMemInfo,
PVRSRV_KERNEL_MEM_INFO *psHWPBDescKernelMemInfo,
PVRSRV_KERNEL_MEM_INFO *psBlockKernelMemInfo,
PVRSRV_KERNEL_MEM_INFO *psHWBlockKernelMemInfo,
IMG_UINT32 ui32TotalPBSize,
IMG_HANDLE *phSharedPBDesc,
PVRSRV_KERNEL_MEM_INFO **ppsSharedPBDescSubKernelMemInfos,
IMG_UINT32 ui32SharedPBDescSubKernelMemInfosCount,
IMG_DEV_VIRTADDR sHWPBDescDevVAddr)
{
PVRSRV_STUB_PBDESC *psStubPBDesc=IMG_NULL;
PVRSRV_ERROR eRet = PVRSRV_ERROR_INVALID_PERPROC;
IMG_UINT32 i;
PVRSRV_SGXDEV_INFO *psSGXDevInfo;
PRESMAN_ITEM psResItem;
if (psPerProcCreateSharedPB != psPerProc)
{
goto NoAdd;
}
else
{
PVR_ASSERT(psResItemCreateSharedPB != IMG_NULL);
ResManFreeResByPtr(psResItemCreateSharedPB, CLEANUP_WITH_POLL);
PVR_ASSERT(psResItemCreateSharedPB == IMG_NULL);
PVR_ASSERT(psPerProcCreateSharedPB == IMG_NULL);
}
psSGXDevInfo = (PVRSRV_SGXDEV_INFO *)((PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
psStubPBDesc = psSGXDevInfo->psStubPBDescListKM;
if (psStubPBDesc != IMG_NULL)
{
if(psStubPBDesc->ui32TotalPBSize != ui32TotalPBSize)
{
PVR_DPF((PVR_DBG_WARNING,
"SGXAddSharedPBDescKM: Shared PB requested with different size (0x%x) from existing shared PB (0x%x) - requested size ignored",
ui32TotalPBSize, psStubPBDesc->ui32TotalPBSize));
}
psResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_PB_DESC,
psStubPBDesc,
0,
&SGXCleanupSharedPBDescCallback);
if (psResItem == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR,
"SGXAddSharedPBDescKM: "
"Failed to register existing shared "
"PBDesc with the resource manager"));
goto NoAddKeepPB;
}
psStubPBDesc->ui32RefCount++;
*phSharedPBDesc = (IMG_HANDLE)psResItem;
eRet = PVRSRV_OK;
goto NoAddKeepPB;
}
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_STUB_PBDESC),
(IMG_VOID **)&psStubPBDesc,
0,
"Stub Parameter Buffer Description") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: Failed to alloc "
"StubPBDesc"));
eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
goto NoAdd;
}
psStubPBDesc->ppsSubKernelMemInfos = IMG_NULL;
if(OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO *)
* ui32SharedPBDescSubKernelMemInfosCount,
(IMG_VOID **)&psStubPBDesc->ppsSubKernelMemInfos,
0,
"Array of Kernel Memory Info") != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to alloc "
"StubPBDesc->ppsSubKernelMemInfos"));
eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
goto NoAdd;
}
if(PVRSRVDissociateMemFromResmanKM(psSharedPBDescKernelMemInfo)
!= PVRSRV_OK)
{
goto NoAdd;
}
if(PVRSRVDissociateMemFromResmanKM(psHWPBDescKernelMemInfo)
!= PVRSRV_OK)
{
goto NoAdd;
}
if(PVRSRVDissociateMemFromResmanKM(psBlockKernelMemInfo)
!= PVRSRV_OK)
{
goto NoAdd;
}
if(PVRSRVDissociateMemFromResmanKM(psHWBlockKernelMemInfo)
!= PVRSRV_OK)
{
goto NoAdd;
}
psStubPBDesc->ui32RefCount = 1;
psStubPBDesc->ui32TotalPBSize = ui32TotalPBSize;
psStubPBDesc->psSharedPBDescKernelMemInfo = psSharedPBDescKernelMemInfo;
psStubPBDesc->psHWPBDescKernelMemInfo = psHWPBDescKernelMemInfo;
psStubPBDesc->psBlockKernelMemInfo = psBlockKernelMemInfo;
psStubPBDesc->psHWBlockKernelMemInfo = psHWBlockKernelMemInfo;
psStubPBDesc->ui32SubKernelMemInfosCount =
ui32SharedPBDescSubKernelMemInfosCount;
for(i=0; i<ui32SharedPBDescSubKernelMemInfosCount; i++)
{
psStubPBDesc->ppsSubKernelMemInfos[i] = ppsSharedPBDescSubKernelMemInfos[i];
if(PVRSRVDissociateMemFromResmanKM(ppsSharedPBDescSubKernelMemInfos[i])
!= PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to dissociate shared PBDesc "
"from process"));
goto NoAdd;
}
}
psStubPBDesc->sHWPBDescDevVAddr = sHWPBDescDevVAddr;
psResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_PB_DESC,
psStubPBDesc,
0,
&SGXCleanupSharedPBDescCallback);
if (psResItem == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to register shared PBDesc "
" with the resource manager"));
goto NoAdd;
}
psStubPBDesc->hDevCookie = hDevCookie;
List_PVRSRV_STUB_PBDESC_Insert(&(psSGXDevInfo->psStubPBDescListKM),
psStubPBDesc);
*phSharedPBDesc = (IMG_HANDLE)psResItem;
return PVRSRV_OK;
NoAdd:
if(psStubPBDesc)
{
if(psStubPBDesc->ppsSubKernelMemInfos)
{
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_KERNEL_MEM_INFO *) * ui32SharedPBDescSubKernelMemInfosCount,
psStubPBDesc->ppsSubKernelMemInfos,
0);
psStubPBDesc->ppsSubKernelMemInfos = IMG_NULL;
}
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(PVRSRV_STUB_PBDESC),
psStubPBDesc,
0);
}
NoAddKeepPB:
for (i = 0; i < ui32SharedPBDescSubKernelMemInfosCount; i++)
{
PVRSRVFreeDeviceMemKM(hDevCookie, ppsSharedPBDescSubKernelMemInfos[i]);
}
PVRSRVFreeSharedSysMemoryKM(psSharedPBDescKernelMemInfo);
PVRSRVFreeDeviceMemKM(hDevCookie, psHWPBDescKernelMemInfo);
PVRSRVFreeSharedSysMemoryKM(psBlockKernelMemInfo);
PVRSRVFreeDeviceMemKM(hDevCookie, psHWBlockKernelMemInfo);
return eRet;
}
static IMG_INT
PVRSRVBridgeAcquireGlobalEventObject(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_ACQUIREGLOBALEVENTOBJECT *psAcquireGlobalEventObjectIN,
PVRSRV_BRIDGE_OUT_ACQUIREGLOBALEVENTOBJECT *psAcquireGlobalEventObjectOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hGlobalEventObjectInt = IMG_NULL;
IMG_HANDLE hGlobalEventObjectInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_ACQUIREGLOBALEVENTOBJECT);
PVR_UNREFERENCED_PARAMETER(psAcquireGlobalEventObjectIN);
psAcquireGlobalEventObjectOUT->eError =
AcquireGlobalEventObjectServer(
&hGlobalEventObjectInt);
/* Exit early if bridged call fails */
if(psAcquireGlobalEventObjectOUT->eError != PVRSRV_OK)
{
goto AcquireGlobalEventObject_exit;
}
/* Create a resman item and overwrite the handle with it */
hGlobalEventObjectInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_SHARED_EVENT_OBJECT,
hGlobalEventObjectInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&ReleaseGlobalEventObjectServer);
if (hGlobalEventObjectInt2 == IMG_NULL)
{
psAcquireGlobalEventObjectOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto AcquireGlobalEventObject_exit;
}
psAcquireGlobalEventObjectOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psAcquireGlobalEventObjectOUT->hGlobalEventObject,
(IMG_HANDLE) hGlobalEventObjectInt2,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT,
PVRSRV_HANDLE_ALLOC_FLAG_SHARED
);
if (psAcquireGlobalEventObjectOUT->eError != PVRSRV_OK)
{
goto AcquireGlobalEventObject_exit;
}
AcquireGlobalEventObject_exit:
if (psAcquireGlobalEventObjectOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hGlobalEventObjectInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hGlobalEventObjectInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (hGlobalEventObjectInt)
{
ReleaseGlobalEventObjectServer(hGlobalEventObjectInt);
}
}
return 0;
}
static IMG_INT
PVRSRVBridgePMRSecureExportPMR(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_PMRSECUREEXPORTPMR *psPMRSecureExportPMRIN,
PVRSRV_BRIDGE_OUT_PMRSECUREEXPORTPMR *psPMRSecureExportPMROUT,
CONNECTION_DATA *psConnection)
{
PMR * psPMRInt = IMG_NULL;
IMG_HANDLE hPMRInt2 = IMG_NULL;
PMR * psPMROutInt = IMG_NULL;
IMG_HANDLE hPMROutInt2 = IMG_NULL;
CONNECTION_DATA *psSecureConnection;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SMM_PMRSECUREEXPORTPMR);
{
/* Look up the address from the handle */
psPMRSecureExportPMROUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRInt2,
psPMRSecureExportPMRIN->hPMR,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if(psPMRSecureExportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureExportPMR_exit;
}
/* Look up the data from the resman address */
psPMRSecureExportPMROUT->eError = ResManFindPrivateDataByPtr(hPMRInt2, (IMG_VOID **) &psPMRInt);
if(psPMRSecureExportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureExportPMR_exit;
}
}
psPMRSecureExportPMROUT->eError =
PMRSecureExportPMR(psConnection,
psPMRInt,
&psPMRSecureExportPMROUT->Export,
&psPMROutInt, &psSecureConnection);
/* Exit early if bridged call fails */
if(psPMRSecureExportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureExportPMR_exit;
}
/* Create a resman item and overwrite the handle with it */
hPMROutInt2 = ResManRegisterRes(psSecureConnection->hResManContext,
RESMAN_TYPE_PMR,
psPMROutInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&PMRSecureUnexportPMR);
if (hPMROutInt2 == IMG_NULL)
{
psPMRSecureExportPMROUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto PMRSecureExportPMR_exit;
}
PMRSecureExportPMR_exit:
if (psPMRSecureExportPMROUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hPMROutInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hPMROutInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psPMROutInt)
{
PMRSecureUnexportPMR(psPMROutInt);
}
}
return 0;
}
static IMG_INT
PVRSRVBridgeRGXCreateComputeContext(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXCREATECOMPUTECONTEXT *psRGXCreateComputeContextIN,
PVRSRV_BRIDGE_OUT_RGXCREATECOMPUTECONTEXT *psRGXCreateComputeContextOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
IMG_BYTE *psFrameworkCmdInt = IMG_NULL;
IMG_HANDLE hPrivDataInt = IMG_NULL;
RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXCREATECOMPUTECONTEXT);
if (psRGXCreateComputeContextIN->ui32FrameworkCmdize != 0)
{
psFrameworkCmdInt = OSAllocMem(psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE));
if (!psFrameworkCmdInt)
{
psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXCreateComputeContext_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXCreateComputeContextIN->psFrameworkCmd, psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE))
|| (OSCopyFromUser(NULL, psFrameworkCmdInt, psRGXCreateComputeContextIN->psFrameworkCmd,
psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE)) != PVRSRV_OK) )
{
psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXCreateComputeContext_exit;
}
{
/* Look up the address from the handle */
psRGXCreateComputeContextOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXCreateComputeContextIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXCreateComputeContext_exit;
}
}
{
/* Look up the address from the handle */
psRGXCreateComputeContextOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPrivDataInt,
psRGXCreateComputeContextIN->hPrivData,
PVRSRV_HANDLE_TYPE_DEV_PRIV_DATA);
if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXCreateComputeContext_exit;
}
}
psRGXCreateComputeContextOUT->eError =
PVRSRVRGXCreateComputeContextKM(psConnection,
hDevNodeInt,
psRGXCreateComputeContextIN->ui32Priority,
psRGXCreateComputeContextIN->sMCUFenceAddr,
psRGXCreateComputeContextIN->ui32FrameworkCmdize,
psFrameworkCmdInt,
hPrivDataInt,
&psComputeContextInt);
/* Exit early if bridged call fails */
if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXCreateComputeContext_exit;
}
/* Create a resman item and overwrite the handle with it */
hComputeContextInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_RGX_SERVER_COMPUTE_CONTEXT,
psComputeContextInt,
(RESMAN_FREE_FN)&PVRSRVRGXDestroyComputeContextKM);
if (hComputeContextInt2 == IMG_NULL)
{
psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto RGXCreateComputeContext_exit;
}
psRGXCreateComputeContextOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psRGXCreateComputeContextOUT->hComputeContext,
(IMG_HANDLE) hComputeContextInt2,
PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXCreateComputeContext_exit;
}
RGXCreateComputeContext_exit:
if (psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hComputeContextInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hComputeContextInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psComputeContextInt)
{
PVRSRVRGXDestroyComputeContextKM(psComputeContextInt);
}
}
if (psFrameworkCmdInt)
OSFreeMem(psFrameworkCmdInt);
return 0;
}
static IMG_INT
PVRSRVBridgeEventObjectOpen(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_EVENTOBJECTOPEN *psEventObjectOpenIN,
PVRSRV_BRIDGE_OUT_EVENTOBJECTOPEN *psEventObjectOpenOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hEventObjectInt = IMG_NULL;
IMG_HANDLE hEventObjectInt2 = IMG_NULL;
IMG_HANDLE hOSEventInt = IMG_NULL;
IMG_HANDLE hOSEventInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_EVENTOBJECTOPEN);
{
/* Look up the address from the handle */
psEventObjectOpenOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hEventObjectInt2,
psEventObjectOpenIN->hEventObject,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
if(psEventObjectOpenOUT->eError != PVRSRV_OK)
{
goto EventObjectOpen_exit;
}
/* Look up the data from the resman address */
psEventObjectOpenOUT->eError = ResManFindPrivateDataByPtr(hEventObjectInt2, (IMG_VOID **) &hEventObjectInt);
if(psEventObjectOpenOUT->eError != PVRSRV_OK)
{
goto EventObjectOpen_exit;
}
}
psEventObjectOpenOUT->eError =
OSEventObjectOpen(
hEventObjectInt,
&hOSEventInt);
/* Exit early if bridged call fails */
if(psEventObjectOpenOUT->eError != PVRSRV_OK)
{
goto EventObjectOpen_exit;
}
/* Create a resman item and overwrite the handle with it */
hOSEventInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_EVENT_OBJECT,
hOSEventInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&OSEventObjectClose);
if (hOSEventInt2 == IMG_NULL)
{
psEventObjectOpenOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto EventObjectOpen_exit;
}
psEventObjectOpenOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psEventObjectOpenOUT->hOSEvent,
(IMG_HANDLE) hOSEventInt2,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
PVRSRV_HANDLE_ALLOC_FLAG_MULTI
);
if (psEventObjectOpenOUT->eError != PVRSRV_OK)
{
goto EventObjectOpen_exit;
}
EventObjectOpen_exit:
if (psEventObjectOpenOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hOSEventInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hOSEventInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (hOSEventInt)
{
OSEventObjectClose(hOSEventInt);
}
}
return 0;
}
static IMG_INT
PVRSRVBridgeTLOpenStream(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_TLOPENSTREAM *psTLOpenStreamIN,
PVRSRV_BRIDGE_OUT_TLOPENSTREAM *psTLOpenStreamOUT,
CONNECTION_DATA *psConnection)
{
IMG_CHAR *uiNameInt = IMG_NULL;
TL_STREAM_DESC * psSDInt = IMG_NULL;
IMG_HANDLE hSDInt2 = IMG_NULL;
DEVMEM_EXPORTCOOKIE * psClientBUFExportCookieInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PVRTL_TLOPENSTREAM);
psTLOpenStreamOUT->hSD = IMG_NULL;
{
uiNameInt = OSAllocMem(PRVSRVTL_MAX_STREAM_NAME_SIZE * sizeof(IMG_CHAR));
if (!uiNameInt)
{
psTLOpenStreamOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto TLOpenStream_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psTLOpenStreamIN->puiName, PRVSRVTL_MAX_STREAM_NAME_SIZE * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiNameInt, psTLOpenStreamIN->puiName,
PRVSRVTL_MAX_STREAM_NAME_SIZE * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psTLOpenStreamOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto TLOpenStream_exit;
}
psTLOpenStreamOUT->eError =
TLServerOpenStreamKM(
uiNameInt,
psTLOpenStreamIN->ui32Mode,
&psSDInt,
&psClientBUFExportCookieInt);
/* Exit early if bridged call fails */
if(psTLOpenStreamOUT->eError != PVRSRV_OK)
{
goto TLOpenStream_exit;
}
/* Create a resman item and overwrite the handle with it */
hSDInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_TL_STREAM_DESC,
psSDInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&TLServerCloseStreamKM);
if (hSDInt2 == IMG_NULL)
{
psTLOpenStreamOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto TLOpenStream_exit;
}
psTLOpenStreamOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psTLOpenStreamOUT->hSD,
(IMG_HANDLE) hSDInt2,
PVRSRV_HANDLE_TYPE_PVR_TL_SD,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psTLOpenStreamOUT->eError != PVRSRV_OK)
{
goto TLOpenStream_exit;
}
psTLOpenStreamOUT->eError = PVRSRVAllocSubHandle(psConnection->psHandleBase,
&psTLOpenStreamOUT->hClientBUFExportCookie,
(IMG_HANDLE) psClientBUFExportCookieInt,
PVRSRV_HANDLE_TYPE_SERVER_EXPORTCOOKIE,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
,psTLOpenStreamOUT->hSD);
if (psTLOpenStreamOUT->eError != PVRSRV_OK)
{
goto TLOpenStream_exit;
}
TLOpenStream_exit:
if (psTLOpenStreamOUT->eError != PVRSRV_OK)
{
if (psTLOpenStreamOUT->hSD)
{
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psTLOpenStreamOUT->hSD,
PVRSRV_HANDLE_TYPE_PVR_TL_SD);
}
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hSDInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hSDInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psSDInt)
{
TLServerCloseStreamKM(psSDInt);
}
}
if (uiNameInt)
OSFreeMem(uiNameInt);
return 0;
}
enum PVRSRV_ERROR SGXAddSharedPBDescKM(
struct PVRSRV_PER_PROCESS_DATA *psPerProc,
void *hDevCookie,
struct PVRSRV_KERNEL_MEM_INFO *psSharedPBDescKernelMemInfo,
struct PVRSRV_KERNEL_MEM_INFO *psHWPBDescKernelMemInfo,
struct PVRSRV_KERNEL_MEM_INFO *psBlockKernelMemInfo,
u32 ui32TotalPBSize, void **phSharedPBDesc,
struct PVRSRV_KERNEL_MEM_INFO **ppsSharedPBDescSubKernelMemInfos,
u32 ui32SharedPBDescSubKernelMemInfosCount)
{
struct PVRSRV_STUB_PBDESC *psStubPBDesc = NULL;
enum PVRSRV_ERROR eRet = PVRSRV_ERROR_GENERIC;
u32 i;
struct PVRSRV_SGXDEV_INFO *psSGXDevInfo;
struct RESMAN_ITEM *psResItem;
if (psPerProcCreateSharedPB != psPerProc) {
goto NoAdd;
} else {
PVR_ASSERT(psResItemCreateSharedPB != NULL);
ResManFreeResByPtr(psResItemCreateSharedPB);
PVR_ASSERT(psResItemCreateSharedPB == NULL);
PVR_ASSERT(psPerProcCreateSharedPB == NULL);
}
psSGXDevInfo = (struct PVRSRV_SGXDEV_INFO *)
((struct PVRSRV_DEVICE_NODE *)hDevCookie)->pvDevice;
psStubPBDesc = psSGXDevInfo->psStubPBDescListKM;
if (psStubPBDesc != NULL) {
if (psStubPBDesc->ui32TotalPBSize != ui32TotalPBSize) {
PVR_DPF(PVR_DBG_WARNING, "SGXAddSharedPBDescKM: "
"Shared PB requested with different size "
"(0x%x) from existing shared PB (0x%x) - "
"requested size ignored",
ui32TotalPBSize,
psStubPBDesc->ui32TotalPBSize);
}
psResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_PB_DESC,
psStubPBDesc, 0,
&SGXCleanupSharedPBDescCallback);
if (psResItem == NULL) {
PVR_DPF(PVR_DBG_ERROR,
"SGXAddSharedPBDescKM: "
"Failed to register existing shared "
"PBDesc with the resource manager");
goto NoAddKeepPB;
}
psStubPBDesc->ui32RefCount++;
*phSharedPBDesc = (void *) psResItem;
eRet = PVRSRV_OK;
goto NoAddKeepPB;
}
if (OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct PVRSRV_STUB_PBDESC),
(void **)&psStubPBDesc, NULL) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "SGXAddSharedPBDescKM: Failed to alloc "
"StubPBDesc");
eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
goto NoAdd;
}
psStubPBDesc->ppsSubKernelMemInfos = NULL;
if (OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct PVRSRV_KERNEL_MEM_INFO *) *
ui32SharedPBDescSubKernelMemInfosCount,
(void **)&psStubPBDesc->ppsSubKernelMemInfos, NULL) !=
PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to alloc "
"StubPBDesc->ppsSubKernelMemInfos");
eRet = PVRSRV_ERROR_OUT_OF_MEMORY;
goto NoAdd;
}
if (PVRSRVDissociateMemFromResmanKM(psSharedPBDescKernelMemInfo)
!= PVRSRV_OK)
goto NoAdd;
if (PVRSRVDissociateMemFromResmanKM(psHWPBDescKernelMemInfo)
!= PVRSRV_OK)
goto NoAdd;
if (PVRSRVDissociateMemFromResmanKM(psBlockKernelMemInfo)
!= PVRSRV_OK)
goto NoAdd;
psStubPBDesc->ui32RefCount = 1;
psStubPBDesc->ui32TotalPBSize = ui32TotalPBSize;
psStubPBDesc->psSharedPBDescKernelMemInfo = psSharedPBDescKernelMemInfo;
psStubPBDesc->psHWPBDescKernelMemInfo = psHWPBDescKernelMemInfo;
psStubPBDesc->psBlockKernelMemInfo = psBlockKernelMemInfo;
psStubPBDesc->ui32SubKernelMemInfosCount =
ui32SharedPBDescSubKernelMemInfosCount;
for (i = 0; i < ui32SharedPBDescSubKernelMemInfosCount; i++) {
psStubPBDesc->ppsSubKernelMemInfos[i] =
ppsSharedPBDescSubKernelMemInfos[i];
if (PVRSRVDissociateMemFromResmanKM
(ppsSharedPBDescSubKernelMemInfos[i]) != PVRSRV_OK) {
PVR_DPF(PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to dissociate shared PBDesc "
"from process");
goto NoAdd;
}
}
psResItem = ResManRegisterRes(psPerProc->hResManContext,
RESMAN_TYPE_SHARED_PB_DESC,
psStubPBDesc,
0, &SGXCleanupSharedPBDescCallback);
if (psResItem == NULL) {
PVR_DPF(PVR_DBG_ERROR, "SGXAddSharedPBDescKM: "
"Failed to register shared PBDesc "
" with the resource manager");
goto NoAdd;
}
psStubPBDesc->hDevCookie = hDevCookie;
psStubPBDesc->psNext = psSGXDevInfo->psStubPBDescListKM;
psSGXDevInfo->psStubPBDescListKM = psStubPBDesc;
*phSharedPBDesc = (void *) psResItem;
return PVRSRV_OK;
NoAdd:
if (psStubPBDesc) {
if (psStubPBDesc->ppsSubKernelMemInfos) {
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct PVRSRV_KERNEL_MEM_INFO *) *
ui32SharedPBDescSubKernelMemInfosCount,
psStubPBDesc->ppsSubKernelMemInfos, NULL);
}
OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
sizeof(struct PVRSRV_STUB_PBDESC), psStubPBDesc,
NULL);
}
NoAddKeepPB:
for (i = 0; i < ui32SharedPBDescSubKernelMemInfosCount; i++)
PVRSRVFreeDeviceMemKM(hDevCookie,
ppsSharedPBDescSubKernelMemInfos[i]);
PVRSRVFreeSharedSysMemoryKM(psSharedPBDescKernelMemInfo);
PVRSRVFreeDeviceMemKM(hDevCookie, psHWPBDescKernelMemInfo);
PVRSRVFreeSharedSysMemoryKM(psBlockKernelMemInfo);
return eRet;
}
static IMG_INT
PVRSRVBridgeSyncPrimOpCreate(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMOPCREATE *psSyncPrimOpCreateIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMOPCREATE *psSyncPrimOpCreateOUT,
CONNECTION_DATA *psConnection)
{
SYNC_PRIMITIVE_BLOCK * *psBlockListInt = IMG_NULL;
IMG_HANDLE *hBlockListInt2 = IMG_NULL;
IMG_UINT32 *ui32SyncBlockIndexInt = IMG_NULL;
IMG_UINT32 *ui32IndexInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerSyncInt = IMG_NULL;
IMG_HANDLE *hServerSyncInt2 = IMG_NULL;
SERVER_OP_COOKIE * psServerCookieInt = IMG_NULL;
IMG_HANDLE hServerCookieInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMOPCREATE);
if (psSyncPrimOpCreateIN->ui32SyncBlockCount != 0)
{
psBlockListInt = OSAllocMem(psSyncPrimOpCreateIN->ui32SyncBlockCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
if (!psBlockListInt)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
hBlockListInt2 = OSAllocMem(psSyncPrimOpCreateIN->ui32SyncBlockCount * sizeof(IMG_HANDLE));
if (!hBlockListInt2)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpCreateIN->phBlockList, psSyncPrimOpCreateIN->ui32SyncBlockCount * sizeof(IMG_HANDLE))
|| (OSCopyFromUser(NULL, hBlockListInt2, psSyncPrimOpCreateIN->phBlockList,
psSyncPrimOpCreateIN->ui32SyncBlockCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpCreate_exit;
}
if (psSyncPrimOpCreateIN->ui32ClientSyncCount != 0)
{
ui32SyncBlockIndexInt = OSAllocMem(psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32));
if (!ui32SyncBlockIndexInt)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpCreateIN->pui32SyncBlockIndex, psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32SyncBlockIndexInt, psSyncPrimOpCreateIN->pui32SyncBlockIndex,
psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpCreate_exit;
}
if (psSyncPrimOpCreateIN->ui32ClientSyncCount != 0)
{
ui32IndexInt = OSAllocMem(psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32));
if (!ui32IndexInt)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpCreateIN->pui32Index, psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32IndexInt, psSyncPrimOpCreateIN->pui32Index,
psSyncPrimOpCreateIN->ui32ClientSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpCreate_exit;
}
if (psSyncPrimOpCreateIN->ui32ServerSyncCount != 0)
{
psServerSyncInt = OSAllocMem(psSyncPrimOpCreateIN->ui32ServerSyncCount * sizeof(SERVER_SYNC_PRIMITIVE *));
if (!psServerSyncInt)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
hServerSyncInt2 = OSAllocMem(psSyncPrimOpCreateIN->ui32ServerSyncCount * sizeof(IMG_HANDLE));
if (!hServerSyncInt2)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpCreate_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpCreateIN->phServerSync, psSyncPrimOpCreateIN->ui32ServerSyncCount * sizeof(IMG_HANDLE))
|| (OSCopyFromUser(NULL, hServerSyncInt2, psSyncPrimOpCreateIN->phServerSync,
psSyncPrimOpCreateIN->ui32ServerSyncCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpCreate_exit;
}
{
IMG_UINT32 i;
for (i=0;i<psSyncPrimOpCreateIN->ui32SyncBlockCount;i++)
{
{
/* Look up the address from the handle */
psSyncPrimOpCreateOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hBlockListInt2[i],
psSyncPrimOpCreateIN->phBlockList[i],
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
if(psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
/* Look up the data from the resman address */
psSyncPrimOpCreateOUT->eError = ResManFindPrivateDataByPtr(hBlockListInt2[i], (IMG_VOID **) &psBlockListInt[i]);
if(psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
}
}
}
{
IMG_UINT32 i;
for (i=0;i<psSyncPrimOpCreateIN->ui32ServerSyncCount;i++)
{
{
/* Look up the address from the handle */
psSyncPrimOpCreateOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hServerSyncInt2[i],
psSyncPrimOpCreateIN->phServerSync[i],
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
if(psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
/* Look up the data from the resman address */
psSyncPrimOpCreateOUT->eError = ResManFindPrivateDataByPtr(hServerSyncInt2[i], (IMG_VOID **) &psServerSyncInt[i]);
if(psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
}
}
}
psSyncPrimOpCreateOUT->eError =
PVRSRVSyncPrimOpCreateKM(
psSyncPrimOpCreateIN->ui32SyncBlockCount,
psBlockListInt,
psSyncPrimOpCreateIN->ui32ClientSyncCount,
ui32SyncBlockIndexInt,
ui32IndexInt,
psSyncPrimOpCreateIN->ui32ServerSyncCount,
psServerSyncInt,
&psServerCookieInt);
/* Exit early if bridged call fails */
if(psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
/* Create a resman item and overwrite the handle with it */
hServerCookieInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_SERVER_OP_COOKIE,
psServerCookieInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&PVRSRVSyncPrimOpDestroyKM);
if (hServerCookieInt2 == IMG_NULL)
{
psSyncPrimOpCreateOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto SyncPrimOpCreate_exit;
}
psSyncPrimOpCreateOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psSyncPrimOpCreateOUT->hServerCookie,
(IMG_HANDLE) hServerCookieInt2,
PVRSRV_HANDLE_TYPE_SERVER_OP_COOKIE,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpCreate_exit;
}
SyncPrimOpCreate_exit:
if (psSyncPrimOpCreateOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hServerCookieInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hServerCookieInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psServerCookieInt)
{
PVRSRVSyncPrimOpDestroyKM(psServerCookieInt);
}
}
if (psBlockListInt)
OSFreeMem(psBlockListInt);
if (hBlockListInt2)
OSFreeMem(hBlockListInt2);
if (ui32SyncBlockIndexInt)
OSFreeMem(ui32SyncBlockIndexInt);
if (ui32IndexInt)
OSFreeMem(ui32IndexInt);
if (psServerSyncInt)
OSFreeMem(psServerSyncInt);
if (hServerSyncInt2)
OSFreeMem(hServerSyncInt2);
return 0;
}
static IMG_INT
PVRSRVBridgeServerSyncAlloc(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SERVERSYNCALLOC *psServerSyncAllocIN,
PVRSRV_BRIDGE_OUT_SERVERSYNCALLOC *psServerSyncAllocOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SERVERSYNCALLOC);
{
/* Look up the address from the handle */
psServerSyncAllocOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psServerSyncAllocIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psServerSyncAllocOUT->eError != PVRSRV_OK)
{
goto ServerSyncAlloc_exit;
}
}
psServerSyncAllocOUT->eError =
PVRSRVServerSyncAllocKM(
hDevNodeInt,
&psSyncHandleInt,
&psServerSyncAllocOUT->ui32SyncPrimVAddr);
/* Exit early if bridged call fails */
if(psServerSyncAllocOUT->eError != PVRSRV_OK)
{
goto ServerSyncAlloc_exit;
}
/* Create a resman item and overwrite the handle with it */
hSyncHandleInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_SERVER_SYNC_PRIMITIVE,
psSyncHandleInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&PVRSRVServerSyncFreeKM);
if (hSyncHandleInt2 == IMG_NULL)
{
psServerSyncAllocOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto ServerSyncAlloc_exit;
}
psServerSyncAllocOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psServerSyncAllocOUT->hSyncHandle,
(IMG_HANDLE) hSyncHandleInt2,
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psServerSyncAllocOUT->eError != PVRSRV_OK)
{
goto ServerSyncAlloc_exit;
}
ServerSyncAlloc_exit:
if (psServerSyncAllocOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hSyncHandleInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hSyncHandleInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psSyncHandleInt)
{
PVRSRVServerSyncFreeKM(psSyncHandleInt);
}
}
return 0;
}
static IMG_INT
PVRSRVBridgeAllocSyncPrimitiveBlock(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_ALLOCSYNCPRIMITIVEBLOCK *psAllocSyncPrimitiveBlockIN,
PVRSRV_BRIDGE_OUT_ALLOCSYNCPRIMITIVEBLOCK *psAllocSyncPrimitiveBlockOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
SYNC_PRIMITIVE_BLOCK * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
DEVMEM_EXPORTCOOKIE * psExportCookieInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_ALLOCSYNCPRIMITIVEBLOCK);
psAllocSyncPrimitiveBlockOUT->hSyncHandle = IMG_NULL;
{
/* Look up the address from the handle */
psAllocSyncPrimitiveBlockOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psAllocSyncPrimitiveBlockIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psAllocSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto AllocSyncPrimitiveBlock_exit;
}
}
psAllocSyncPrimitiveBlockOUT->eError =
PVRSRVAllocSyncPrimitiveBlockKM(psConnection,
hDevNodeInt,
&psSyncHandleInt,
&psAllocSyncPrimitiveBlockOUT->ui32SyncPrimVAddr,
&psAllocSyncPrimitiveBlockOUT->ui32SyncPrimBlockSize,
&psExportCookieInt);
/* Exit early if bridged call fails */
if(psAllocSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto AllocSyncPrimitiveBlock_exit;
}
/* Create a resman item and overwrite the handle with it */
hSyncHandleInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_SYNC_PRIMITIVE_BLOCK,
psSyncHandleInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&PVRSRVFreeSyncPrimitiveBlockKM);
if (hSyncHandleInt2 == IMG_NULL)
{
psAllocSyncPrimitiveBlockOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto AllocSyncPrimitiveBlock_exit;
}
psAllocSyncPrimitiveBlockOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psAllocSyncPrimitiveBlockOUT->hSyncHandle,
(IMG_HANDLE) hSyncHandleInt2,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psAllocSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto AllocSyncPrimitiveBlock_exit;
}
psAllocSyncPrimitiveBlockOUT->eError = PVRSRVAllocSubHandle(psConnection->psHandleBase,
&psAllocSyncPrimitiveBlockOUT->hExportCookie,
(IMG_HANDLE) psExportCookieInt,
PVRSRV_HANDLE_TYPE_SERVER_EXPORTCOOKIE,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
,psAllocSyncPrimitiveBlockOUT->hSyncHandle);
if (psAllocSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto AllocSyncPrimitiveBlock_exit;
}
AllocSyncPrimitiveBlock_exit:
if (psAllocSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
if (psAllocSyncPrimitiveBlockOUT->hSyncHandle)
{
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psAllocSyncPrimitiveBlockOUT->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
}
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hSyncHandleInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hSyncHandleInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psSyncHandleInt)
{
PVRSRVFreeSyncPrimitiveBlockKM(psSyncHandleInt);
}
}
return 0;
}
