/*! ****************************************************************************** @Function PVRSRVAllocHandleBase @Description Allocate a handle base structure for a process @Input ppsBase - pointer to handle base structure pointer @Output ppsBase - points to handle base structure pointer @Return Error code or PVRSRV_OK ******************************************************************************/ PVRSRV_ERROR PVRSRVAllocHandleBase(PVRSRV_HANDLE_BASE **ppsBase) { PVRSRV_HANDLE_BASE *psBase; PVRSRV_ERROR eError; if (gpsHandleFuncs == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Handle management not initialised")); return PVRSRV_ERROR_NOT_READY; } if (ppsBase == IMG_NULL) { eError = PVRSRV_ERROR_INVALID_PARAMS; goto err; } psBase = OSAllocZMem(sizeof(*psBase)); if (psBase == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't allocate handle base")); eError = PVRSRV_ERROR_OUT_OF_MEMORY; goto err; } eError = gpsHandleFuncs->pfnCreateHandleBase(&psBase->psImplBase); if (eError != PVRSRV_OK) { goto ErrorFreeHandleBase; } psBase->psHashTab = HASH_Create_Extended(HANDLE_HASH_TAB_INIT_SIZE, sizeof(HAND_KEY), HASH_Func_Default, HASH_Key_Comp_Default); if (psBase->psHashTab == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocHandleBase: Couldn't create data pointer hash table")); eError = PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE; goto ErrorDestroyHandleBase; } *ppsBase = psBase; return PVRSRV_OK; ErrorDestroyHandleBase: (IMG_VOID)gpsHandleFuncs->pfnDestroyHandleBase(psBase->psImplBase); ErrorFreeHandleBase: OSFreeMem(psBase); err: return eError; }
/* * ################################################################### * Función : * Descripción : * Parmámetros : * Retorna : * ################################################################### */ OS_ERROR OSSemFree(OS_SEM *sem) { OS_CPU_SR sr; if(sem->OSBlockListHead != NULL) // y no tiene procesos bloqueados return OS_ERROR_SEM_HAVE_BLOCKED_TASK; sr = OSEnterCriticalSection(); OSRemoveSemCreatedList(sem); // Sacar de la lista de semaforos creados OSExitCriticalSection(sr); OSFreeMem(sem); // y liberar la memoria return OS_ERROR_NONE; }
IMG_EXPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfoKM(PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo) { PVRSRV_ERROR eError; eError = FreeDeviceMem(psKernelSyncInfo->psSyncDataMemInfoKM); (IMG_VOID)OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_KERNEL_SYNC_INFO), psKernelSyncInfo, IMG_NULL); return eError; }
static PVRSRV_ERROR _PVRSRVSyncPrimServerUnexportKM(SERVER_SYNC_EXPORT *psExport) { /* FIXME: Lock */ _ServerSyncUnref(psExport->psSync); /* FIXME: Unlock */ OSFreeMem(psExport); return PVRSRV_OK; }
IMG_EXPORT PVRSRV_ERROR PVRSRVAllocSharedSysMemoryKM(PVRSRV_PER_PROCESS_DATA *psPerProc, IMG_UINT32 ui32Flags, IMG_SIZE_T uSize, PVRSRV_KERNEL_MEM_INFO **ppsKernelMemInfo) { PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo; if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), (IMG_VOID **)&psKernelMemInfo, IMG_NULL, "Kernel Memory Info") != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for meminfo")); return PVRSRV_ERROR_OUT_OF_MEMORY; } OSMemSet(psKernelMemInfo, 0, sizeof(*psKernelMemInfo)); ui32Flags &= ~PVRSRV_HAP_MAPTYPE_MASK; ui32Flags |= PVRSRV_HAP_MULTI_PROCESS; psKernelMemInfo->ui32Flags = ui32Flags; psKernelMemInfo->uAllocSize = uSize; if(OSAllocPages(psKernelMemInfo->ui32Flags, psKernelMemInfo->uAllocSize, (IMG_UINT32)HOST_PAGESIZE(), IMG_NULL, 0, IMG_NULL, &psKernelMemInfo->pvLinAddrKM, &psKernelMemInfo->sMemBlk.hOSMemHandle) != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVAllocSharedSysMemoryKM: Failed to alloc memory for block")); OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_KERNEL_MEM_INFO), psKernelMemInfo, 0); return PVRSRV_ERROR_OUT_OF_MEMORY; } /* register with the resman */ psKernelMemInfo->sMemBlk.hResItem = ResManRegisterRes(psPerProc->hResManContext, RESMAN_TYPE_SHARED_MEM_INFO, psKernelMemInfo, 0, &FreeSharedSysMemCallBack); *ppsKernelMemInfo = psKernelMemInfo; return PVRSRV_OK; }
static void BM_FreeMemory(void *h, u32 _base, struct BM_MAPPING *psMapping) { struct BM_HEAP *pBMHeap = h; size_t uPSize; PVR_UNREFERENCED_PARAMETER(_base); PVR_DPF(PVR_DBG_MESSAGE, "BM_FreeMemory (h=%08X, base=0x%x, psMapping=0x%x)", h, _base, psMapping); PVR_ASSERT(psMapping != NULL); if (psMapping == NULL) { PVR_DPF(PVR_DBG_ERROR, "BM_FreeMemory: invalid parameter"); return; } DevMemoryFree(psMapping); if ((psMapping->ui32Flags & PVRSRV_MEM_INTERLEAVED) != 0) psMapping->uSize /= 2; if (psMapping->ui32Flags & PVRSRV_MEM_DUMMY) uPSize = psMapping->pBMHeap->sDevArena.ui32DataPageSize; else uPSize = psMapping->uSize; if (pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_SYSMEM_NONCONTIG) { OSFreePages(pBMHeap->ui32Attribs, uPSize, (void *)psMapping->CpuVAddr, psMapping->hOSMemHandle); } else if (pBMHeap->ui32Attribs & PVRSRV_BACKINGSTORE_LOCALMEM_CONTIG) { struct IMG_SYS_PHYADDR sSysPAddr; OSUnReservePhys(psMapping->CpuVAddr, uPSize, pBMHeap->ui32Attribs, psMapping->hOSMemHandle); sSysPAddr = SysCpuPAddrToSysPAddr(psMapping->CpuPAddr); RA_Free(pBMHeap->pLocalDevMemArena, sSysPAddr.uiAddr, IMG_FALSE); } else { PVR_DPF(PVR_DBG_ERROR, "BM_FreeMemory: Invalid backing store type"); } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct BM_MAPPING), psMapping, NULL); PVR_DPF(PVR_DBG_MESSAGE, "..BM_FreeMemory (h=%08X, base=0x%x, psMapping=0x%x)", h, _base, psMapping); }
static enum PVRSRV_ERROR AllocDeviceMem(void *hDevCookie, void *hDevMemHeap, u32 ui32Flags, u32 ui32Size, u32 ui32Alignment, struct PVRSRV_KERNEL_MEM_INFO **ppsMemInfo) { struct PVRSRV_KERNEL_MEM_INFO *psMemInfo; void *hBuffer; struct PVRSRV_MEMBLK *psMemBlock; IMG_BOOL bBMError; PVR_UNREFERENCED_PARAMETER(hDevCookie); *ppsMemInfo = NULL; if (OSAllocMem(PVRSRV_PAGEABLE_SELECT, sizeof(struct PVRSRV_KERNEL_MEM_INFO), (void **) &psMemInfo, NULL) != PVRSRV_OK) { PVR_DPF(PVR_DBG_ERROR, "AllocDeviceMem: Failed to alloc memory for block"); return PVRSRV_ERROR_OUT_OF_MEMORY; } OSMemSet(psMemInfo, 0, sizeof(*psMemInfo)); psMemBlock = &(psMemInfo->sMemBlk); psMemInfo->ui32Flags = ui32Flags | PVRSRV_MEM_RAM_BACKED_ALLOCATION; bBMError = BM_Alloc(hDevMemHeap, NULL, ui32Size, &psMemInfo->ui32Flags, ui32Alignment, &hBuffer); if (!bBMError) { PVR_DPF(PVR_DBG_ERROR, "AllocDeviceMem: BM_Alloc Failed"); OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(struct PVRSRV_KERNEL_MEM_INFO), psMemInfo, NULL); return PVRSRV_ERROR_OUT_OF_MEMORY; } psMemBlock->sDevVirtAddr = BM_HandleToDevVaddr(hBuffer); psMemBlock->hOSMemHandle = BM_HandleToOSMemHandle(hBuffer); psMemBlock->hBuffer = (void *)hBuffer; psMemInfo->pvLinAddrKM = BM_HandleToCpuVaddr(hBuffer); psMemInfo->sDevVAddr = psMemBlock->sDevVirtAddr; psMemInfo->ui32AllocSize = ui32Size; psMemInfo->pvSysBackupBuffer = NULL; *ppsMemInfo = psMemInfo; return PVRSRV_OK; }
static PVRSRV_ERROR CloseBCDeviceCallBack(IMG_PVOID pvParam, IMG_UINT32 ui32Param) { PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *psBCPerContextInfo; PVRSRV_BUFFERCLASS_INFO *psBCInfo; PVR_UNREFERENCED_PARAMETER(ui32Param); psBCPerContextInfo = (PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *)pvParam; psBCInfo = psBCPerContextInfo->psBCInfo; psBCInfo->ui32RefCount--; if(psBCInfo->ui32RefCount == 0) { IMG_UINT32 i; psBCInfo->psFuncTable->pfnCloseBCDevice(psBCInfo->hExtDevice); for(i=0; i<psBCInfo->ui32BufferCount; i++) { if(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo) { PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i].sDeviceClassBuffer.psKernelSyncInfo); } } if(psBCInfo->psBuffer) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BC_BUFFER), psBCInfo->psBuffer, IMG_NULL); psBCInfo->psBuffer = IMG_NULL; } } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(PVRSRV_BUFFERCLASS_PERCONTEXT_INFO), psBCPerContextInfo, IMG_NULL); return PVRSRV_OK; }
IMG_VOID SysDestroyConfigData(PVRSRV_SYSTEM_CONFIG *psSysConfig) { PLAT_DATA *psPlatData = gpsPlatData; PVR_UNREFERENCED_PARAMETER(psSysConfig); PCIDeInitDev(psPlatData); OSFreeMem(psPlatData); #if defined(SUPPORT_ION) IonDeinit(); #endif }
IMG_VOID IMG_CALLCONV PVRSRVDeInit(PSYS_DATA psSysData) { PVRSRV_ERROR eError; PVR_UNREFERENCED_PARAMETER(psSysData); if (psSysData == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed - invalid param")); return; } PERFDEINIT(); #if defined(TTRACE) if ((g_ui32InitFlags & INIT_DATA_ENABLE_TTARCE) > 0) { PVRSRVTimeTraceDeinit(); } #endif if( (g_ui32InitFlags & INIT_DATA_ENABLE_PDUMPINIT) > 0) { PDUMPDEINIT(); } if(psSysData->psGlobalEventObject) { OSEventObjectDestroyKM(psSysData->psGlobalEventObject); OSFreeMem( PVRSRV_PAGEABLE_SELECT, sizeof(PVRSRV_EVENTOBJECT), psSysData->psGlobalEventObject, 0); psSysData->psGlobalEventObject = IMG_NULL; } eError = PVRSRVHandleDeInit(); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVHandleDeInit failed")); } eError = PVRSRVPerProcessDataDeInit(); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVDeInit: PVRSRVPerProcessDataDeInit failed")); } ResManDeInit(); }
static IMG_VOID SysFreeVersionString(SYS_DATA *psSysData) { if(psSysData->pszVersionString) { IMG_UINT32 ui32MaxStrLen; ui32MaxStrLen = OSStringLength(VERSION_STR_MAX_LEN_TEMPLATE); OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32MaxStrLen+1, psSysData->pszVersionString, IMG_NULL); psSysData->pszVersionString = IMG_NULL; } }
static IMG_BOOL _SyncRecordListDestroy(PDLLIST_NODE psNode, IMG_PVOID pvCallbackData) { struct SYNC_RECORD *pSyncRec; PVR_UNREFERENCED_PARAMETER(pvCallbackData); pSyncRec = IMG_CONTAINER_OF(psNode, struct SYNC_RECORD, sNode); dllist_remove_node(psNode); OSFreeMem(pSyncRec); return IMG_TRUE; }
/*! ****************************************************************************** @Function PVRSRVTimeTraceBufferDestroy @Description Destroy a trace buffer. Note: We assume that this will only be called once per process. @Input ui32PID : PID of the process that is creating the buffer @Return none ******************************************************************************/ PVRSRV_ERROR PVRSRVTimeTraceBufferDestroy(IMG_UINT32 ui32PID) { sTimeTraceBuffer *psBuffer; #if defined(DUMP_TTRACE_BUFFERS_ON_EXIT) PVRSRVDumpTimeTraceBuffers(); #endif psBuffer = (sTimeTraceBuffer *) HASH_Retrieve(g_psBufferTable, (IMG_UINTPTR_T) ui32PID); if (psBuffer) { if (psBuffer->pui8Data) OSFreeMem(PVRSRV_PAGEABLE_SELECT, TIME_TRACE_BUFFER_SIZE, psBuffer->pui8Data, NULL); OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(sTimeTraceBuffer), psBuffer, NULL); HASH_Remove(g_psBufferTable, (IMG_UINTPTR_T) ui32PID); return PVRSRV_OK; } PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferDestroy: Can't find trace buffer in hash table")); return PVRSRV_ERROR_INVALID_PARAMS; }
void PDumpDeInit(void) { pdumpfs_cleanup(); if (gpszFile) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (void *)gpszFile, NULL); gpszFile = NULL; } if (gpszScript) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (void *)gpszScript, NULL); gpszScript = NULL; } if (gpszComment) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_COMMENT_SIZE_MAX, (void *)gpszComment, NULL); gpszComment = NULL; } }
IMG_VOID SysDestroyConfigData(PVRSRV_SYSTEM_CONFIG *psSysConfig) { PLAT_DATA *psPlatData = gpsPlatData; PVR_UNREFERENCED_PARAMETER(psSysConfig); PCIDeInitDev(psPlatData); OSFreeMem(psPlatData); #if defined(SUPPORT_ION) #error "Need to check this function call" IonDeinit(NULL); #endif }
static enum PVRSRV_ERROR CloseBCDeviceCallBack(void *pvParam, u32 ui32Param) { struct PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *psBCPerContextInfo; struct PVRSRV_BUFFERCLASS_INFO *psBCInfo; PVR_UNREFERENCED_PARAMETER(ui32Param); psBCPerContextInfo = (struct PVRSRV_BUFFERCLASS_PERCONTEXT_INFO *) pvParam; psBCInfo = psBCPerContextInfo->psBCInfo; psBCInfo->ui32RefCount--; if (psBCInfo->ui32RefCount == 0) { u32 i; psBCInfo->psFuncTable->pfnCloseBCDevice(psBCInfo->hExtDevice); for (i = 0; i < psBCInfo->ui32BufferCount; i++) { if (psBCInfo->psBuffer[i].sDeviceClassBuffer. psKernelSyncInfo) PVRSRVFreeSyncInfoKM(psBCInfo->psBuffer[i]. sDeviceClassBuffer. psKernelSyncInfo); } if (psBCInfo->psBuffer) OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct PVRSRV_BC_BUFFER) * psBCInfo->ui32BufferCount, psBCInfo->psBuffer, NULL); } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct PVRSRV_BUFFERCLASS_PERCONTEXT_INFO), psBCPerContextInfo, NULL); return PVRSRV_OK; }
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; }
IMG_INTERNAL PVRSRV_ERROR TLClientCloseStream(IMG_HANDLE hSrvHandle, IMG_HANDLE hSD) { PVRSRV_ERROR eError = PVRSRV_OK; TL_STREAM_DESC* psSD = (TL_STREAM_DESC*) hSD; PVR_ASSERT(hSrvHandle); PVR_ASSERT(hSD); /* Check the caller provided connection is valid */ if(!psSD->hServerSD) { PVR_DPF((PVR_DBG_ERROR, "TLClientCloseStream: descriptor already closed/not open")); return PVRSRV_ERROR_HANDLE_NOT_FOUND; } /* Check if acquire is outstanding, perform release if it is, ignore result * as there is not much we can do if it is an error other than close */ if (psSD->uiReadLen != NO_ACQUIRE) { (void) BridgeTLReleaseData(hSrvHandle, psSD->hServerSD, psSD->uiReadOffset, psSD->uiReadLen); psSD->uiReadLen = psSD->uiReadOffset = NO_ACQUIRE; } /* Clean up DevMem resources used for this stream in this client */ DevmemReleaseCpuVirtAddr(psSD->psUMmemDesc); DevmemFree(psSD->psUMmemDesc); /* Ignore error, not much that can be done */ (void) DevmemUnmakeServerExportClientExport(hSrvHandle, &psSD->sExportCookie); /* Send close to server to clean up kernel mode resources for this * handle and release the memory. */ eError = BridgeTLCloseStream(hSrvHandle, psSD->hServerSD); if (eError != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR, "BridgeTLCloseStream: KM returned %d", eError)); /*/ Not much we can do with error, fall through to clean up * return eError; */ } OSMemSet(psSD, 0x00, sizeof(TL_STREAM_DESC)); OSFreeMem (psSD); return eError; }
static PVRSRV_ERROR BM_DestroyContextCallBack(IMG_PVOID pvParam, IMG_UINT32 ui32Param) { BM_CONTEXT *pBMContext = pvParam; PVRSRV_DEVICE_NODE *psDeviceNode; PVRSRV_ERROR eError; PVR_UNREFERENCED_PARAMETER(ui32Param); psDeviceNode = pBMContext->psDeviceNode; eError = List_BM_HEAP_PVRSRV_ERROR_Any_va(pBMContext->psBMHeap, &BM_DestroyContextCallBack_AnyVaCb, psDeviceNode); if (eError != PVRSRV_OK) { return eError; } if (pBMContext->psMMUContext) { psDeviceNode->pfnMMUFinalise(pBMContext->psMMUContext); } if (pBMContext->pBufferHash) { HASH_Delete(pBMContext->pBufferHash); } if (pBMContext == psDeviceNode->sDevMemoryInfo.pBMKernelContext) { psDeviceNode->sDevMemoryInfo.pBMKernelContext = IMG_NULL; } else { List_BM_CONTEXT_Remove(pBMContext); } OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(BM_CONTEXT), pBMContext, IMG_NULL); return PVRSRV_OK; }
/*************************************************************************/ /*! @Function OSPCISetDev @Description Set a PCI device for subsequent use. @Input pvPCICookie Pointer to OS specific PCI structure @Input eFlags Flags @Return PVRSRV_PCI_DEV_HANDLE Pointer to PCI device handle */ /**************************************************************************/ PVRSRV_PCI_DEV_HANDLE OSPCISetDev(IMG_VOID *pvPCICookie, HOST_PCI_INIT_FLAGS eFlags) { int err; IMG_UINT32 i; PVR_PCI_DEV *psPVRPCI; psPVRPCI = OSAllocMem(sizeof(*psPVRPCI)); if (psPVRPCI == IMG_NULL) { printk(KERN_ERR "OSPCISetDev: Couldn't allocate PVR PCI structure\n"); return IMG_NULL; } psPVRPCI->psPCIDev = (struct pci_dev *)pvPCICookie; psPVRPCI->ePCIFlags = eFlags; err = pci_enable_device(psPVRPCI->psPCIDev); if (err != 0) { printk(KERN_ERR "OSPCISetDev: Couldn't enable device (%d)\n", err); OSFreeMem(psPVRPCI); return IMG_NULL; } if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_BUS_MASTER) /* PRQA S 3358 */ /* misuse of enums */ { pci_set_master(psPVRPCI->psPCIDev); } if (psPVRPCI->ePCIFlags & HOST_PCI_INIT_FLAG_MSI) /* PRQA S 3358 */ /* misuse of enums */ { #if defined(CONFIG_PCI_MSI) err = pci_enable_msi(psPVRPCI->psPCIDev); if (err != 0) { printk(KERN_ERR "OSPCISetDev: Couldn't enable MSI (%d)", err); psPVRPCI->ePCIFlags &= ~HOST_PCI_INIT_FLAG_MSI; /* PRQA S 1474,3358,4130 */ /* misuse of enums */ } #else printk(KERN_ERR "OSPCISetDev: MSI support not enabled in the kernel"); #endif } /* Initialise the PCI resource tracking array */ for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { psPVRPCI->abPCIResourceInUse[i] = IMG_FALSE; } return (PVRSRV_PCI_DEV_HANDLE)psPVRPCI; }
/*! ****************************************************************************** @Function PVRSRVRegisterDevice @Description registers a device with the system @Input psSysData : sysdata structure @Input pfnRegisterDevice : device registration function @Input ui32SOCInterruptBit : SoC interrupt bit for this device @Output pui32DeviceIndex : unique device key (for case of multiple identical devices) @Return PVRSRV_ERROR : ******************************************************************************/ PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData, PVRSRV_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*), IMG_UINT32 ui32SOCInterruptBit, IMG_UINT32 *pui32DeviceIndex) { PVRSRV_ERROR eError; PVRSRV_DEVICE_NODE *psDeviceNode; /* Allocate device node */ if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), (IMG_VOID **)&psDeviceNode, IMG_NULL, "Device Node") != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to alloc memory for psDeviceNode")); return (PVRSRV_ERROR_OUT_OF_MEMORY); } OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE)); eError = pfnRegisterDevice(psDeviceNode); if (eError != PVRSRV_OK) { OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL); /*not nulling pointer, out of scope*/ PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to register device")); return (PVRSRV_ERROR_DEVICE_REGISTER_FAILED); } /* make the refcount 1 and test on this to initialise device at acquiredevinfo. On release if refcount is 1, deinitialise and when refcount is 0 (sysdata de-alloc) deallocate the device structures */ psDeviceNode->ui32RefCount = 1; psDeviceNode->psSysData = psSysData; psDeviceNode->ui32SOCInterruptBit = ui32SOCInterruptBit; /* all devices need a unique identifier */ AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex); /* and finally insert the device into the dev-list */ List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode); /* and copy back index */ *pui32DeviceIndex = psDeviceNode->sDevId.ui32DeviceIndex; return PVRSRV_OK; }
static enum PVRSRV_ERROR FreePerProcessData( struct PVRSRV_PER_PROCESS_DATA *psPerProc) { enum PVRSRV_ERROR eError; u32 uiPerProc; PVR_ASSERT(psPerProc != NULL); uiPerProc = HASH_Remove(psHashTab, (u32)psPerProc->ui32PID); if (uiPerProc == 0) { PVR_DPF(PVR_DBG_ERROR, "FreePerProcessData: " "Couldn't find process in per-process data hash table"); PVR_ASSERT(psPerProc->ui32PID == 0); } else { PVR_ASSERT((struct PVRSRV_PER_PROCESS_DATA *) uiPerProc == psPerProc); PVR_ASSERT(((struct PVRSRV_PER_PROCESS_DATA *)uiPerProc)-> ui32PID == psPerProc->ui32PID); } if (psPerProc->psHandleBase != NULL) { eError = PVRSRVFreeHandleBase(psPerProc->psHandleBase); if (eError != PVRSRV_OK) { PVR_DPF(PVR_DBG_ERROR, "FreePerProcessData: " "Couldn't free handle base for process (%d)", eError); return eError; } } if (psPerProc->hPerProcData != NULL) { eError = PVRSRVReleaseHandle(KERNEL_HANDLE_BASE, psPerProc->hPerProcData, PVRSRV_HANDLE_TYPE_PERPROC_DATA); if (eError != PVRSRV_OK) { PVR_DPF(PVR_DBG_ERROR, "FreePerProcessData: " "Couldn't release per-process data handle (%d)", eError); return eError; } } OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(*psPerProc), psPerProc, psPerProc->hBlockAlloc); return PVRSRV_OK; }
static IMG_INT PVRSRVBridgeEnumerateDevices(IMG_UINT32 ui32BridgeID, PVRSRV_BRIDGE_IN_ENUMERATEDEVICES *psEnumerateDevicesIN, PVRSRV_BRIDGE_OUT_ENUMERATEDEVICES *psEnumerateDevicesOUT, CONNECTION_DATA *psConnection) { PVRSRV_DEVICE_IDENTIFIER *psDeviceIdentifierInt = IMG_NULL; PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SRVCORE_ENUMERATEDEVICES); PVR_UNREFERENCED_PARAMETER(psConnection); PVR_UNREFERENCED_PARAMETER(psEnumerateDevicesIN); psEnumerateDevicesOUT->psDeviceIdentifier = psEnumerateDevicesIN->psDeviceIdentifier; { psDeviceIdentifierInt = OSAllocMem(PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER)); if (!psDeviceIdentifierInt) { psEnumerateDevicesOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY; goto EnumerateDevices_exit; } } psEnumerateDevicesOUT->eError = PVRSRVEnumerateDevicesKM( &psEnumerateDevicesOUT->ui32NumDevices, psDeviceIdentifierInt); if ( !OSAccessOK(PVR_VERIFY_WRITE, (IMG_VOID*) psEnumerateDevicesOUT->psDeviceIdentifier, (PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER))) || (OSCopyToUser(NULL, psEnumerateDevicesOUT->psDeviceIdentifier, psDeviceIdentifierInt, (PVRSRV_MAX_DEVICES * sizeof(PVRSRV_DEVICE_IDENTIFIER))) != PVRSRV_OK) ) { psEnumerateDevicesOUT->eError = PVRSRV_ERROR_INVALID_PARAMS; goto EnumerateDevices_exit; } EnumerateDevices_exit: if (psDeviceIdentifierInt) OSFreeMem(psDeviceIdentifierInt); return 0; }
IMG_INTERNAL PVRSRV_ERROR _DevmemMemDescAlloc(DEVMEM_MEMDESC **ppsMemDesc) { DEVMEM_MEMDESC *psMemDesc; PVRSRV_ERROR eError; psMemDesc = OSAllocMem(sizeof(DEVMEM_MEMDESC)); if (psMemDesc == IMG_NULL) { eError = PVRSRV_ERROR_OUT_OF_MEMORY; goto failAlloc; } /* Structure must be zero'd incase it needs to be freed before it is initialised! */ OSMemSet(psMemDesc, 0, sizeof(DEVMEM_MEMDESC)); eError = OSLockCreate(&psMemDesc->hLock, LOCK_TYPE_PASSIVE); if (eError != PVRSRV_OK) { goto failMDLock; } eError = OSLockCreate(&psMemDesc->sDeviceMemDesc.hLock, LOCK_TYPE_PASSIVE); if (eError != PVRSRV_OK) { goto failDMDLock; } eError = OSLockCreate(&psMemDesc->sCPUMemDesc.hLock, LOCK_TYPE_PASSIVE); if (eError != PVRSRV_OK) { goto failCMDLock; } *ppsMemDesc = psMemDesc; return PVRSRV_OK; failCMDLock: OSLockDestroy(psMemDesc->sDeviceMemDesc.hLock); failDMDLock: OSLockDestroy(psMemDesc->hLock); failMDLock: OSFreeMem(psMemDesc); failAlloc: PVR_ASSERT(eError != PVRSRV_OK); return eError; }
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; }
PVRSRV_ERROR IMG_CALLCONV PVRSRVRegisterDevice(PSYS_DATA psSysData, PVRSRV_ERROR (*pfnRegisterDevice)(PVRSRV_DEVICE_NODE*), IMG_UINT32 ui32SOCInterruptBit, IMG_UINT32 *pui32DeviceIndex) { PVRSRV_ERROR eError; PVRSRV_DEVICE_NODE *psDeviceNode; if(OSAllocMem( PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), (IMG_VOID **)&psDeviceNode, IMG_NULL, "Device Node") != PVRSRV_OK) { PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to alloc memory for psDeviceNode")); return (PVRSRV_ERROR_OUT_OF_MEMORY); } OSMemSet (psDeviceNode, 0, sizeof(PVRSRV_DEVICE_NODE)); eError = pfnRegisterDevice(psDeviceNode); if (eError != PVRSRV_OK) { OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP, sizeof(PVRSRV_DEVICE_NODE), psDeviceNode, IMG_NULL); PVR_DPF((PVR_DBG_ERROR,"PVRSRVRegisterDevice : Failed to register device")); return (PVRSRV_ERROR_DEVICE_REGISTER_FAILED); } psDeviceNode->ui32RefCount = 1; psDeviceNode->psSysData = psSysData; psDeviceNode->ui32SOCInterruptBit = ui32SOCInterruptBit; AllocateDeviceID(psSysData, &psDeviceNode->sDevId.ui32DeviceIndex); List_PVRSRV_DEVICE_NODE_Insert(&psSysData->psDeviceNodeList, psDeviceNode); *pui32DeviceIndex = psDeviceNode->sDevId.ui32DeviceIndex; return PVRSRV_OK; }
/*! ****************************************************************************** @Function PVRSRVTimeTraceBufferCreate @Description Create a trace buffer. Note: We assume that this will only be called once per process. @Input ui32PID : PID of the process that is creating the buffer @Return none ******************************************************************************/ PVRSRV_ERROR PVRSRVTimeTraceBufferCreate(IMG_UINT32 ui32PID) { sTimeTraceBuffer *psBuffer; psBuffer = (sTimeTraceBuffer*) KMallocWrapper(sizeof(sTimeTraceBuffer), GFP_NOWAIT | __GFP_NOWARN); if (psBuffer == IMG_NULL) { PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferCreate: Error allocating trace buffer header")); return PVRSRV_ERROR_OUT_OF_MEMORY; } OSMemSet(psBuffer, 0, sizeof(sTimeTraceBuffer)); psBuffer->pui8Data = (IMG_UINT8*) KMallocWrapper(TIME_TRACE_BUFFER_SIZE, GFP_NOWAIT | __GFP_NOWARN); if (psBuffer->pui8Data == IMG_NULL) { OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(sTimeTraceBuffer), psBuffer, NULL); PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferCreate: Error allocating trace buffer data")); return PVRSRV_ERROR_OUT_OF_MEMORY; } OSMemSet(psBuffer->pui8Data, 0, TIME_TRACE_BUFFER_SIZE); if (!HASH_Insert_NoWait(g_psBufferTable, (IMG_UINTPTR_T) ui32PID, (IMG_UINTPTR_T) psBuffer)) { OSFreeMem(PVRSRV_PAGEABLE_SELECT, TIME_TRACE_BUFFER_SIZE, psBuffer->pui8Data, NULL); OSFreeMem(PVRSRV_PAGEABLE_SELECT, sizeof(sTimeTraceBuffer), psBuffer, NULL); PVR_DPF((PVR_DBG_ERROR, "PVRSRVTimeTraceBufferCreate: Error adding trace buffer to hash table")); return PVRSRV_ERROR_OUT_OF_MEMORY; } return PVRSRV_OK; }
IMG_VOID PDumpDeInit(IMG_VOID) { IMG_UINT32 i; DBGKM_CONNECT_NOTIFIER sConnectNotifier; for(i=0; i < PDUMP_NUM_STREAMS; i++) { gpfnDbgDrv->pfnDestroyStream(gsDBGPdumpState.psStream[i]); } if(gsDBGPdumpState.pszFile) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0); gsDBGPdumpState.pszFile = IMG_NULL; } if(gsDBGPdumpState.pszScript) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0); gsDBGPdumpState.pszScript = IMG_NULL; } if(gsDBGPdumpState.pszMsg) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0); gsDBGPdumpState.pszMsg = IMG_NULL; } /* * Remove the connection notify callback */ sConnectNotifier.pfnConnectNotifier = 0; gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier); gpfnDbgDrv = IMG_NULL; }
static enum PVRSRV_ERROR UnmapDeviceMemoryCallBack(void *pvParam, u32 ui32Param) { enum PVRSRV_ERROR eError; struct RESMAN_MAP_DEVICE_MEM_DATA *psMapData = pvParam; int page_count; PVR_UNREFERENCED_PARAMETER(ui32Param); page_count = get_page_count((u32)psMapData->psMemInfo->pvLinAddrKM, psMapData->psMemInfo->ui32AllocSize); if (psMapData->psMemInfo->sMemBlk.psIntSysPAddr) OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, page_count * sizeof(struct IMG_SYS_PHYADDR), psMapData->psMemInfo->sMemBlk.psIntSysPAddr, NULL); eError = FreeDeviceMem(psMapData->psMemInfo); if (eError != PVRSRV_OK) { PVR_DPF(PVR_DBG_ERROR, "UnmapDeviceMemoryCallBack: " "Failed to free DST meminfo"); return eError; } psMapData->psSrcMemInfo->ui32RefCount--; PVR_ASSERT(psMapData->psSrcMemInfo->ui32RefCount != (u32) (-1)); /* * Don't free the source MemInfo as we didn't allocate it * and it's not our job as the process the allocated * should also free it when it's finished */ OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(struct RESMAN_MAP_DEVICE_MEM_DATA), psMapData, NULL); return eError; }
static IMG_VOID freeWrapped(PVRSRV_KERNEL_MEM_INFO *psMemInfo) { IMG_HANDLE hOSWrapMem = psMemInfo->sMemBlk.hOSWrapMem; if(psMemInfo->sMemBlk.psIntSysPAddr) { OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(IMG_SYS_PHYADDR), psMemInfo->sMemBlk.psIntSysPAddr, IMG_NULL); psMemInfo->sMemBlk.psIntSysPAddr = IMG_NULL; } if(hOSWrapMem) { OSReleasePhysPageAddr(hOSWrapMem); } }