static IMG_INT
PVRSRVBridgeConnect(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_CONNECT *psConnectIN,
PVRSRV_BRIDGE_OUT_CONNECT *psConnectOUT,
CONNECTION_DATA *psConnection)
{
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_CONNECT);
PVR_UNREFERENCED_PARAMETER(psConnection);
psConnectOUT->eError =
PVRSRVConnectKM(
psConnectIN->ui32Flags,
psConnectIN->ui32ClientBuildOptions,
psConnectIN->ui32ClientDDKVersion,
psConnectIN->ui32ClientDDKBuild);
return 0;
}
static IMG_INT
PVRSRVBridgeRGXOverallocateBPRegisters(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXOVERALLOCATEBPREGISTERS *psRGXOverallocateBPRegistersIN,
PVRSRV_BRIDGE_OUT_RGXOVERALLOCATEBPREGISTERS *psRGXOverallocateBPRegistersOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_BREAKPOINT_RGXOVERALLOCATEBPREGISTERS);
/* Look up the address from the handle */
psRGXOverallocateBPRegistersOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXOverallocateBPRegistersIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXOverallocateBPRegistersOUT->eError != PVRSRV_OK)
{
goto RGXOverallocateBPRegisters_exit;
}
psRGXOverallocateBPRegistersOUT->eError =
PVRSRVRGXOverallocateBPRegistersKM(
hDevNodeInt,
psRGXOverallocateBPRegistersIN->ui32TempRegs,
psRGXOverallocateBPRegistersIN->ui32SharedRegs);
RGXOverallocateBPRegisters_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRGXSetBreakpoint(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXSETBREAKPOINT *psRGXSetBreakpointIN,
PVRSRV_BRIDGE_OUT_RGXSETBREAKPOINT *psRGXSetBreakpointOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
IMG_HANDLE hPrivDataInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_BREAKPOINT_RGXSETBREAKPOINT);
{
/* Look up the address from the handle */
psRGXSetBreakpointOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXSetBreakpointIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXSetBreakpointOUT->eError != PVRSRV_OK)
{
goto RGXSetBreakpoint_exit;
}
}
{
/* Look up the address from the handle */
psRGXSetBreakpointOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPrivDataInt,
psRGXSetBreakpointIN->hPrivData,
PVRSRV_HANDLE_TYPE_DEV_PRIV_DATA);
if(psRGXSetBreakpointOUT->eError != PVRSRV_OK)
{
goto RGXSetBreakpoint_exit;
}
}
psRGXSetBreakpointOUT->eError =
PVRSRVRGXSetBreakpointKM(
hDevNodeInt,
hPrivDataInt,
psRGXSetBreakpointIN->eFWDataMaster,
psRGXSetBreakpointIN->ui32BreakpointAddr,
psRGXSetBreakpointIN->ui32HandlerAddr,
psRGXSetBreakpointIN->ui32DM);
RGXSetBreakpoint_exit:
return 0;
}
static IMG_INT
PVRSRVBridgePMRSecureImportPMR(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_PMRSECUREIMPORTPMR *psPMRSecureImportPMRIN,
PVRSRV_BRIDGE_OUT_PMRSECUREIMPORTPMR *psPMRSecureImportPMROUT,
CONNECTION_DATA *psConnection)
{
PMR * psPMRInt;
IMG_HANDLE hPMRInt2;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SMM_PMRSECUREIMPORTPMR);
NEW_HANDLE_BATCH_OR_ERROR(psPMRSecureImportPMROUT->eError, psConnection, 1);
psPMRSecureImportPMROUT->eError =
PMRSecureImportPMR(
psPMRSecureImportPMRIN->Export,
&psPMRInt,
&psPMRSecureImportPMROUT->uiSize,
&psPMRSecureImportPMROUT->sAlign);
/* Exit early if bridged call fails */
if(psPMRSecureImportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureImportPMR_exit;
}
/* Create a resman item and overwrite the handle with it */
hPMRInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_PMR,
psPMRInt,
/* FIXME: how can we avoid this cast? */
(RESMAN_FREE_FN)&PMRUnrefPMR);
if (hPMRInt2 == IMG_NULL)
{
psPMRSecureImportPMROUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto PMRSecureImportPMR_exit;
}
PVRSRVAllocHandleNR(psConnection->psHandleBase,
&psPMRSecureImportPMROUT->hPMR,
(IMG_HANDLE) hPMRInt2,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
COMMIT_HANDLE_BATCH_OR_ERROR(psPMRSecureImportPMROUT->eError, psConnection);
PMRSecureImportPMR_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeTLTestIoctl(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_TLTESTIOCTL *psTLTestIoctlIN,
PVRSRV_BRIDGE_OUT_TLTESTIOCTL *psTLTestIoctlOUT,
CONNECTION_DATA *psConnection)
{
IMG_BYTE *psIn1Int = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PVRTL_TLTESTIOCTL);
PVR_UNREFERENCED_PARAMETER(psConnection);
{
psIn1Int = OSAllocMem(PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE));
if (!psIn1Int)
{
psTLTestIoctlOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto TLTestIoctl_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psTLTestIoctlIN->psIn1, PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE))
|| (OSCopyFromUser(NULL, psIn1Int, psTLTestIoctlIN->psIn1,
PVR_TL_TEST_PARAM_MAX_SIZE * sizeof(IMG_BYTE)) != PVRSRV_OK) )
{
psTLTestIoctlOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto TLTestIoctl_exit;
}
psTLTestIoctlOUT->eError =
TLServerTestIoctlKM(
psTLTestIoctlIN->ui32Cmd,
psIn1Int,
psTLTestIoctlIN->ui32In2,
&psTLTestIoctlOUT->ui32Out1,
&psTLTestIoctlOUT->ui32Out2);
TLTestIoctl_exit:
if (psIn1Int)
OSFreeMem(psIn1Int);
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimPDumpPol(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMPDUMPPOL *psSyncPrimPDumpPolIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMPDUMPPOL *psSyncPrimPDumpPolOUT,
CONNECTION_DATA *psConnection)
{
SYNC_PRIMITIVE_BLOCK * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMPDUMPPOL);
{
/* Look up the address from the handle */
psSyncPrimPDumpPolOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psSyncPrimPDumpPolIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
if(psSyncPrimPDumpPolOUT->eError != PVRSRV_OK)
{
goto SyncPrimPDumpPol_exit;
}
/* Look up the data from the resman address */
psSyncPrimPDumpPolOUT->eError = ResManFindPrivateDataByPtr(hSyncHandleInt2, (IMG_VOID **) &psSyncHandleInt);
if(psSyncPrimPDumpPolOUT->eError != PVRSRV_OK)
{
goto SyncPrimPDumpPol_exit;
}
}
psSyncPrimPDumpPolOUT->eError =
PVRSRVSyncPrimPDumpPolKM(
psSyncHandleInt,
psSyncPrimPDumpPolIN->ui32Offset,
psSyncPrimPDumpPolIN->ui32Value,
psSyncPrimPDumpPolIN->ui32Mask,
psSyncPrimPDumpPolIN->eOperator,
psSyncPrimPDumpPolIN->uiPDumpFlags);
SyncPrimPDumpPol_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeEnumerateDevices(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_ENUMERATEDEVICES *psEnumerateDevicesIN,
PVRSRV_BRIDGE_OUT_ENUMERATEDEVICES *psEnumerateDevicesOUT,
CONNECTION_DATA *psConnection)
{
PVRSRV_DEVICE_IDENTIFIER *psDeviceIdentifierInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_ENUMERATEDEVICES);
PVR_UNREFERENCED_PARAMETER(psConnection);
PVR_UNREFERENCED_PARAMETER(psEnumerateDevicesIN);
psEnumerateDevicesOUT->psDeviceIdentifier = psEnumerateDevicesIN->psDeviceIdentifier;
{
psDeviceIdentifierInt = OSAllocMem(PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER));
if (!psDeviceIdentifierInt)
{
psEnumerateDevicesOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto EnumerateDevices_exit;
}
}
psEnumerateDevicesOUT->eError =
PVRSRVEnumerateDevicesKM(
&psEnumerateDevicesOUT->ui32NumDevices,
psDeviceIdentifierInt);
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psEnumerateDevicesOUT->psDeviceIdentifier, (PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER)))
|| (OSCopyToUser(NULL, psEnumerateDevicesOUT->psDeviceIdentifier, psDeviceIdentifierInt,
(PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER))) != PVRSRV_OK) )
{
psEnumerateDevicesOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto EnumerateDevices_exit;
}
EnumerateDevices_exit:
if (psDeviceIdentifierInt)
OSFreeMem(psDeviceIdentifierInt);
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimPDumpCBP(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMPDUMPCBP *psSyncPrimPDumpCBPIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMPDUMPCBP *psSyncPrimPDumpCBPOUT,
CONNECTION_DATA *psConnection)
{
SYNC_PRIMITIVE_BLOCK * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMPDUMPCBP);
{
/* Look up the address from the handle */
psSyncPrimPDumpCBPOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psSyncPrimPDumpCBPIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
if(psSyncPrimPDumpCBPOUT->eError != PVRSRV_OK)
{
goto SyncPrimPDumpCBP_exit;
}
/* Look up the data from the resman address */
psSyncPrimPDumpCBPOUT->eError = ResManFindPrivateDataByPtr(hSyncHandleInt2, (IMG_VOID **) &psSyncHandleInt);
if(psSyncPrimPDumpCBPOUT->eError != PVRSRV_OK)
{
goto SyncPrimPDumpCBP_exit;
}
}
psSyncPrimPDumpCBPOUT->eError =
PVRSRVSyncPrimPDumpCBPKM(
psSyncHandleInt,
psSyncPrimPDumpCBPIN->ui32Offset,
psSyncPrimPDumpCBPIN->uiWriteOffset,
psSyncPrimPDumpCBPIN->uiPacketSize,
psSyncPrimPDumpCBPIN->uiBufferSize);
SyncPrimPDumpCBP_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeServerSyncQueueHWOp(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SERVERSYNCQUEUEHWOP *psServerSyncQueueHWOpIN,
PVRSRV_BRIDGE_OUT_SERVERSYNCQUEUEHWOP *psServerSyncQueueHWOpOUT,
CONNECTION_DATA *psConnection)
{
SERVER_SYNC_PRIMITIVE * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SERVERSYNCQUEUEHWOP);
{
/* Look up the address from the handle */
psServerSyncQueueHWOpOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psServerSyncQueueHWOpIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
if(psServerSyncQueueHWOpOUT->eError != PVRSRV_OK)
{
goto ServerSyncQueueHWOp_exit;
}
/* Look up the data from the resman address */
psServerSyncQueueHWOpOUT->eError = ResManFindPrivateDataByPtr(hSyncHandleInt2, (IMG_VOID **) &psSyncHandleInt);
if(psServerSyncQueueHWOpOUT->eError != PVRSRV_OK)
{
goto ServerSyncQueueHWOp_exit;
}
}
psServerSyncQueueHWOpOUT->eError =
PVRSRVServerSyncQueueHWOpKM(
psSyncHandleInt,
psServerSyncQueueHWOpIN->bbUpdate,
&psServerSyncQueueHWOpOUT->ui32FenceValue,
&psServerSyncQueueHWOpOUT->ui32UpdateValue);
ServerSyncQueueHWOp_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeTLReleaseData(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_TLRELEASEDATA *psTLReleaseDataIN,
PVRSRV_BRIDGE_OUT_TLRELEASEDATA *psTLReleaseDataOUT,
CONNECTION_DATA *psConnection)
{
TL_STREAM_DESC * psSDInt = IMG_NULL;
IMG_HANDLE hSDInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PVRTL_TLRELEASEDATA);
{
/* Look up the address from the handle */
psTLReleaseDataOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSDInt2,
psTLReleaseDataIN->hSD,
PVRSRV_HANDLE_TYPE_PVR_TL_SD);
if(psTLReleaseDataOUT->eError != PVRSRV_OK)
{
goto TLReleaseData_exit;
}
/* Look up the data from the resman address */
psTLReleaseDataOUT->eError = ResManFindPrivateDataByPtr(hSDInt2, (IMG_VOID **) &psSDInt);
if(psTLReleaseDataOUT->eError != PVRSRV_OK)
{
goto TLReleaseData_exit;
}
}
psTLReleaseDataOUT->eError =
TLServerReleaseDataKM(
psSDInt,
psTLReleaseDataIN->ui32ReadOffset,
psTLReleaseDataIN->ui32ReadLen);
TLReleaseData_exit:
return 0;
}
static IMG_INT
PVRSRVBridgePVRSRVPDumpComment(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentIN,
PVRSRV_BRIDGE_OUT_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentOUT,
CONNECTION_DATA *psConnection)
{
IMG_CHAR *uiCommentInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_PVRSRVPDUMPCOMMENT);
PVR_UNREFERENCED_PARAMETER(psConnection);
{
uiCommentInt = OSAllocMem(PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR));
if (!uiCommentInt)
{
psPVRSRVPDumpCommentOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto PVRSRVPDumpComment_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPVRSRVPDumpCommentIN->puiComment, PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiCommentInt, psPVRSRVPDumpCommentIN->puiComment,
PVRSRV_PDUMP_MAX_COMMENT_SIZE * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psPVRSRVPDumpCommentOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto PVRSRVPDumpComment_exit;
}
psPVRSRVPDumpCommentOUT->eError =
PDumpCommentKM(
uiCommentInt,
psPVRSRVPDumpCommentIN->ui32Flags);
PVRSRVPDumpComment_exit:
if (uiCommentInt)
OSFreeMem(uiCommentInt);
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimSet(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMSET *psSyncPrimSetIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMSET *psSyncPrimSetOUT,
CONNECTION_DATA *psConnection)
{
SYNC_PRIMITIVE_BLOCK * psSyncHandleInt = IMG_NULL;
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMSET);
{
/* Look up the address from the handle */
psSyncPrimSetOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psSyncPrimSetIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
if(psSyncPrimSetOUT->eError != PVRSRV_OK)
{
goto SyncPrimSet_exit;
}
/* Look up the data from the resman address */
psSyncPrimSetOUT->eError = ResManFindPrivateDataByPtr(hSyncHandleInt2, (IMG_VOID **) &psSyncHandleInt);
if(psSyncPrimSetOUT->eError != PVRSRV_OK)
{
goto SyncPrimSet_exit;
}
}
psSyncPrimSetOUT->eError =
PVRSRVSyncPrimSetKM(
psSyncHandleInt,
psSyncPrimSetIN->ui32Index,
psSyncPrimSetIN->ui32Value);
SyncPrimSet_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRIUpdateMEMDESCAddr(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RIUPDATEMEMDESCADDR *psRIUpdateMEMDESCAddrIN,
PVRSRV_BRIDGE_OUT_RIUPDATEMEMDESCADDR *psRIUpdateMEMDESCAddrOUT,
CONNECTION_DATA *psConnection)
{
RI_HANDLE psRIHandleInt = IMG_NULL;
IMG_HANDLE hRIHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RI_RIUPDATEMEMDESCADDR);
{
/* Look up the address from the handle */
psRIUpdateMEMDESCAddrOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hRIHandleInt2,
psRIUpdateMEMDESCAddrIN->hRIHandle,
PVRSRV_HANDLE_TYPE_RI_HANDLE);
if(psRIUpdateMEMDESCAddrOUT->eError != PVRSRV_OK)
{
goto RIUpdateMEMDESCAddr_exit;
}
/* Look up the data from the resman address */
psRIUpdateMEMDESCAddrOUT->eError = ResManFindPrivateDataByPtr(hRIHandleInt2, (IMG_VOID **) &psRIHandleInt);
if(psRIUpdateMEMDESCAddrOUT->eError != PVRSRV_OK)
{
goto RIUpdateMEMDESCAddr_exit;
}
}
psRIUpdateMEMDESCAddrOUT->eError =
RIUpdateMEMDESCAddrKM(
psRIHandleInt,
psRIUpdateMEMDESCAddrIN->sAddr);
RIUpdateMEMDESCAddr_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimOpReady(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMOPREADY *psSyncPrimOpReadyIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMOPREADY *psSyncPrimOpReadyOUT,
CONNECTION_DATA *psConnection)
{
SERVER_OP_COOKIE * psServerCookieInt = IMG_NULL;
IMG_HANDLE hServerCookieInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMOPREADY);
{
/* Look up the address from the handle */
psSyncPrimOpReadyOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hServerCookieInt2,
psSyncPrimOpReadyIN->hServerCookie,
PVRSRV_HANDLE_TYPE_SERVER_OP_COOKIE);
if(psSyncPrimOpReadyOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpReady_exit;
}
/* Look up the data from the resman address */
psSyncPrimOpReadyOUT->eError = ResManFindPrivateDataByPtr(hServerCookieInt2, (IMG_VOID **) &psServerCookieInt);
if(psSyncPrimOpReadyOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpReady_exit;
}
}
psSyncPrimOpReadyOUT->eError =
PVRSRVSyncPrimOpReadyKM(
psServerCookieInt,
&psSyncPrimOpReadyOUT->bReady);
SyncPrimOpReady_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRGXSetComputeContextPriority(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXSETCOMPUTECONTEXTPRIORITY *psRGXSetComputeContextPriorityIN,
PVRSRV_BRIDGE_OUT_RGXSETCOMPUTECONTEXTPRIORITY *psRGXSetComputeContextPriorityOUT,
CONNECTION_DATA *psConnection)
{
RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXSETCOMPUTECONTEXTPRIORITY);
{
/* Look up the address from the handle */
psRGXSetComputeContextPriorityOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hComputeContextInt2,
psRGXSetComputeContextPriorityIN->hComputeContext,
PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
if(psRGXSetComputeContextPriorityOUT->eError != PVRSRV_OK)
{
goto RGXSetComputeContextPriority_exit;
}
/* Look up the data from the resman address */
psRGXSetComputeContextPriorityOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
if(psRGXSetComputeContextPriorityOUT->eError != PVRSRV_OK)
{
goto RGXSetComputeContextPriority_exit;
}
}
psRGXSetComputeContextPriorityOUT->eError =
PVRSRVRGXSetComputeContextPriorityKM(psConnection,
psComputeContextInt,
psRGXSetComputeContextPriorityIN->ui32Priority);
RGXSetComputeContextPriority_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeEventObjectWait(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_EVENTOBJECTWAIT *psEventObjectWaitIN,
PVRSRV_BRIDGE_OUT_EVENTOBJECTWAIT *psEventObjectWaitOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hOSEventKMInt = IMG_NULL;
IMG_HANDLE hOSEventKMInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_EVENTOBJECTWAIT);
{
/* Look up the address from the handle */
psEventObjectWaitOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hOSEventKMInt2,
psEventObjectWaitIN->hOSEventKM,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
if(psEventObjectWaitOUT->eError != PVRSRV_OK)
{
goto EventObjectWait_exit;
}
/* Look up the data from the resman address */
psEventObjectWaitOUT->eError = ResManFindPrivateDataByPtr(hOSEventKMInt2, (IMG_VOID **) &hOSEventKMInt);
if(psEventObjectWaitOUT->eError != PVRSRV_OK)
{
goto EventObjectWait_exit;
}
}
psEventObjectWaitOUT->eError =
OSEventObjectWait(
hOSEventKMInt);
EventObjectWait_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRIDumpList(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RIDUMPLIST *psRIDumpListIN,
PVRSRV_BRIDGE_OUT_RIDUMPLIST *psRIDumpListOUT,
CONNECTION_DATA *psConnection)
{
PMR * psPMRHandleInt = IMG_NULL;
IMG_HANDLE hPMRHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RI_RIDUMPLIST);
{
/* Look up the address from the handle */
psRIDumpListOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRHandleInt2,
psRIDumpListIN->hPMRHandle,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if(psRIDumpListOUT->eError != PVRSRV_OK)
{
goto RIDumpList_exit;
}
/* Look up the data from the resman address */
psRIDumpListOUT->eError = ResManFindPrivateDataByPtr(hPMRHandleInt2, (IMG_VOID **) &psPMRHandleInt);
if(psRIDumpListOUT->eError != PVRSRV_OK)
{
goto RIDumpList_exit;
}
}
psRIDumpListOUT->eError =
RIDumpListKM(
psPMRHandleInt);
RIDumpList_exit:
return 0;
}
static IMG_INT
PVRSRVBridgePMRSecureUnexportPMR(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_PMRSECUREUNEXPORTPMR *psPMRSecureUnexportPMRIN,
PVRSRV_BRIDGE_OUT_PMRSECUREUNEXPORTPMR *psPMRSecureUnexportPMROUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hPMRInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SMM_PMRSECUREUNEXPORTPMR);
{
/* Look up the address from the handle */
psPMRSecureUnexportPMROUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRInt2,
psPMRSecureUnexportPMRIN->hPMR,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if(psPMRSecureUnexportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureUnexportPMR_exit;
}
}
psPMRSecureUnexportPMROUT->eError = PMRSecureUnexportPMRResManProxy(hPMRInt2);
/* Exit early if bridged call fails */
if(psPMRSecureUnexportPMROUT->eError != PVRSRV_OK)
{
goto PMRSecureUnexportPMR_exit;
}
psPMRSecureUnexportPMROUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psPMRSecureUnexportPMRIN->hPMR,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
PMRSecureUnexportPMR_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeTLCloseStream(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_TLCLOSESTREAM *psTLCloseStreamIN,
PVRSRV_BRIDGE_OUT_TLCLOSESTREAM *psTLCloseStreamOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hSDInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PVRTL_TLCLOSESTREAM);
{
/* Look up the address from the handle */
psTLCloseStreamOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSDInt2,
psTLCloseStreamIN->hSD,
PVRSRV_HANDLE_TYPE_PVR_TL_SD);
if(psTLCloseStreamOUT->eError != PVRSRV_OK)
{
goto TLCloseStream_exit;
}
}
psTLCloseStreamOUT->eError = TLCloseStreamResManProxy(hSDInt2);
/* Exit early if bridged call fails */
if(psTLCloseStreamOUT->eError != PVRSRV_OK)
{
goto TLCloseStream_exit;
}
psTLCloseStreamOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psTLCloseStreamIN->hSD,
PVRSRV_HANDLE_TYPE_PVR_TL_SD);
TLCloseStream_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRIDeleteMEMDESCEntry(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RIDELETEMEMDESCENTRY *psRIDeleteMEMDESCEntryIN,
PVRSRV_BRIDGE_OUT_RIDELETEMEMDESCENTRY *psRIDeleteMEMDESCEntryOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hRIHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RI_RIDELETEMEMDESCENTRY);
{
/* Look up the address from the handle */
psRIDeleteMEMDESCEntryOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hRIHandleInt2,
psRIDeleteMEMDESCEntryIN->hRIHandle,
PVRSRV_HANDLE_TYPE_RI_HANDLE);
if(psRIDeleteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIDeleteMEMDESCEntry_exit;
}
}
psRIDeleteMEMDESCEntryOUT->eError = RIDeleteMEMDESCEntryResManProxy(hRIHandleInt2);
/* Exit early if bridged call fails */
if(psRIDeleteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIDeleteMEMDESCEntry_exit;
}
psRIDeleteMEMDESCEntryOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psRIDeleteMEMDESCEntryIN->hRIHandle,
PVRSRV_HANDLE_TYPE_RI_HANDLE);
RIDeleteMEMDESCEntry_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeServerSyncFree(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SERVERSYNCFREE *psServerSyncFreeIN,
PVRSRV_BRIDGE_OUT_SERVERSYNCFREE *psServerSyncFreeOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SERVERSYNCFREE);
{
/* Look up the address from the handle */
psServerSyncFreeOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psServerSyncFreeIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
if(psServerSyncFreeOUT->eError != PVRSRV_OK)
{
goto ServerSyncFree_exit;
}
}
psServerSyncFreeOUT->eError = ServerSyncFreeResManProxy(hSyncHandleInt2);
/* Exit early if bridged call fails */
if(psServerSyncFreeOUT->eError != PVRSRV_OK)
{
goto ServerSyncFree_exit;
}
psServerSyncFreeOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psServerSyncFreeIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
ServerSyncFree_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeFreeSyncPrimitiveBlock(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_FREESYNCPRIMITIVEBLOCK *psFreeSyncPrimitiveBlockIN,
PVRSRV_BRIDGE_OUT_FREESYNCPRIMITIVEBLOCK *psFreeSyncPrimitiveBlockOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hSyncHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_FREESYNCPRIMITIVEBLOCK);
{
/* Look up the address from the handle */
psFreeSyncPrimitiveBlockOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2,
psFreeSyncPrimitiveBlockIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
if(psFreeSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto FreeSyncPrimitiveBlock_exit;
}
}
psFreeSyncPrimitiveBlockOUT->eError = FreeSyncPrimitiveBlockResManProxy(hSyncHandleInt2);
/* Exit early if bridged call fails */
if(psFreeSyncPrimitiveBlockOUT->eError != PVRSRV_OK)
{
goto FreeSyncPrimitiveBlock_exit;
}
psFreeSyncPrimitiveBlockOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psFreeSyncPrimitiveBlockIN->hSyncHandle,
PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
FreeSyncPrimitiveBlock_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimOpDestroy(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMOPDESTROY *psSyncPrimOpDestroyIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMOPDESTROY *psSyncPrimOpDestroyOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hServerCookieInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMOPDESTROY);
{
/* Look up the address from the handle */
psSyncPrimOpDestroyOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hServerCookieInt2,
psSyncPrimOpDestroyIN->hServerCookie,
PVRSRV_HANDLE_TYPE_SERVER_OP_COOKIE);
if(psSyncPrimOpDestroyOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpDestroy_exit;
}
}
psSyncPrimOpDestroyOUT->eError = SyncPrimOpDestroyResManProxy(hServerCookieInt2);
/* Exit early if bridged call fails */
if(psSyncPrimOpDestroyOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpDestroy_exit;
}
psSyncPrimOpDestroyOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psSyncPrimOpDestroyIN->hServerCookie,
PVRSRV_HANDLE_TYPE_SERVER_OP_COOKIE);
SyncPrimOpDestroy_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeAcquireDeviceData(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_ACQUIREDEVICEDATA *psAcquireDeviceDataIN,
PVRSRV_BRIDGE_OUT_ACQUIREDEVICEDATA *psAcquireDeviceDataOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevCookieInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_ACQUIREDEVICEDATA);
psAcquireDeviceDataOUT->eError =
PVRSRVAcquireDeviceDataKM(
psAcquireDeviceDataIN->ui32DevIndex,
psAcquireDeviceDataIN->eDeviceType,
&hDevCookieInt);
/* Exit early if bridged call fails */
if(psAcquireDeviceDataOUT->eError != PVRSRV_OK)
{
goto AcquireDeviceData_exit;
}
psAcquireDeviceDataOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psAcquireDeviceDataOUT->hDevCookie,
(IMG_HANDLE) hDevCookieInt,
PVRSRV_HANDLE_TYPE_DEV_NODE,
PVRSRV_HANDLE_ALLOC_FLAG_SHARED
);
if (psAcquireDeviceDataOUT->eError != PVRSRV_OK)
{
goto AcquireDeviceData_exit;
}
AcquireDeviceData_exit:
if (psAcquireDeviceDataOUT->eError != PVRSRV_OK)
{
}
return 0;
}
static IMG_INT
PVRSRVBridgeReleaseGlobalEventObject(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RELEASEGLOBALEVENTOBJECT *psReleaseGlobalEventObjectIN,
PVRSRV_BRIDGE_OUT_RELEASEGLOBALEVENTOBJECT *psReleaseGlobalEventObjectOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hGlobalEventObjectInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_RELEASEGLOBALEVENTOBJECT);
{
/* Look up the address from the handle */
psReleaseGlobalEventObjectOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hGlobalEventObjectInt2,
psReleaseGlobalEventObjectIN->hGlobalEventObject,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
if(psReleaseGlobalEventObjectOUT->eError != PVRSRV_OK)
{
goto ReleaseGlobalEventObject_exit;
}
}
psReleaseGlobalEventObjectOUT->eError = ReleaseGlobalEventObjectResManProxy(hGlobalEventObjectInt2);
/* Exit early if bridged call fails */
if(psReleaseGlobalEventObjectOUT->eError != PVRSRV_OK)
{
goto ReleaseGlobalEventObject_exit;
}
psReleaseGlobalEventObjectOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psReleaseGlobalEventObjectIN->hGlobalEventObject,
PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
ReleaseGlobalEventObject_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeEventObjectClose(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_EVENTOBJECTCLOSE *psEventObjectCloseIN,
PVRSRV_BRIDGE_OUT_EVENTOBJECTCLOSE *psEventObjectCloseOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hOSEventKMInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_EVENTOBJECTCLOSE);
{
/* Look up the address from the handle */
psEventObjectCloseOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hOSEventKMInt2,
psEventObjectCloseIN->hOSEventKM,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
if(psEventObjectCloseOUT->eError != PVRSRV_OK)
{
goto EventObjectClose_exit;
}
}
psEventObjectCloseOUT->eError = EventObjectCloseResManProxy(hOSEventKMInt2);
/* Exit early if bridged call fails */
if(psEventObjectCloseOUT->eError != PVRSRV_OK)
{
goto EventObjectClose_exit;
}
psEventObjectCloseOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psEventObjectCloseIN->hOSEventKM,
PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
EventObjectClose_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRGXDestroyComputeContext(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXDESTROYCOMPUTECONTEXT *psRGXDestroyComputeContextIN,
PVRSRV_BRIDGE_OUT_RGXDESTROYCOMPUTECONTEXT *psRGXDestroyComputeContextOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXDESTROYCOMPUTECONTEXT);
{
/* Look up the address from the handle */
psRGXDestroyComputeContextOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hComputeContextInt2,
psRGXDestroyComputeContextIN->hComputeContext,
PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
if(psRGXDestroyComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXDestroyComputeContext_exit;
}
}
psRGXDestroyComputeContextOUT->eError = RGXDestroyComputeContextResManProxy(hComputeContextInt2);
/* Exit early if bridged call fails */
if(psRGXDestroyComputeContextOUT->eError != PVRSRV_OK)
{
goto RGXDestroyComputeContext_exit;
}
psRGXDestroyComputeContextOUT->eError =
PVRSRVReleaseHandle(psConnection->psHandleBase,
(IMG_HANDLE) psRGXDestroyComputeContextIN->hComputeContext,
PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
RGXDestroyComputeContext_exit:
return 0;
}
static IMG_INT
PVRSRVBridgeRGXCtrlHWPerf(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXCTRLHWPERF *psRGXCtrlHWPerfIN,
PVRSRV_BRIDGE_OUT_RGXCTRLHWPERF *psRGXCtrlHWPerfOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXHWPERF_RGXCTRLHWPERF);
{
/* Look up the address from the handle */
psRGXCtrlHWPerfOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXCtrlHWPerfIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXCtrlHWPerfOUT->eError != PVRSRV_OK)
{
goto RGXCtrlHWPerf_exit;
}
}
psRGXCtrlHWPerfOUT->eError =
PVRSRVRGXCtrlHWPerfKM(
hDevNodeInt,
psRGXCtrlHWPerfIN->bToggle,
psRGXCtrlHWPerfIN->ui64Mask);
RGXCtrlHWPerf_exit:
return 0;
}
static IMG_INT
PVRSRVBridgePVRSRVPDumpSetFrame(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_PVRSRVPDUMPSETFRAME *psPVRSRVPDumpSetFrameIN,
PVRSRV_BRIDGE_OUT_PVRSRVPDUMPSETFRAME *psPVRSRVPDumpSetFrameOUT,
CONNECTION_DATA *psConnection)
{
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_PVRSRVPDUMPSETFRAME);
psPVRSRVPDumpSetFrameOUT->eError =
PDumpSetFrameKM(psConnection,
psPVRSRVPDumpSetFrameIN->ui32Frame);
return 0;
}
static IMG_INT
PVRSRVBridgeGetDevClockSpeed(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_GETDEVCLOCKSPEED *psGetDevClockSpeedIN,
PVRSRV_BRIDGE_OUT_GETDEVCLOCKSPEED *psGetDevClockSpeedOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_GETDEVCLOCKSPEED);
{
/* Look up the address from the handle */
psGetDevClockSpeedOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psGetDevClockSpeedIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psGetDevClockSpeedOUT->eError != PVRSRV_OK)
{
goto GetDevClockSpeed_exit;
}
}
psGetDevClockSpeedOUT->eError =
PVRSRVGetDevClockSpeedKM(
hDevNodeInt,
&psGetDevClockSpeedOUT->ui32ui32RGXClockSpeed);
GetDevClockSpeed_exit:
return 0;
}