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
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;
}
void PVRSRVExportFDToIONHandles(int fd, struct ion_client **client,
struct ion_handle *handles[2])
{
PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
LinuxMemArea *psLinuxMemArea;
PVRSRV_ERROR eError;
struct file *psFile;
/* Take the bridge mutex so the handle won't be freed underneath us */
LinuxLockMutex(&gPVRSRVLock);
psFile = fget(fd);
if(!psFile)
goto err_unlock;
psPrivateData = psFile->private_data;
if(!psPrivateData)
{
PVR_DPF((PVR_DBG_ERROR, "%s: struct file* has no private_data; "
"invalid export handle", __func__));
goto err_fput;
}
eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
(IMG_PVOID *)&psKernelMemInfo,
psPrivateData->hKernelMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
if(eError != PVRSRV_OK)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Failed to look up MEM_INFO handle",
__func__));
goto err_fput;
}
psLinuxMemArea = (LinuxMemArea *)psKernelMemInfo->sMemBlk.hOSMemHandle;
BUG_ON(psLinuxMemArea == IMG_NULL);
if(psLinuxMemArea->eAreaType != LINUX_MEM_AREA_ION)
{
PVR_DPF((PVR_DBG_ERROR, "%s: Valid handle, but not an ION buffer",
__func__));
goto err_fput;
}
handles[0] = psLinuxMemArea->uData.sIONTilerAlloc.psIONHandle[0];
handles[1] = psLinuxMemArea->uData.sIONTilerAlloc.psIONHandle[1];
if(client)
*client = gpsIONClient;
err_fput:
fput(psFile);
err_unlock:
/* Allow PVRSRV clients to communicate with srvkm again */
LinuxUnLockMutex(&gPVRSRVLock);
}
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
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;
}
int msvdx_preinit_mmu(unsigned long hmemcxt)
{
PVRSRV_ERROR err;
PVRSRV_PER_PROCESS_DATA *ps_data = NULL;
IMG_HANDLE hmem = (IMG_HANDLE) hmemcxt;
IMG_HANDLE hmemkm;
IMG_DEV_PHYADDR addr;
IMG_UINT32 pid = OSGetCurrentProcessIDKM();
int ret;
drm_emgd_priv_t *priv = gpDrmDevice->dev_private;
igd_context_t *context = priv->context;
platform_context_plb_t *platform =
(platform_context_plb_t *) context->platform_context;
ps_data = PVRSRVPerProcessData(pid);
if (!ps_data) {
printk(KERN_ERR "MSVDX: Cannot get process data information");
return -1;
}
err = PVRSRVLookupHandle(ps_data->psHandleBase, &hmemkm, hmem, PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
if(err != PVRSRV_OK)
{
printk(KERN_ERR "MSVDX: Cannot get memory context from process data");
return -1;
}
addr = BM_GetDeviceNode(hmemkm)->pfnMMUGetPDDevPAddr(BM_GetMMUContextFromMemContext(hmemkm));
msvdx_init_compositor_mmu(addr.uiAddr);
if (!platform->msvdx_pvr) {
ret = msvdx_pvr_init();
if (ret) {
printk(KERN_INFO "Failed in msvdx_pvr_init()");
} else {
printk(KERN_INFO "Succeed for msvdx_pvr_init()");
}
}
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
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
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
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
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
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
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
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
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
PVRSRVBridgePDumpTraceBuffer(IMG_UINT32 ui32DispatchTableEntry,
PVRSRV_BRIDGE_IN_PDUMPTRACEBUFFER *psPDumpTraceBufferIN,
PVRSRV_BRIDGE_OUT_PDUMPTRACEBUFFER *psPDumpTraceBufferOUT,
CONNECTION_DATA *psConnection)
{
IMG_HANDLE hDeviceNodeInt = IMG_NULL;
{
/* Look up the address from the handle */
psPDumpTraceBufferOUT->eError =
PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_VOID **) &hDeviceNodeInt,
psPDumpTraceBufferIN->hDeviceNode,
PVRSRV_HANDLE_TYPE_DEV_NODE);
if(psPDumpTraceBufferOUT->eError != PVRSRV_OK)
{
goto PDumpTraceBuffer_exit;
}
}
psPDumpTraceBufferOUT->eError =
PVRSRVPDumpTraceBufferKM(
hDeviceNodeInt,
psPDumpTraceBufferIN->ui32PDumpFlags);
PDumpTraceBuffer_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
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;
}
int psb_get_meminfo_by_handle(IMG_HANDLE hKernelMemInfo,
PVRSRV_KERNEL_MEM_INFO **ppsKernelMemInfo)
{
PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = IMG_NULL;
PVRSRV_PER_PROCESS_DATA *psPerProc = IMG_NULL;
PVRSRV_ERROR eError;
psPerProc = PVRSRVPerProcessData(OSGetCurrentProcessIDKM());
eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
(IMG_VOID *)&psKernelMemInfo,
hKernelMemInfo,
PVRSRV_HANDLE_TYPE_MEM_INFO);
if (eError != PVRSRV_OK) {
DRM_ERROR("Cannot find kernel meminfo for handle 0x%x\n",
(IMG_UINT32)hKernelMemInfo);
return -EINVAL;
}
*ppsKernelMemInfo = psKernelMemInfo;
DRM_DEBUG("Got Kernel MemInfo for handle %x\n",
(IMG_UINT32)hKernelMemInfo);
return 0;
}
int MMapPMR(struct file *pFile, struct vm_area_struct *ps_vma)
{
PVRSRV_ERROR eError;
IMG_HANDLE hSecurePMRHandle;
IMG_SIZE_T uiLength;
IMG_DEVMEM_OFFSET_T uiOffset;
unsigned long uiPFN;
IMG_HANDLE hPMRResmanHandle;
PMR *psPMR;
PMR_FLAGS_T ulPMRFlags;
IMG_UINT32 ui32CPUCacheFlags;
unsigned long ulNewFlags = 0;
pgprot_t sPageProt;
#if defined(SUPPORT_DRM)
CONNECTION_DATA *psConnection = LinuxConnectionFromFile(PVR_DRM_FILE_FROM_FILE(pFile));
#else
CONNECTION_DATA *psConnection = LinuxConnectionFromFile(pFile);
#endif
#if defined(PVR_MMAP_USE_VM_INSERT)
IMG_BOOL bMixedMap = IMG_FALSE;
#endif
/*
* The pmr lock used here to protect both handle related operations and PMR
* operations.
* This was introduced to fix lockdep issue.
*/
mutex_lock(&g_sMMapMutex);
PMRLock();
#if defined(SUPPORT_DRM_DC_MODULE)
psPMR = PVRSRVGEMMMapLookupPMR(pFile, ps_vma);
if (!psPMR)
#endif
{
hSecurePMRHandle = (IMG_HANDLE)((IMG_UINTPTR_T)ps_vma->vm_pgoff);
eError = PVRSRVLookupHandle(psConnection->psHandleBase,
(IMG_HANDLE *) &hPMRResmanHandle,
hSecurePMRHandle,
PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
if (eError != PVRSRV_OK)
{
goto e0;
}
eError = ResManFindPrivateDataByPtr(hPMRResmanHandle,
(void **)&psPMR);
if (eError != PVRSRV_OK)
{
goto e0;
}
}
/*
* Take a reference on the PMR, make's sure that it can't be freed
* while it's mapped into the user process
*/
PMRRefPMR(psPMR);
PMRUnlock();
eError = PMRLockSysPhysAddresses(psPMR, PAGE_SHIFT);
if (eError != PVRSRV_OK)
{
goto e1;
}
if (((ps_vma->vm_flags & VM_WRITE) != 0) &&
((ps_vma->vm_flags & VM_SHARED) == 0))
{
eError = PVRSRV_ERROR_INVALID_PARAMS;
goto e1;
}
/*
* We ought to call PMR_Flags() here to check the permissions
* against the requested mode, and possibly to set up the cache
* control protflags
*/
eError = PMR_Flags(psPMR, &ulPMRFlags);
if (eError != PVRSRV_OK)
{
goto e1;
}
ulNewFlags = ps_vma->vm_flags;
#if 0
/* Discard user read/write request, we will pull these flags from the PMR */
ulNewFlags &= ~(VM_READ | VM_WRITE);
if (ulPMRFlags & PVRSRV_MEMALLOCFLAG_CPU_READABLE)
{
ulNewFlags |= VM_READ;
}
if (ulPMRFlags & PVRSRV_MEMALLOCFLAG_CPU_WRITEABLE)
{
ulNewFlags |= VM_WRITE;
}
#endif
ps_vma->vm_flags = ulNewFlags;
#if defined (CONFIG_ARM64)
sPageProt = __pgprot_modify(ps_vma->vm_page_prot, 0, vm_get_page_prot(ulNewFlags));
#elif defined(CONFIG_ARM)
sPageProt = __pgprot_modify(ps_vma->vm_page_prot, L_PTE_MT_MASK, vm_get_page_prot(ulNewFlags));
#elif defined(CONFIG_X86)
sPageProt = pgprot_modify(ps_vma->vm_page_prot, vm_get_page_prot(ulNewFlags));
#elif defined(CONFIG_METAG) || defined(CONFIG_MIPS)
sPageProt = vm_get_page_prot(ulNewFlags);
#else
#error Please add pgprot_modify equivalent for your system
#endif
ui32CPUCacheFlags = DevmemCPUCacheMode(ulPMRFlags);
switch (ui32CPUCacheFlags)
{
case PVRSRV_MEMALLOCFLAG_CPU_UNCACHED:
sPageProt = pgprot_noncached(sPageProt);
break;
case PVRSRV_MEMALLOCFLAG_CPU_WRITE_COMBINE:
sPageProt = pgprot_writecombine(sPageProt);
break;
case PVRSRV_MEMALLOCFLAG_CPU_CACHED:
break;
default:
eError = PVRSRV_ERROR_INVALID_PARAMS;
goto e1;
}
ps_vma->vm_page_prot = sPageProt;
uiLength = ps_vma->vm_end - ps_vma->vm_start;
ps_vma->vm_flags |= VM_IO;
/* Don't include the mapping in core dumps */
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
ps_vma->vm_flags |= VM_DONTDUMP;
#else
ps_vma->vm_flags |= VM_RESERVED;
#endif
/*
* Disable mremap because our nopage handler assumes all
* page requests have already been validated.
*/
ps_vma->vm_flags |= VM_DONTEXPAND;
/* Don't allow mapping to be inherited across a process fork */
ps_vma->vm_flags |= VM_DONTCOPY;
#if defined(PVR_MMAP_USE_VM_INSERT)
{
/* Scan the map range for pfns without struct page* handling. If we find
* one, this is a mixed map, and we can't use vm_insert_page().
*/
for (uiOffset = 0; uiOffset < uiLength; uiOffset += 1ULL<<PAGE_SHIFT)
{
IMG_CPU_PHYADDR sCpuPAddr;
IMG_BOOL bValid;
eError = PMR_CpuPhysAddr(psPMR, uiOffset, &sCpuPAddr, &bValid);
PVR_ASSERT(eError == PVRSRV_OK);
if (eError)
{
goto e2;
}
if (bValid)
{
uiPFN = sCpuPAddr.uiAddr >> PAGE_SHIFT;
PVR_ASSERT(((IMG_UINT64)uiPFN << PAGE_SHIFT) == sCpuPAddr.uiAddr);
if (!pfn_valid(uiPFN) || page_count(pfn_to_page(uiPFN)) == 0)
{
bMixedMap = IMG_TRUE;
}
}
}
if (bMixedMap)
{
ps_vma->vm_flags |= VM_MIXEDMAP;
}
}
#endif /* defined(PVR_MMAP_USE_VM_INSERT) */
for (uiOffset = 0; uiOffset < uiLength; uiOffset += 1ULL<<PAGE_SHIFT)
{
IMG_SIZE_T uiNumContiguousBytes;
IMG_INT32 iStatus;
IMG_CPU_PHYADDR sCpuPAddr;
IMG_BOOL bValid;
uiNumContiguousBytes = 1ULL<<PAGE_SHIFT;
eError = PMR_CpuPhysAddr(psPMR,
uiOffset,
&sCpuPAddr,
&bValid);
PVR_ASSERT(eError == PVRSRV_OK);
if (eError)
{
goto e2;
}
/*
Only map in pages that are valid, any that aren't will be picked up
by the nopage handler which will return a zeroed page for us
*/
if (bValid)
{
uiPFN = sCpuPAddr.uiAddr >> PAGE_SHIFT;
PVR_ASSERT(((IMG_UINT64)uiPFN << PAGE_SHIFT) == sCpuPAddr.uiAddr);
#if defined(PVR_MMAP_USE_VM_INSERT)
if (bMixedMap)
{
/* This path is just for debugging. It should be equivalent
* to the remap_pfn_range() path.
*/
iStatus = vm_insert_mixed(ps_vma,
ps_vma->vm_start + uiOffset,
uiPFN);
}
else
{
iStatus = vm_insert_page(ps_vma,
ps_vma->vm_start + uiOffset,
pfn_to_page(uiPFN));
}
#else /* defined(PVR_MMAP_USE_VM_INSERT) */
iStatus = remap_pfn_range(ps_vma,
ps_vma->vm_start + uiOffset,
uiPFN,
uiNumContiguousBytes,
ps_vma->vm_page_prot);
#endif /* defined(PVR_MMAP_USE_VM_INSERT) */
PVR_ASSERT(iStatus == 0);
if(iStatus)
{
// N.B. not the right error code, but, it doesn't get propagated anyway... :(
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto e2;
}
#if defined(PVRSRV_ENABLE_PROCESS_STATS)
/* USER MAPPING*/
#if !defined(PVRSRV_ENABLE_MEMORY_STATS)
PVRSRVStatsIncrMemAllocStat(PVRSRV_MEM_ALLOC_TYPE_MAP_UMA_LMA_PAGES, PAGE_SIZE);
#else
PVRSRVStatsAddMemAllocRecord(PVRSRV_MEM_ALLOC_TYPE_MAP_UMA_LMA_PAGES,
(IMG_VOID*)(IMG_UINTPTR_T)(ps_vma->vm_start + uiOffset),
sCpuPAddr,
PAGE_SIZE,
IMG_NULL);
#endif
#endif
}
(void)pFile;
}
/* let us see the PMR so we can unlock it later */
ps_vma->vm_private_data = psPMR;
/* Install open and close handlers for ref-counting */
ps_vma->vm_ops = &gsMMapOps;
mutex_unlock(&g_sMMapMutex);
return 0;
/*
error exit paths follow
*/
e2:
PVR_DPF((PVR_DBG_ERROR, "don't know how to handle this error. Abort!"));
PMRUnlockSysPhysAddresses(psPMR);
e1:
PMRUnrefPMR(psPMR);
goto em1;
e0:
PVR_DPF((PVR_DBG_ERROR, "Error in MMapPMR critical section"));
PMRUnlock();
em1:
PVR_ASSERT(eError != PVRSRV_OK);
PVR_DPF((PVR_DBG_ERROR, "unable to translate error %d", eError));
mutex_unlock(&g_sMMapMutex);
return -ENOENT; // -EAGAIN // or what?
}
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;
}
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;
}