PVRSRV_ERROR
CopyFromUserWrapper(CONNECTION_DATA *psConnection,
IMG_UINT32 ui32BridgeID,
IMG_VOID *pvDest,
IMG_VOID *pvSrc,
IMG_UINT32 ui32Size)
{
g_BridgeDispatchTable[ui32BridgeID].ui32CopyFromUserTotalBytes+=ui32Size;
g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+=ui32Size;
return OSCopyFromUser(psConnection, pvDest, pvSrc, ui32Size);
}
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
PVRSRVBridgePVRSRVPDumpComment(IMG_UINT32 ui32DispatchTableEntry,
PVRSRV_BRIDGE_IN_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentIN,
PVRSRV_BRIDGE_OUT_PVRSRVPDUMPCOMMENT *psPVRSRVPDumpCommentOUT,
CONNECTION_DATA *psConnection)
{
IMG_CHAR *uiCommentInt = IMG_NULL;
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
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
PVRSRVBridgeServerSyncGetStatus(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SERVERSYNCGETSTATUS *psServerSyncGetStatusIN,
PVRSRV_BRIDGE_OUT_SERVERSYNCGETSTATUS *psServerSyncGetStatusOUT,
CONNECTION_DATA *psConnection)
{
SERVER_SYNC_PRIMITIVE * *psSyncHandleInt = IMG_NULL;
IMG_HANDLE *hSyncHandleInt2 = IMG_NULL;
IMG_UINT32 *pui32UIDInt = IMG_NULL;
IMG_UINT32 *pui32FWAddrInt = IMG_NULL;
IMG_UINT32 *pui32CurrentOpInt = IMG_NULL;
IMG_UINT32 *pui32NextOpInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SERVERSYNCGETSTATUS);
psServerSyncGetStatusOUT->pui32UID = psServerSyncGetStatusIN->pui32UID;
psServerSyncGetStatusOUT->pui32FWAddr = psServerSyncGetStatusIN->pui32FWAddr;
psServerSyncGetStatusOUT->pui32CurrentOp = psServerSyncGetStatusIN->pui32CurrentOp;
psServerSyncGetStatusOUT->pui32NextOp = psServerSyncGetStatusIN->pui32NextOp;
if (psServerSyncGetStatusIN->ui32SyncCount != 0)
{
psSyncHandleInt = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(SERVER_SYNC_PRIMITIVE *));
if (!psSyncHandleInt)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
hSyncHandleInt2 = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_HANDLE));
if (!hSyncHandleInt2)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psServerSyncGetStatusIN->phSyncHandle, psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_HANDLE))
|| (OSCopyFromUser(NULL, hSyncHandleInt2, psServerSyncGetStatusIN->phSyncHandle,
psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto ServerSyncGetStatus_exit;
}
if (psServerSyncGetStatusIN->ui32SyncCount != 0)
{
pui32UIDInt = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32));
if (!pui32UIDInt)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
}
if (psServerSyncGetStatusIN->ui32SyncCount != 0)
{
pui32FWAddrInt = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32));
if (!pui32FWAddrInt)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
}
if (psServerSyncGetStatusIN->ui32SyncCount != 0)
{
pui32CurrentOpInt = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32));
if (!pui32CurrentOpInt)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
}
if (psServerSyncGetStatusIN->ui32SyncCount != 0)
{
pui32NextOpInt = OSAllocMem(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32));
if (!pui32NextOpInt)
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto ServerSyncGetStatus_exit;
}
}
{
IMG_UINT32 i;
for (i=0;i<psServerSyncGetStatusIN->ui32SyncCount;i++)
{
{
/* Look up the address from the handle */
psServerSyncGetStatusOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hSyncHandleInt2[i],
psServerSyncGetStatusIN->phSyncHandle[i],
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
if(psServerSyncGetStatusOUT->eError != PVRSRV_OK)
{
goto ServerSyncGetStatus_exit;
}
/* Look up the data from the resman address */
psServerSyncGetStatusOUT->eError = ResManFindPrivateDataByPtr(hSyncHandleInt2[i], (IMG_VOID **) &psSyncHandleInt[i]);
if(psServerSyncGetStatusOUT->eError != PVRSRV_OK)
{
goto ServerSyncGetStatus_exit;
}
}
}
}
psServerSyncGetStatusOUT->eError =
PVRSRVServerSyncGetStatusKM(
psServerSyncGetStatusIN->ui32SyncCount,
psSyncHandleInt,
pui32UIDInt,
pui32FWAddrInt,
pui32CurrentOpInt,
pui32NextOpInt);
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psServerSyncGetStatusOUT->pui32UID, (psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32)))
|| (OSCopyToUser(NULL, psServerSyncGetStatusOUT->pui32UID, pui32UIDInt,
(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto ServerSyncGetStatus_exit;
}
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psServerSyncGetStatusOUT->pui32FWAddr, (psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32)))
|| (OSCopyToUser(NULL, psServerSyncGetStatusOUT->pui32FWAddr, pui32FWAddrInt,
(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto ServerSyncGetStatus_exit;
}
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psServerSyncGetStatusOUT->pui32CurrentOp, (psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32)))
|| (OSCopyToUser(NULL, psServerSyncGetStatusOUT->pui32CurrentOp, pui32CurrentOpInt,
(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto ServerSyncGetStatus_exit;
}
if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psServerSyncGetStatusOUT->pui32NextOp, (psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32)))
|| (OSCopyToUser(NULL, psServerSyncGetStatusOUT->pui32NextOp, pui32NextOpInt,
(psServerSyncGetStatusIN->ui32SyncCount * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psServerSyncGetStatusOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto ServerSyncGetStatus_exit;
}
ServerSyncGetStatus_exit:
if (psSyncHandleInt)
OSFreeMem(psSyncHandleInt);
if (hSyncHandleInt2)
OSFreeMem(hSyncHandleInt2);
if (pui32UIDInt)
OSFreeMem(pui32UIDInt);
if (pui32FWAddrInt)
OSFreeMem(pui32FWAddrInt);
if (pui32CurrentOpInt)
OSFreeMem(pui32CurrentOpInt);
if (pui32NextOpInt)
OSFreeMem(pui32NextOpInt);
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;
}
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
compat_PVRSRVBridgeRGXKickCDM(IMG_UINT32 ui32BridgeID,
compat_PVRSRV_BRIDGE_IN_RGXKICKCDM *psRGXKickCDMIN_32,
PVRSRV_BRIDGE_OUT_RGXKICKCDM *psRGXKickCDMOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE *hServerSyncsInt2 = IMG_NULL;
IMG_UINT32 *hServerSyncsInt3 = IMG_NULL;
PVRSRV_BRIDGE_IN_RGXKICKCDM sRGXKickCDMIN;
PVRSRV_BRIDGE_IN_RGXKICKCDM *psRGXKickCDMIN = &sRGXKickCDMIN;
psRGXKickCDMIN->hComputeContext = (IMG_HANDLE)(IMG_UINT64)psRGXKickCDMIN_32->hComputeContext;
psRGXKickCDMIN->ui32ClientFenceCount = psRGXKickCDMIN_32->ui32ClientFenceCount;
psRGXKickCDMIN->psClientFenceUFOAddress = (PRGXFWIF_UFO_ADDR*)(IMG_UINT64)psRGXKickCDMIN_32->psClientFenceUFOAddress;
psRGXKickCDMIN->pui32ClientFenceValue = (IMG_UINT32*)(IMG_UINT64)psRGXKickCDMIN_32->pui32ClientFenceValue;
psRGXKickCDMIN->ui32ClientUpdateCount = psRGXKickCDMIN_32->ui32ClientUpdateCount;
psRGXKickCDMIN->psClientUpdateUFOAddress = (PRGXFWIF_UFO_ADDR*)(IMG_UINT64)psRGXKickCDMIN_32->psClientUpdateUFOAddress;
psRGXKickCDMIN->pui32ClientUpdateValue = (IMG_UINT32*)(IMG_UINT64)psRGXKickCDMIN_32->pui32ClientUpdateValue;
psRGXKickCDMIN->ui32ServerSyncCount = psRGXKickCDMIN_32->ui32ServerSyncCount;
psRGXKickCDMIN->pui32ServerSyncFlags = (IMG_UINT32*)(IMG_UINT64)psRGXKickCDMIN_32->pui32ServerSyncFlags;
psRGXKickCDMIN->phServerSyncs = (IMG_HANDLE*)(IMG_UINT64)psRGXKickCDMIN_32->phServerSyncs;
psRGXKickCDMIN->ui32CmdSize = psRGXKickCDMIN_32->ui32CmdSize;
psRGXKickCDMIN->psDMCmd = (IMG_BYTE*)(IMG_UINT64)psRGXKickCDMIN_32->psDMCmd;
psRGXKickCDMIN->bbPDumpContinuous = psRGXKickCDMIN_32->bbPDumpContinuous;
if (psRGXKickCDMIN->ui32ServerSyncCount != 0)
{
hServerSyncsInt2 = compat_alloc_user_space(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE));
if (!hServerSyncsInt2)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
hServerSyncsInt3 = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32));
if (!hServerSyncsInt3)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phServerSyncs, psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, hServerSyncsInt3, psRGXKickCDMIN->phServerSyncs,
psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
{
IMG_UINT32 i;
for (i=0;i<psRGXKickCDMIN->ui32ServerSyncCount;i++)
{
if (!access_ok(VERIFY_WRITE, &hServerSyncsInt2[i], sizeof(IMG_HANDLE))
|| __put_user((unsigned long)hServerSyncsInt3[i], &hServerSyncsInt2[i])) {
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
}
psRGXKickCDMIN->phServerSyncs = hServerSyncsInt2;
}
PVRSRVBridgeRGXKickCDM(ui32BridgeID,
psRGXKickCDMIN,
psRGXKickCDMOUT,
psConnection);
RGXKickCDM_exit:
if (hServerSyncsInt3)
OSFreeMem(hServerSyncsInt3);
return 0;
}
static IMG_INT
PVRSRVBridgeRIWriteMEMDESCEntry(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RIWRITEMEMDESCENTRY *psRIWriteMEMDESCEntryIN,
PVRSRV_BRIDGE_OUT_RIWRITEMEMDESCENTRY *psRIWriteMEMDESCEntryOUT,
CONNECTION_DATA *psConnection)
{
PMR * psPMRHandleInt = IMG_NULL;
IMG_HANDLE hPMRHandleInt2 = IMG_NULL;
IMG_CHAR *uiTextBInt = IMG_NULL;
RI_HANDLE psRIHandleInt = IMG_NULL;
IMG_HANDLE hRIHandleInt2 = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RI_RIWRITEMEMDESCENTRY);
{
uiTextBInt = OSAllocMem(RI_MAX_TEXT_LEN * sizeof(IMG_CHAR));
if (!uiTextBInt)
{
psRIWriteMEMDESCEntryOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RIWriteMEMDESCEntry_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRIWriteMEMDESCEntryIN->puiTextB, RI_MAX_TEXT_LEN * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiTextBInt, psRIWriteMEMDESCEntryIN->puiTextB,
RI_MAX_TEXT_LEN * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psRIWriteMEMDESCEntryOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RIWriteMEMDESCEntry_exit;
}
{
/* Look up the address from the handle */
psRIWriteMEMDESCEntryOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRHandleInt2,
psRIWriteMEMDESCEntryIN->hPMRHandle,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if(psRIWriteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIWriteMEMDESCEntry_exit;
}
/* Look up the data from the resman address */
psRIWriteMEMDESCEntryOUT->eError = ResManFindPrivateDataByPtr(hPMRHandleInt2, (IMG_VOID **) &psPMRHandleInt);
if(psRIWriteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIWriteMEMDESCEntry_exit;
}
}
psRIWriteMEMDESCEntryOUT->eError =
RIWriteMEMDESCEntryKM(
psPMRHandleInt,
uiTextBInt,
psRIWriteMEMDESCEntryIN->uiOffset,
psRIWriteMEMDESCEntryIN->uiSize,
psRIWriteMEMDESCEntryIN->bIsImport,
psRIWriteMEMDESCEntryIN->bIsExportable,
&psRIHandleInt);
/* Exit early if bridged call fails */
if(psRIWriteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIWriteMEMDESCEntry_exit;
}
/* Create a resman item and overwrite the handle with it */
hRIHandleInt2 = ResManRegisterRes(psConnection->hResManContext,
RESMAN_TYPE_RI_HANDLE,
psRIHandleInt,
(RESMAN_FREE_FN)&RIDeleteMEMDESCEntryKM);
if (hRIHandleInt2 == IMG_NULL)
{
psRIWriteMEMDESCEntryOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
goto RIWriteMEMDESCEntry_exit;
}
psRIWriteMEMDESCEntryOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
&psRIWriteMEMDESCEntryOUT->hRIHandle,
(IMG_HANDLE) hRIHandleInt2,
PVRSRV_HANDLE_TYPE_RI_HANDLE,
PVRSRV_HANDLE_ALLOC_FLAG_NONE
);
if (psRIWriteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
goto RIWriteMEMDESCEntry_exit;
}
RIWriteMEMDESCEntry_exit:
if (psRIWriteMEMDESCEntryOUT->eError != PVRSRV_OK)
{
/* If we have a valid resman item we should undo the bridge function by freeing the resman item */
if (hRIHandleInt2)
{
PVRSRV_ERROR eError = ResManFreeResByPtr(hRIHandleInt2);
/* Freeing a resource should never fail... */
PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
}
else if (psRIHandleInt)
{
RIDeleteMEMDESCEntryKM(psRIHandleInt);
}
}
if (uiTextBInt)
OSFreeMem(uiTextBInt);
return 0;
}
static IMG_INT
PVRSRVBridgeDevmemPDumpBitmap(IMG_UINT32 ui32DispatchTableEntry,
PVRSRV_BRIDGE_IN_DEVMEMPDUMPBITMAP *psDevmemPDumpBitmapIN,
PVRSRV_BRIDGE_OUT_DEVMEMPDUMPBITMAP *psDevmemPDumpBitmapOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDeviceNodeInt = IMG_NULL;
IMG_CHAR *uiFileNameInt = IMG_NULL;
DEVMEMINT_CTX * psDevmemCtxInt = IMG_NULL;
{
uiFileNameInt = OSAllocMem(PVRSRV_PDUMP_MAX_FILENAME_SIZE * sizeof(IMG_CHAR));
if (!uiFileNameInt)
{
psDevmemPDumpBitmapOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto DevmemPDumpBitmap_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psDevmemPDumpBitmapIN->puiFileName, PVRSRV_PDUMP_MAX_FILENAME_SIZE * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiFileNameInt, psDevmemPDumpBitmapIN->puiFileName,
PVRSRV_PDUMP_MAX_FILENAME_SIZE * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psDevmemPDumpBitmapOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto DevmemPDumpBitmap_exit;
}
{
/* Look up the address from the handle */
psDevmemPDumpBitmapOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_VOID **) &hDeviceNodeInt,
psDevmemPDumpBitmapIN->hDeviceNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psDevmemPDumpBitmapOUT->eError != PVRSRV_OK)
{
goto DevmemPDumpBitmap_exit;
}
}
{
/* Look up the address from the handle */
psDevmemPDumpBitmapOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_VOID **) &psDevmemCtxInt,
psDevmemPDumpBitmapIN->hDevmemCtx,
PVRSRV_HANDLE_TYPE_DEVMEMINT_CTX);
if(psDevmemPDumpBitmapOUT->eError != PVRSRV_OK)
{
goto DevmemPDumpBitmap_exit;
}
}
psDevmemPDumpBitmapOUT->eError =
DevmemIntPDumpBitmap(
hDeviceNodeInt,
uiFileNameInt,
psDevmemPDumpBitmapIN->ui32FileOffset,
psDevmemPDumpBitmapIN->ui32Width,
psDevmemPDumpBitmapIN->ui32Height,
psDevmemPDumpBitmapIN->ui32StrideInBytes,
psDevmemPDumpBitmapIN->sDevBaseAddr,
psDevmemCtxInt,
psDevmemPDumpBitmapIN->ui32Size,
psDevmemPDumpBitmapIN->ePixelFormat,
psDevmemPDumpBitmapIN->ui32AddrMode,
psDevmemPDumpBitmapIN->ui32PDumpFlags);
DevmemPDumpBitmap_exit:
if (uiFileNameInt)
OSFreeMem(uiFileNameInt);
return 0;
}
static IMG_INT
PVRSRVBridgeRGXConfigCustomCounters(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXCONFIGCUSTOMCOUNTERS *psRGXConfigCustomCountersIN,
PVRSRV_BRIDGE_OUT_RGXCONFIGCUSTOMCOUNTERS *psRGXConfigCustomCountersOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
IMG_UINT32 *ui32CustomCounterIDsInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXHWPERF_RGXCONFIGCUSTOMCOUNTERS);
if (psRGXConfigCustomCountersIN->ui16NumCustomCounters != 0)
{
ui32CustomCounterIDsInt = OSAllocMem(psRGXConfigCustomCountersIN->ui16NumCustomCounters * sizeof(IMG_UINT32));
if (!ui32CustomCounterIDsInt)
{
psRGXConfigCustomCountersOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXConfigCustomCounters_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXConfigCustomCountersIN->pui32CustomCounterIDs, psRGXConfigCustomCountersIN->ui16NumCustomCounters * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32CustomCounterIDsInt, psRGXConfigCustomCountersIN->pui32CustomCounterIDs,
psRGXConfigCustomCountersIN->ui16NumCustomCounters * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXConfigCustomCountersOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXConfigCustomCounters_exit;
}
{
/* Look up the address from the handle */
psRGXConfigCustomCountersOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXConfigCustomCountersIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXConfigCustomCountersOUT->eError != PVRSRV_OK)
{
goto RGXConfigCustomCounters_exit;
}
}
psRGXConfigCustomCountersOUT->eError =
PVRSRVRGXConfigCustomCountersKM(
hDevNodeInt,
psRGXConfigCustomCountersIN->ui16CustomBlockID,
psRGXConfigCustomCountersIN->ui16NumCustomCounters,
ui32CustomCounterIDsInt);
RGXConfigCustomCounters_exit:
if (ui32CustomCounterIDsInt)
OSFreeMem(ui32CustomCounterIDsInt);
return 0;
}
static IMG_INT
PVRSRVBridgeRGXConfigEnableHWPerfCounters(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXCONFIGENABLEHWPERFCOUNTERS *psRGXConfigEnableHWPerfCountersIN,
PVRSRV_BRIDGE_OUT_RGXCONFIGENABLEHWPERFCOUNTERS *psRGXConfigEnableHWPerfCountersOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDevNodeInt = IMG_NULL;
RGX_HWPERF_CONFIG_CNTBLK *psBlockConfigsInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXHWPERF_RGXCONFIGENABLEHWPERFCOUNTERS);
if (psRGXConfigEnableHWPerfCountersIN->ui32ArrayLen != 0)
{
psBlockConfigsInt = OSAllocMem(psRGXConfigEnableHWPerfCountersIN->ui32ArrayLen * sizeof(RGX_HWPERF_CONFIG_CNTBLK));
if (!psBlockConfigsInt)
{
psRGXConfigEnableHWPerfCountersOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXConfigEnableHWPerfCounters_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXConfigEnableHWPerfCountersIN->psBlockConfigs, psRGXConfigEnableHWPerfCountersIN->ui32ArrayLen * sizeof(RGX_HWPERF_CONFIG_CNTBLK))
|| (OSCopyFromUser(NULL, psBlockConfigsInt, psRGXConfigEnableHWPerfCountersIN->psBlockConfigs,
psRGXConfigEnableHWPerfCountersIN->ui32ArrayLen * sizeof(RGX_HWPERF_CONFIG_CNTBLK)) != PVRSRV_OK) )
{
psRGXConfigEnableHWPerfCountersOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXConfigEnableHWPerfCounters_exit;
}
{
/* Look up the address from the handle */
psRGXConfigEnableHWPerfCountersOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hDevNodeInt,
psRGXConfigEnableHWPerfCountersIN->hDevNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psRGXConfigEnableHWPerfCountersOUT->eError != PVRSRV_OK)
{
goto RGXConfigEnableHWPerfCounters_exit;
}
}
psRGXConfigEnableHWPerfCountersOUT->eError =
PVRSRVRGXConfigEnableHWPerfCountersKM(
hDevNodeInt,
psRGXConfigEnableHWPerfCountersIN->ui32ArrayLen,
psBlockConfigsInt);
RGXConfigEnableHWPerfCounters_exit:
if (psBlockConfigsInt)
OSFreeMem(psBlockConfigsInt);
return 0;
}
IMG_INT32
PVRSRV_BridgeDispatchKM(struct file *pFile, IMG_UINT unref__ ioctlCmd, IMG_UINT32 arg)
#endif
{
IMG_UINT32 cmd;
#if !defined(SUPPORT_DRI_DRM)
PVRSRV_BRIDGE_PACKAGE *psBridgePackageUM = (PVRSRV_BRIDGE_PACKAGE *)arg;
PVRSRV_BRIDGE_PACKAGE sBridgePackageKM;
#endif
PVRSRV_BRIDGE_PACKAGE *psBridgePackageKM;
IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
PVRSRV_PER_PROCESS_DATA *psPerProc;
IMG_INT err = -EFAULT;
LinuxLockMutex(&gPVRSRVLock);
#if defined(SUPPORT_DRI_DRM)
PVR_UNREFERENCED_PARAMETER(dev);
psBridgePackageKM = (PVRSRV_BRIDGE_PACKAGE *)arg;
PVR_ASSERT(psBridgePackageKM != IMG_NULL);
#else
PVR_UNREFERENCED_PARAMETER(ioctlCmd);
psBridgePackageKM = &sBridgePackageKM;
if(!OSAccessOK(PVR_VERIFY_WRITE,
psBridgePackageUM,
sizeof(PVRSRV_BRIDGE_PACKAGE)))
{
PVR_DPF((PVR_DBG_ERROR, "%s: Received invalid pointer to function arguments",
__FUNCTION__));
goto unlock_and_return;
}
if(OSCopyFromUser(IMG_NULL,
psBridgePackageKM,
psBridgePackageUM,
sizeof(PVRSRV_BRIDGE_PACKAGE))
!= PVRSRV_OK)
{
goto unlock_and_return;
}
#endif
cmd = psBridgePackageKM->ui32BridgeID;
#if defined(MODULE_TEST)
switch (cmd)
{
case PVRSRV_BRIDGE_SERVICES_TEST_MEM1:
{
PVRSRV_ERROR eError = MemTest1();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_MEM2:
{
PVRSRV_ERROR eError = MemTest2();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_RESOURCE:
{
PVRSRV_ERROR eError = ResourceTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_EVENTOBJECT:
{
PVRSRV_ERROR eError = EventObjectTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_MEMMAPPING:
{
PVRSRV_ERROR eError = MemMappingTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_PROCESSID:
{
PVRSRV_ERROR eError = ProcessIDTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_CLOCKUSWAITUS:
{
PVRSRV_ERROR eError = ClockusWaitusTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_TIMER:
{
PVRSRV_ERROR eError = TimerTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_PRIVSRV:
{
PVRSRV_ERROR eError = PrivSrvTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
case PVRSRV_BRIDGE_SERVICES_TEST_COPYDATA:
{
IMG_UINT32 ui32PID;
PVRSRV_PER_PROCESS_DATA *psPerProc;
PVRSRV_ERROR eError;
ui32PID = OSGetCurrentProcessIDKM();
PVRSRVTrace("PVRSRV_BRIDGE_SERVICES_TEST_COPYDATA %d", ui32PID);
psPerProc = PVRSRVPerProcessData(ui32PID);
eError = CopyDataTest(psBridgePackageKM->pvParamIn, psBridgePackageKM->pvParamOut, psPerProc);
*(PVRSRV_ERROR*)psBridgePackageKM->pvParamOut = eError;
err = 0;
goto unlock_and_return;
}
case PVRSRV_BRIDGE_SERVICES_TEST_POWERMGMT:
{
PVRSRV_ERROR eError = PowerMgmtTest();
if (psBridgePackageKM->ui32OutBufferSize == sizeof(PVRSRV_BRIDGE_RETURN))
{
PVRSRV_BRIDGE_RETURN* pReturn = (PVRSRV_BRIDGE_RETURN*)psBridgePackageKM->pvParamOut ;
pReturn->eError = eError;
}
}
err = 0;
goto unlock_and_return;
}
#endif
if(cmd != PVRSRV_BRIDGE_CONNECT_SERVICES)
{
PVRSRV_ERROR eError;
eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
(IMG_PVOID *)&psPerProc,
psBridgePackageKM->hKernelServices,
PVRSRV_HANDLE_TYPE_PERPROC_DATA);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Invalid kernel services handle (%d)",
__FUNCTION__, eError));
goto unlock_and_return;
}
if(psPerProc->ui32PID != ui32PID)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Process %d tried to access data "
"belonging to process %d", __FUNCTION__, ui32PID,
psPerProc->ui32PID));
goto unlock_and_return;
}
}
else
{
psPerProc = PVRSRVPerProcessData(ui32PID);
if(psPerProc == IMG_NULL)
{
PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BridgeDispatchKM: "
"Couldn't create per-process data area"));
goto unlock_and_return;
}
}
psBridgePackageKM->ui32BridgeID = PVRSRV_GET_BRIDGE_ID(psBridgePackageKM->ui32BridgeID);
#if defined(PVR_SECURE_FD_EXPORT)
switch(cmd)
{
case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(psPrivateData->hKernelMemInfo)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Can only export one MemInfo "
"per file descriptor", __FUNCTION__));
err = -EINVAL;
goto unlock_and_return;
}
break;
}
case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
{
PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN =
(PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamIn;
PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(!psPrivateData->hKernelMemInfo)
{
PVR_DPF((PVR_DBG_ERROR, "%s: File descriptor has no "
"associated MemInfo handle", __FUNCTION__));
err = -EINVAL;
goto unlock_and_return;
}
psMapDevMemIN->hKernelMemInfo = psPrivateData->hKernelMemInfo;
break;
}
default:
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
if(psPrivateData->hKernelMemInfo)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Import/Export handle tried "
"to use privileged service", __FUNCTION__));
goto unlock_and_return;
}
break;
}
}
#endif
err = BridgedDispatchKM(psPerProc, psBridgePackageKM);
if(err != PVRSRV_OK)
goto unlock_and_return;
switch(cmd)
{
#if defined(PVR_SECURE_FD_EXPORT)
case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
{
PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT =
(PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)psBridgePackageKM->pvParamOut;
PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
psPrivateData->hKernelMemInfo = psExportDeviceMemOUT->hMemInfo;
#if defined(SUPPORT_MEMINFO_IDS)
psExportDeviceMemOUT->ui64Stamp = psPrivateData->ui64Stamp = ++ui64Stamp;
#endif
break;
}
#endif
#if defined(SUPPORT_MEMINFO_IDS)
case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
{
PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDeviceMemoryOUT =
(PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamOut;
PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
psMapDeviceMemoryOUT->sDstClientMemInfo.ui64Stamp = psPrivateData->ui64Stamp;
break;
}
case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
{
PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psDeviceClassMemoryOUT =
(PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *)psBridgePackageKM->pvParamOut;
psDeviceClassMemoryOUT->sClientMemInfo.ui64Stamp = ++ui64Stamp;
break;
}
#endif
default:
break;
}
unlock_and_return:
LinuxUnLockMutex(&gPVRSRVLock);
return err;
}
static IMG_INT
PVRSRVBridgeRIWritePMREntry(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RIWRITEPMRENTRY *psRIWritePMREntryIN,
PVRSRV_BRIDGE_OUT_RIWRITEPMRENTRY *psRIWritePMREntryOUT,
CONNECTION_DATA *psConnection)
{
PMR * psPMRHandleInt = IMG_NULL;
IMG_HANDLE hPMRHandleInt2 = IMG_NULL;
IMG_CHAR *uiTextAInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RI_RIWRITEPMRENTRY);
{
uiTextAInt = OSAllocMem(RI_MAX_TEXT_LEN * sizeof(IMG_CHAR));
if (!uiTextAInt)
{
psRIWritePMREntryOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RIWritePMREntry_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRIWritePMREntryIN->puiTextA, RI_MAX_TEXT_LEN * sizeof(IMG_CHAR))
|| (OSCopyFromUser(NULL, uiTextAInt, psRIWritePMREntryIN->puiTextA,
RI_MAX_TEXT_LEN * sizeof(IMG_CHAR)) != PVRSRV_OK) )
{
psRIWritePMREntryOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RIWritePMREntry_exit;
}
{
/* Look up the address from the handle */
psRIWritePMREntryOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRHandleInt2,
psRIWritePMREntryIN->hPMRHandle,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if(psRIWritePMREntryOUT->eError != PVRSRV_OK)
{
goto RIWritePMREntry_exit;
}
/* Look up the data from the resman address */
psRIWritePMREntryOUT->eError = ResManFindPrivateDataByPtr(hPMRHandleInt2, (IMG_VOID **) &psPMRHandleInt);
if(psRIWritePMREntryOUT->eError != PVRSRV_OK)
{
goto RIWritePMREntry_exit;
}
}
psRIWritePMREntryOUT->eError =
RIWritePMREntryKM(
psPMRHandleInt,
uiTextAInt,
psRIWritePMREntryIN->uiLogicalSize);
RIWritePMREntry_exit:
if (uiTextAInt)
OSFreeMem(uiTextAInt);
return 0;
}
static IMG_INT
PVRSRVBridgeSyncPrimOpTake(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_SYNCPRIMOPTAKE *psSyncPrimOpTakeIN,
PVRSRV_BRIDGE_OUT_SYNCPRIMOPTAKE *psSyncPrimOpTakeOUT,
CONNECTION_DATA *psConnection)
{
SERVER_OP_COOKIE * psServerCookieInt = IMG_NULL;
IMG_HANDLE hServerCookieInt2 = IMG_NULL;
IMG_UINT32 *ui32FlagsInt = IMG_NULL;
IMG_UINT32 *ui32FenceValueInt = IMG_NULL;
IMG_UINT32 *ui32UpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerFlagsInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_SYNCPRIMOPTAKE);
if (psSyncPrimOpTakeIN->ui32ClientSyncCount != 0)
{
ui32FlagsInt = OSAllocMem(psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32));
if (!ui32FlagsInt)
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpTake_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpTakeIN->pui32Flags, psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32FlagsInt, psSyncPrimOpTakeIN->pui32Flags,
psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpTake_exit;
}
if (psSyncPrimOpTakeIN->ui32ClientSyncCount != 0)
{
ui32FenceValueInt = OSAllocMem(psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32));
if (!ui32FenceValueInt)
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpTake_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpTakeIN->pui32FenceValue, psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32FenceValueInt, psSyncPrimOpTakeIN->pui32FenceValue,
psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpTake_exit;
}
if (psSyncPrimOpTakeIN->ui32ClientSyncCount != 0)
{
ui32UpdateValueInt = OSAllocMem(psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32));
if (!ui32UpdateValueInt)
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpTake_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpTakeIN->pui32UpdateValue, psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32UpdateValueInt, psSyncPrimOpTakeIN->pui32UpdateValue,
psSyncPrimOpTakeIN->ui32ClientSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpTake_exit;
}
if (psSyncPrimOpTakeIN->ui32ServerSyncCount != 0)
{
ui32ServerFlagsInt = OSAllocMem(psSyncPrimOpTakeIN->ui32ServerSyncCount * sizeof(IMG_UINT32));
if (!ui32ServerFlagsInt)
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto SyncPrimOpTake_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psSyncPrimOpTakeIN->pui32ServerFlags, psSyncPrimOpTakeIN->ui32ServerSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32ServerFlagsInt, psSyncPrimOpTakeIN->pui32ServerFlags,
psSyncPrimOpTakeIN->ui32ServerSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psSyncPrimOpTakeOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto SyncPrimOpTake_exit;
}
{
/* Look up the address from the handle */
psSyncPrimOpTakeOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hServerCookieInt2,
psSyncPrimOpTakeIN->hServerCookie,
PVRSRV_HANDLE_TYPE_SERVER_OP_COOKIE);
if(psSyncPrimOpTakeOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpTake_exit;
}
/* Look up the data from the resman address */
psSyncPrimOpTakeOUT->eError = ResManFindPrivateDataByPtr(hServerCookieInt2, (IMG_VOID **) &psServerCookieInt);
if(psSyncPrimOpTakeOUT->eError != PVRSRV_OK)
{
goto SyncPrimOpTake_exit;
}
}
psSyncPrimOpTakeOUT->eError =
PVRSRVSyncPrimOpTakeKM(
psServerCookieInt,
psSyncPrimOpTakeIN->ui32ClientSyncCount,
ui32FlagsInt,
ui32FenceValueInt,
ui32UpdateValueInt,
psSyncPrimOpTakeIN->ui32ServerSyncCount,
ui32ServerFlagsInt);
SyncPrimOpTake_exit:
if (ui32FlagsInt)
OSFreeMem(ui32FlagsInt);
if (ui32FenceValueInt)
OSFreeMem(ui32FenceValueInt);
if (ui32UpdateValueInt)
OSFreeMem(ui32UpdateValueInt);
if (ui32ServerFlagsInt)
OSFreeMem(ui32ServerFlagsInt);
return 0;
}
PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA * psPerProc,
void *pvAltLinAddrUM,
void *pvLinAddrUM,
PVRSRV_KERNEL_MEM_INFO * psMemInfo,
u32 ui32Offset,
u32 ui32Bytes, u32 ui32Flags, void *hUniqueTag)
{
void *pvAddrUM;
void *pvAddrKM;
u32 ui32BytesDumped;
u32 ui32CurrentOffset;
if (psMemInfo->pvLinAddrKM != NULL && pvAltLinAddrUM == NULL) {
return PDumpMemKM(NULL,
psMemInfo,
ui32Offset, ui32Bytes, ui32Flags, hUniqueTag);
}
pvAddrUM =
(pvAltLinAddrUM !=
NULL) ? pvAltLinAddrUM : ((pvLinAddrUM !=
NULL) ? VPTR_PLUS(pvLinAddrUM,
ui32Offset) : NULL);
pvAddrKM = GetTempBuffer();
PVR_ASSERT(pvAddrUM != NULL && pvAddrKM != NULL);
if (pvAddrUM == NULL || pvAddrKM == NULL) {
PVR_DPF((PVR_DBG_ERROR, "PDumpMemUM: Nothing to dump"));
return PVRSRV_ERROR_GENERIC;
}
if (ui32Bytes > PDUMP_TEMP_BUFFER_SIZE) {
PDumpCommentWithFlags(ui32Flags,
"Dumping 0x%8.8lx bytes of memory, in blocks of 0x%8.8lx bytes",
ui32Bytes, (u32) PDUMP_TEMP_BUFFER_SIZE);
}
ui32CurrentOffset = ui32Offset;
for (ui32BytesDumped = 0; ui32BytesDumped < ui32Bytes;) {
PVRSRV_ERROR eError;
u32 ui32BytesToDump =
MIN(PDUMP_TEMP_BUFFER_SIZE, ui32Bytes - ui32BytesDumped);
eError = OSCopyFromUser(psPerProc,
pvAddrKM, pvAddrUM, ui32BytesToDump);
if (eError != PVRSRV_OK) {
PVR_DPF((PVR_DBG_ERROR,
"PDumpMemUM: OSCopyFromUser failed (%d), eError"));
return PVRSRV_ERROR_GENERIC;
}
eError = PDumpMemKM(pvAddrKM,
psMemInfo,
ui32CurrentOffset,
ui32BytesToDump, ui32Flags, hUniqueTag);
if (eError != PVRSRV_OK) {
if (ui32BytesDumped != 0) {
PVR_DPF((PVR_DBG_ERROR,
"PDumpMemUM: PDumpMemKM failed (%d)",
eError));
}
PVR_ASSERT(ui32BytesDumped == 0);
return eError;
}
VPTR_INC(pvAddrUM, ui32BytesToDump);
ui32CurrentOffset += ui32BytesToDump;
ui32BytesDumped += ui32BytesToDump;
}
return PVRSRV_OK;
}
static IMG_INT
PVRSRVBridgeRGXKickCDM(IMG_UINT32 ui32BridgeID,
PVRSRV_BRIDGE_IN_RGXKICKCDM *psRGXKickCDMIN,
PVRSRV_BRIDGE_OUT_RGXKICKCDM *psRGXKickCDMOUT,
CONNECTION_DATA *psConnection)
{
RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
PRGXFWIF_UFO_ADDR *sClientFenceUFOAddressInt = IMG_NULL;
IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
PRGXFWIF_UFO_ADDR *sClientUpdateUFOAddressInt = IMG_NULL;
IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
IMG_HANDLE *hServerSyncsInt2 = IMG_NULL;
IMG_BYTE *psDMCmdInt = IMG_NULL;
PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXKICKCDM);
if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
{
sClientFenceUFOAddressInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
if (!sClientFenceUFOAddressInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psClientFenceUFOAddress, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
|| (OSCopyFromUser(NULL, sClientFenceUFOAddressInt, psRGXKickCDMIN->psClientFenceUFOAddress,
psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
{
ui32ClientFenceValueInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
if (!ui32ClientFenceValueInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientFenceValue, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32ClientFenceValueInt, psRGXKickCDMIN->pui32ClientFenceValue,
psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
{
sClientUpdateUFOAddressInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
if (!sClientUpdateUFOAddressInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psClientUpdateUFOAddress, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
|| (OSCopyFromUser(NULL, sClientUpdateUFOAddressInt, psRGXKickCDMIN->psClientUpdateUFOAddress,
psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
{
ui32ClientUpdateValueInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
if (!ui32ClientUpdateValueInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientUpdateValue, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32ClientUpdateValueInt, psRGXKickCDMIN->pui32ClientUpdateValue,
psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32ServerSyncCount != 0)
{
ui32ServerSyncFlagsInt = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32));
if (!ui32ServerSyncFlagsInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ServerSyncFlags, psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32))
|| (OSCopyFromUser(NULL, ui32ServerSyncFlagsInt, psRGXKickCDMIN->pui32ServerSyncFlags,
psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32ServerSyncCount != 0)
{
psServerSyncsInt = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(SERVER_SYNC_PRIMITIVE *));
if (!psServerSyncsInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
hServerSyncsInt2 = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE));
if (!hServerSyncsInt2)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phServerSyncs, psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE))
|| (OSCopyFromUser(NULL, hServerSyncsInt2, psRGXKickCDMIN->phServerSyncs,
psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
if (psRGXKickCDMIN->ui32CmdSize != 0)
{
psDMCmdInt = OSAllocMem(psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE));
if (!psDMCmdInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXKickCDM_exit;
}
}
/* Copy the data over */
if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psDMCmd, psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE))
|| (OSCopyFromUser(NULL, psDMCmdInt, psRGXKickCDMIN->psDMCmd,
psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXKickCDM_exit;
}
{
/* Look up the address from the handle */
psRGXKickCDMOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hComputeContextInt2,
psRGXKickCDMIN->hComputeContext,
PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
if(psRGXKickCDMOUT->eError != PVRSRV_OK)
{
goto RGXKickCDM_exit;
}
/* Look up the data from the resman address */
psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
if(psRGXKickCDMOUT->eError != PVRSRV_OK)
{
goto RGXKickCDM_exit;
}
}
{
IMG_UINT32 i;
for (i=0;i<psRGXKickCDMIN->ui32ServerSyncCount;i++)
{
{
/* Look up the address from the handle */
psRGXKickCDMOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hServerSyncsInt2[i],
psRGXKickCDMIN->phServerSyncs[i],
PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
if(psRGXKickCDMOUT->eError != PVRSRV_OK)
{
goto RGXKickCDM_exit;
}
/* Look up the data from the resman address */
psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hServerSyncsInt2[i], (IMG_VOID **) &psServerSyncsInt[i]);
if(psRGXKickCDMOUT->eError != PVRSRV_OK)
{
goto RGXKickCDM_exit;
}
}
}
}
psRGXKickCDMOUT->eError =
PVRSRVRGXKickCDMKM(
psComputeContextInt,
psRGXKickCDMIN->ui32ClientFenceCount,
sClientFenceUFOAddressInt,
ui32ClientFenceValueInt,
psRGXKickCDMIN->ui32ClientUpdateCount,
sClientUpdateUFOAddressInt,
ui32ClientUpdateValueInt,
psRGXKickCDMIN->ui32ServerSyncCount,
ui32ServerSyncFlagsInt,
psServerSyncsInt,
psRGXKickCDMIN->ui32CmdSize,
psDMCmdInt,
psRGXKickCDMIN->bbPDumpContinuous);
RGXKickCDM_exit:
if (sClientFenceUFOAddressInt)
OSFreeMem(sClientFenceUFOAddressInt);
if (ui32ClientFenceValueInt)
OSFreeMem(ui32ClientFenceValueInt);
if (sClientUpdateUFOAddressInt)
OSFreeMem(sClientUpdateUFOAddressInt);
if (ui32ClientUpdateValueInt)
OSFreeMem(ui32ClientUpdateValueInt);
if (ui32ServerSyncFlagsInt)
OSFreeMem(ui32ServerSyncFlagsInt);
if (psServerSyncsInt)
OSFreeMem(psServerSyncsInt);
if (hServerSyncsInt2)
OSFreeMem(hServerSyncsInt2);
if (psDMCmdInt)
OSFreeMem(psDMCmdInt);
return 0;
}
