| /*************************************************************************/ /*! |
| @File |
| @Title Device Memory Management |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @Description Server-side component of the Device Memory Management. |
| @License Dual MIT/GPLv2 |
| |
| The contents of this file are subject to the MIT license as set out below. |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| Alternatively, the contents of this file may be used under the terms of |
| the GNU General Public License Version 2 ("GPL") in which case the provisions |
| of GPL are applicable instead of those above. |
| |
| If you wish to allow use of your version of this file only under the terms of |
| GPL, and not to allow others to use your version of this file under the terms |
| of the MIT license, indicate your decision by deleting the provisions above |
| and replace them with the notice and other provisions required by GPL as set |
| out in the file called "GPL-COPYING" included in this distribution. If you do |
| not delete the provisions above, a recipient may use your version of this file |
| under the terms of either the MIT license or GPL. |
| |
| This License is also included in this distribution in the file called |
| "MIT-COPYING". |
| |
| EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS |
| PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING |
| BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
| PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR |
| COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ /**************************************************************************/ |
| /* our exported API */ |
| #include "devicemem_server.h" |
| #include "devicemem_utils.h" |
| #include "devicemem.h" |
| |
| #include "device.h" /* For device node */ |
| #include "img_types.h" |
| #include "pvr_debug.h" |
| #include "pvrsrv_error.h" |
| |
| #include "mmu_common.h" |
| #include "pdump_km.h" |
| #include "pmr.h" |
| #include "physmem.h" |
| |
| #include "allocmem.h" |
| #include "osfunc.h" |
| #include "lock.h" |
| |
| #include "rgx_bvnc_defs_km.h" |
| |
| #if defined(SUPPORT_BUFFER_SYNC) |
| #include <linux/sched.h> |
| #include "pvr_buffer_sync.h" |
| #endif |
| |
| struct _DEVMEMINT_CTX_ |
| { |
| PVRSRV_DEVICE_NODE *psDevNode; |
| |
| /* MMU common code needs to have a context. There's a one-to-one |
| correspondence between device memory context and MMU context, |
| but we have the abstraction here so that we don't need to care |
| what the MMU does with its context, and the MMU code need not |
| know about us at all. */ |
| MMU_CONTEXT *psMMUContext; |
| |
| ATOMIC_T hRefCount; |
| |
| /* This handle is for devices that require notification when a new |
| memory context is created and they need to store private data that |
| is associated with the context. */ |
| IMG_HANDLE hPrivData; |
| |
| /* The following tracks UM applications that need to be notified of a |
| * page fault */ |
| DLLIST_NODE sProcessNotifyListHead; |
| /* The following is a node for the list of registered devmem contexts */ |
| DLLIST_NODE sPageFaultNotifyListElem; |
| }; |
| |
| struct _DEVMEMINT_CTX_EXPORT_ |
| { |
| DEVMEMINT_CTX *psDevmemCtx; |
| PMR *psPMR; |
| ATOMIC_T hRefCount; |
| DLLIST_NODE sNode; |
| }; |
| |
| struct _DEVMEMINT_HEAP_ |
| { |
| struct _DEVMEMINT_CTX_ *psDevmemCtx; |
| IMG_UINT32 uiLog2PageSize; |
| ATOMIC_T hRefCount; |
| }; |
| |
| struct _DEVMEMINT_RESERVATION_ |
| { |
| struct _DEVMEMINT_HEAP_ *psDevmemHeap; |
| IMG_DEV_VIRTADDR sBase; |
| IMG_DEVMEM_SIZE_T uiLength; |
| }; |
| |
| struct _DEVMEMINT_MAPPING_ |
| { |
| struct _DEVMEMINT_RESERVATION_ *psReservation; |
| PMR *psPMR; |
| IMG_UINT32 uiNumPages; |
| }; |
| |
| struct _DEVMEMINT_PF_NOTIFY_ |
| { |
| IMG_UINT32 ui32PID; |
| DLLIST_NODE sProcessNotifyListElem; |
| }; |
| |
| /*************************************************************************/ /*! |
| @Function _DevmemIntCtxAcquire |
| @Description Acquire a reference to the provided device memory context. |
| @Return None |
| */ /**************************************************************************/ |
| static INLINE void _DevmemIntCtxAcquire(DEVMEMINT_CTX *psDevmemCtx) |
| { |
| OSAtomicIncrement(&psDevmemCtx->hRefCount); |
| } |
| |
| /*************************************************************************/ /*! |
| @Function _DevmemIntCtxRelease |
| @Description Release the reference to the provided device memory context. |
| If this is the last reference which was taken then the |
| memory context will be freed. |
| @Return None |
| */ /**************************************************************************/ |
| static INLINE void _DevmemIntCtxRelease(DEVMEMINT_CTX *psDevmemCtx) |
| { |
| if (OSAtomicDecrement(&psDevmemCtx->hRefCount) == 0) |
| { |
| /* The last reference has gone, destroy the context */ |
| PVRSRV_DEVICE_NODE *psDevNode = psDevmemCtx->psDevNode; |
| DLLIST_NODE *psNode, *psNodeNext; |
| |
| /* If there are any PIDs registered for page fault notification. |
| * Loop through the registered PIDs and free each one */ |
| dllist_foreach_node(&(psDevmemCtx->sProcessNotifyListHead), psNode, psNodeNext) |
| { |
| DEVMEMINT_PF_NOTIFY *psNotifyNode = |
| IMG_CONTAINER_OF(psNode, DEVMEMINT_PF_NOTIFY, sProcessNotifyListElem); |
| dllist_remove_node(psNode); |
| OSFreeMem(psNotifyNode); |
| } |
| |
| /* If this context is in the list registered for a debugger, remove |
| * from that list */ |
| if (dllist_node_is_in_list(&psDevmemCtx->sPageFaultNotifyListElem)) |
| { |
| dllist_remove_node(&psDevmemCtx->sPageFaultNotifyListElem); |
| } |
| |
| if (psDevNode->pfnUnregisterMemoryContext) |
| { |
| psDevNode->pfnUnregisterMemoryContext(psDevmemCtx->hPrivData); |
| } |
| MMU_ContextDestroy(psDevmemCtx->psMMUContext); |
| |
| PVR_DPF((PVR_DBG_MESSAGE, "%s: Freed memory context %p", __FUNCTION__, psDevmemCtx)); |
| OSFreeMem(psDevmemCtx); |
| } |
| } |
| |
| /*************************************************************************/ /*! |
| @Function _DevmemIntHeapAcquire |
| @Description Acquire a reference to the provided device memory heap. |
| @Return None |
| */ /**************************************************************************/ |
| static INLINE void _DevmemIntHeapAcquire(DEVMEMINT_HEAP *psDevmemHeap) |
| { |
| OSAtomicIncrement(&psDevmemHeap->hRefCount); |
| } |
| |
| /*************************************************************************/ /*! |
| @Function _DevmemIntHeapRelease |
| @Description Release the reference to the provided device memory heap. |
| If this is the last reference which was taken then the |
| memory context will be freed. |
| @Return None |
| */ /**************************************************************************/ |
| static INLINE void _DevmemIntHeapRelease(DEVMEMINT_HEAP *psDevmemHeap) |
| { |
| OSAtomicDecrement(&psDevmemHeap->hRefCount); |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntUnpin(PMR *psPMR) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| /* Unpin */ |
| eError = PMRUnpinPMR(psPMR, IMG_FALSE); |
| |
| return eError; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntUnpinInvalidate(DEVMEMINT_MAPPING *psDevmemMapping, PMR *psPMR) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| eError = PMRUnpinPMR(psPMR, IMG_TRUE); |
| if (eError != PVRSRV_OK) |
| { |
| goto e_exit; |
| } |
| |
| /* Invalidate mapping */ |
| eError = MMU_ChangeValidity(psDevmemMapping->psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| psDevmemMapping->psReservation->sBase, |
| psDevmemMapping->uiNumPages, |
| psDevmemMapping->psReservation->psDevmemHeap->uiLog2PageSize, |
| IMG_FALSE, /* !< Choose to invalidate PT entries */ |
| psPMR); |
| |
| e_exit: |
| return eError; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntPin(PMR *psPMR) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| |
| /* Start the pinning */ |
| eError = PMRPinPMR(psPMR); |
| |
| return eError; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntPinValidate(DEVMEMINT_MAPPING *psDevmemMapping, PMR *psPMR) |
| { |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| PVRSRV_ERROR eErrorMMU = PVRSRV_OK; |
| IMG_UINT32 uiLog2PageSize = psDevmemMapping->psReservation->psDevmemHeap->uiLog2PageSize; |
| |
| /* Start the pinning */ |
| eError = PMRPinPMR(psPMR); |
| |
| if (eError == PVRSRV_OK) |
| { |
| /* Make mapping valid again */ |
| eErrorMMU = MMU_ChangeValidity(psDevmemMapping->psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| psDevmemMapping->psReservation->sBase, |
| psDevmemMapping->uiNumPages, |
| uiLog2PageSize, |
| IMG_TRUE, /* !< Choose to make PT entries valid again */ |
| psPMR); |
| } |
| else if (eError == PVRSRV_ERROR_PMR_NEW_MEMORY) |
| { |
| /* If we lost the physical baking we have to map it again because |
| * the old physical addresses are not valid anymore. */ |
| IMG_UINT32 uiFlags; |
| uiFlags = PMR_Flags(psPMR); |
| |
| eErrorMMU = MMU_MapPages(psDevmemMapping->psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiFlags, |
| psDevmemMapping->psReservation->sBase, |
| psPMR, |
| 0, |
| psDevmemMapping->uiNumPages, |
| NULL, |
| uiLog2PageSize); |
| } |
| |
| /* Just overwrite eError if the mappings failed. |
| * PMR_NEW_MEMORY has to be propagated to the user. */ |
| if (eErrorMMU != PVRSRV_OK) |
| { |
| eError = eErrorMMU; |
| } |
| |
| return eError; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemServerGetImportHandle |
| @Description For given exportable memory descriptor returns PMR handle. |
| @Return Memory is exportable - Success |
| PVRSRV_ERROR failure code |
| */ /**************************************************************************/ |
| PVRSRV_ERROR |
| DevmemServerGetImportHandle(DEVMEM_MEMDESC *psMemDesc, |
| IMG_HANDLE *phImport) |
| { |
| PVRSRV_ERROR eError; |
| |
| if ((psMemDesc->psImport->uiProperties & DEVMEM_PROPERTIES_EXPORTABLE) == 0) |
| { |
| eError = PVRSRV_ERROR_DEVICEMEM_CANT_EXPORT_SUBALLOCATION; |
| goto e0; |
| } |
| |
| *phImport = psMemDesc->psImport->hPMR; |
| return PVRSRV_OK; |
| |
| e0: |
| return eError; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemServerGetHeapHandle |
| @Description For given reservation returns the Heap handle. |
| @Return PVRSRV_ERROR failure code |
| */ /**************************************************************************/ |
| PVRSRV_ERROR |
| DevmemServerGetHeapHandle(DEVMEMINT_RESERVATION *psReservation, |
| IMG_HANDLE *phHeap) |
| { |
| *phHeap = psReservation->psDevmemHeap; |
| return PVRSRV_OK; |
| } |
| |
| |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntCtxCreate |
| @Description Creates and initialises a device memory context. |
| @Return valid Device Memory context handle - Success |
| PVRSRV_ERROR failure code |
| */ /**************************************************************************/ |
| PVRSRV_ERROR |
| DevmemIntCtxCreate(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_BOOL bKernelMemoryCtx, |
| DEVMEMINT_CTX **ppsDevmemCtxPtr, |
| IMG_HANDLE *hPrivData, |
| IMG_UINT32 *pui32CPUCacheLineSize |
| ) |
| { |
| PVRSRV_ERROR eError; |
| DEVMEMINT_CTX *psDevmemCtx; |
| IMG_HANDLE hPrivDataInt = NULL; |
| MMU_DEVICEATTRIBS *psMMUDevAttrs; |
| |
| if((psDeviceNode->pfnCheckDeviceFeature) && \ |
| psDeviceNode->pfnCheckDeviceFeature(psDeviceNode, RGX_FEATURE_MIPS_BIT_MASK)) |
| { |
| psMMUDevAttrs = bKernelMemoryCtx ? psDeviceNode->psFirmwareMMUDevAttrs: |
| psDeviceNode->psMMUDevAttrs; |
| }else |
| { |
| psMMUDevAttrs = psDeviceNode->psMMUDevAttrs; |
| PVR_UNREFERENCED_PARAMETER(bKernelMemoryCtx); |
| } |
| |
| |
| PVR_DPF((PVR_DBG_MESSAGE, "%s", __FUNCTION__)); |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| |
| /* allocate a Devmem context */ |
| psDevmemCtx = OSAllocMem(sizeof *psDevmemCtx); |
| if (psDevmemCtx == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| PVR_DPF ((PVR_DBG_ERROR, "%s: Alloc failed", __FUNCTION__)); |
| goto fail_alloc; |
| } |
| |
| OSAtomicWrite(&psDevmemCtx->hRefCount, 1); |
| psDevmemCtx->psDevNode = psDeviceNode; |
| |
| /* Call down to MMU context creation */ |
| |
| eError = MMU_ContextCreate(psDeviceNode, |
| &psDevmemCtx->psMMUContext, |
| psMMUDevAttrs); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "%s: MMU_ContextCreate failed", __FUNCTION__)); |
| goto fail_mmucontext; |
| } |
| |
| |
| if (psDeviceNode->pfnRegisterMemoryContext) |
| { |
| eError = psDeviceNode->pfnRegisterMemoryContext(psDeviceNode, psDevmemCtx->psMMUContext, &hPrivDataInt); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "%s: Failed to register MMU context", __FUNCTION__)); |
| goto fail_register; |
| } |
| } |
| |
| /* Store the private data as it is required to unregister the memory context */ |
| psDevmemCtx->hPrivData = hPrivDataInt; |
| *hPrivData = hPrivDataInt; |
| *ppsDevmemCtxPtr = psDevmemCtx; |
| |
| /* Pass the CPU cache line size through the bridge to the user mode as it can't be queried in user mode.*/ |
| *pui32CPUCacheLineSize = OSCPUCacheAttributeSize(PVR_DCACHE_LINE_SIZE); |
| |
| /* Initialise the PID notify list */ |
| dllist_init(&(psDevmemCtx->sProcessNotifyListHead)); |
| psDevmemCtx->sPageFaultNotifyListElem.psNextNode = NULL; |
| psDevmemCtx->sPageFaultNotifyListElem.psPrevNode = NULL; |
| |
| return PVRSRV_OK; |
| |
| fail_register: |
| MMU_ContextDestroy(psDevmemCtx->psMMUContext); |
| fail_mmucontext: |
| OSFreeMem(psDevmemCtx); |
| fail_alloc: |
| PVR_ASSERT(eError != PVRSRV_OK); |
| return eError; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntHeapCreate |
| @Description Creates and initialises a device memory heap. |
| @Return valid Device Memory heap handle - Success |
| PVRSRV_ERROR failure code |
| */ /**************************************************************************/ |
| PVRSRV_ERROR |
| DevmemIntHeapCreate( |
| DEVMEMINT_CTX *psDevmemCtx, |
| IMG_DEV_VIRTADDR sHeapBaseAddr, |
| IMG_DEVMEM_SIZE_T uiHeapLength, |
| IMG_UINT32 uiLog2DataPageSize, |
| DEVMEMINT_HEAP **ppsDevmemHeapPtr |
| ) |
| { |
| PVRSRV_ERROR eError; |
| DEVMEMINT_HEAP *psDevmemHeap; |
| |
| PVR_DPF((PVR_DBG_MESSAGE, "%s: DevmemIntHeap_Create", __FUNCTION__)); |
| |
| /* allocate a Devmem context */ |
| psDevmemHeap = OSAllocMem(sizeof *psDevmemHeap); |
| if (psDevmemHeap == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| PVR_DPF ((PVR_DBG_ERROR, "%s: Alloc failed", __FUNCTION__)); |
| goto fail_alloc; |
| } |
| |
| psDevmemHeap->psDevmemCtx = psDevmemCtx; |
| |
| _DevmemIntCtxAcquire(psDevmemHeap->psDevmemCtx); |
| |
| OSAtomicWrite(&psDevmemHeap->hRefCount, 1); |
| |
| psDevmemHeap->uiLog2PageSize = uiLog2DataPageSize; |
| |
| *ppsDevmemHeapPtr = psDevmemHeap; |
| |
| return PVRSRV_OK; |
| |
| fail_alloc: |
| return eError; |
| } |
| |
| static PVRSRV_ERROR DevmemIntAllocDummyPage(DEVMEMINT_HEAP *psDevmemHeap) |
| { |
| |
| IMG_UINT32 ui32Dummyref = 0; |
| PVRSRV_ERROR eError = PVRSRV_OK; |
| PVRSRV_DEVICE_NODE *psDevNode; |
| |
| psDevNode = psDevmemHeap->psDevmemCtx->psDevNode; |
| |
| /* We know there will not be 4G number of sparse PMR's */ |
| /* Also this function depends on the fact that its called under the global lock & |
| * pmr lock and thus is safe from being re-entrant */ |
| ui32Dummyref = OSAtomicIncrement(&psDevNode->sDummyPage.atRefCounter); |
| if(1 == ui32Dummyref) |
| { |
| IMG_UINT8 u8Value = 0; |
| IMG_BOOL bInitPage = IMG_FALSE; |
| IMG_DEV_PHYADDR sDevPhysAddr={0}; |
| |
| /*Acquire the lock */ |
| OSLockAcquire(psDevNode->sDummyPage.psDummyPgLock); |
| |
| #if defined(PVR_DUMMY_PAGE_INIT_VALUE) |
| u8Value = PVR_DUMMY_PAGE_INIT_VALUE; |
| bInitPage = IMG_TRUE; |
| #else |
| bInitPage = IMG_FALSE; |
| #endif |
| |
| #if defined(PDUMP) |
| PDUMPCOMMENT("Alloc Dummy page object"); |
| #endif |
| /*Allocate the dummy page required for sparse backing */ |
| eError = DevPhysMemAlloc(psDevNode, |
| (1 << psDevNode->sDummyPage.ui32Log2DummyPgSize), |
| u8Value, |
| bInitPage, |
| #if defined(PDUMP) |
| psDevNode->psMMUDevAttrs->pszMMUPxPDumpMemSpaceName, |
| DUMMY_PAGE, |
| &psDevNode->sDummyPage.hPdumpDummyPg, |
| #endif |
| &psDevNode->sDummyPage.sDummyPageHandle, |
| &sDevPhysAddr); |
| if(PVRSRV_OK != eError) |
| { |
| OSAtomicDecrement(&psDevNode->sDummyPage.atRefCounter); |
| } |
| else |
| { |
| psDevNode->sDummyPage.ui64DummyPgPhysAddr = sDevPhysAddr.uiAddr; |
| } |
| |
| /*Release the lock */ |
| OSLockRelease(psDevNode->sDummyPage.psDummyPgLock); |
| } |
| return eError; |
| } |
| |
| static void DevmemIntFreeDummyPage(DEVMEMINT_HEAP *psDevmemHeap) |
| { |
| PVRSRV_DEVICE_NODE *psDevNode; |
| IMG_UINT32 ui32Dummyref = 0; |
| |
| psDevNode = psDevmemHeap->psDevmemCtx->psDevNode; |
| ui32Dummyref = OSAtomicRead(&psDevNode->sDummyPage.atRefCounter); |
| |
| /* For the cases where the dummy page allocation fails due to lack of memory |
| * The refcount can still be 0 even for a sparse allocation */ |
| if(0 != ui32Dummyref) |
| { |
| OSLockAcquire(psDevNode->sDummyPage.psDummyPgLock); |
| |
| /* We know there will not be 4G number of sparse PMR's */ |
| ui32Dummyref = OSAtomicDecrement(&psDevNode->sDummyPage.atRefCounter); |
| |
| if(0 == ui32Dummyref) |
| { |
| PDUMPCOMMENT("Free Dummy page object"); |
| |
| /* Free the dummy page when refcount reaches zero */ |
| DevPhysMemFree(psDevNode, |
| #if defined(PDUMP) |
| psDevNode->sDummyPage.hPdumpDummyPg, |
| #endif |
| &psDevNode->sDummyPage.sDummyPageHandle); |
| |
| #if defined(PDUMP) |
| psDevNode->sDummyPage.hPdumpDummyPg = NULL; |
| #endif |
| psDevNode->sDummyPage.ui64DummyPgPhysAddr = MMU_BAD_PHYS_ADDR; |
| } |
| |
| OSLockRelease(psDevNode->sDummyPage.psDummyPgLock); |
| } |
| |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntMapPages(DEVMEMINT_RESERVATION *psReservation, |
| PMR *psPMR, |
| IMG_UINT32 ui32PageCount, |
| IMG_UINT32 ui32PhysicalPgOffset, |
| PVRSRV_MEMALLOCFLAGS_T uiFlags, |
| IMG_DEV_VIRTADDR sDevVAddrBase) |
| { |
| PVRSRV_ERROR eError; |
| |
| if (psReservation->psDevmemHeap->uiLog2PageSize > PMR_GetLog2Contiguity(psPMR)) |
| { |
| PVR_DPF ((PVR_DBG_ERROR, |
| "%s: Device heap and PMR have incompatible Log2Contiguity (%u - %u). " |
| "PMR contiguity must be a multiple of the heap contiguity!", |
| __func__, |
| psReservation->psDevmemHeap->uiLog2PageSize, |
| PMR_GetLog2Contiguity(psPMR) )); |
| eError = PVRSRV_ERROR_INVALID_PARAMS; |
| goto e0; |
| } |
| |
| eError = MMU_MapPages(psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiFlags, |
| sDevVAddrBase, |
| psPMR, |
| ui32PhysicalPgOffset, |
| ui32PageCount, |
| NULL, |
| psReservation->psDevmemHeap->uiLog2PageSize); |
| |
| e0: |
| return eError; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntUnmapPages(DEVMEMINT_RESERVATION *psReservation, |
| IMG_DEV_VIRTADDR sDevVAddrBase, |
| IMG_UINT32 ui32PageCount) |
| { |
| /*Unmap the pages and mark them invalid in the MMU PTE */ |
| MMU_UnmapPages (psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| 0, |
| sDevVAddrBase, |
| ui32PageCount, |
| NULL, |
| psReservation->psDevmemHeap->uiLog2PageSize, |
| IMG_FALSE); |
| |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntMapPMR(DEVMEMINT_HEAP *psDevmemHeap, |
| DEVMEMINT_RESERVATION *psReservation, |
| PMR *psPMR, |
| PVRSRV_MEMALLOCFLAGS_T uiMapFlags, |
| DEVMEMINT_MAPPING **ppsMappingPtr) |
| { |
| PVRSRV_ERROR eError; |
| DEVMEMINT_MAPPING *psMapping; |
| /* number of pages (device pages) that allocation spans */ |
| IMG_UINT32 ui32NumDevPages; |
| /* device virtual address of start of allocation */ |
| IMG_DEV_VIRTADDR sAllocationDevVAddr; |
| /* and its length */ |
| IMG_DEVMEM_SIZE_T uiAllocationSize; |
| IMG_UINT32 uiLog2Contiguity = psDevmemHeap->uiLog2PageSize; |
| IMG_BOOL bIsSparse = IMG_FALSE, bNeedBacking = IMG_FALSE; |
| PVRSRV_DEVICE_NODE *psDevNode; |
| PMR_FLAGS_T uiPMRFlags; |
| |
| if (uiLog2Contiguity > PMR_GetLog2Contiguity(psPMR)) |
| { |
| PVR_DPF ((PVR_DBG_ERROR, |
| "%s: Device heap and PMR have incompatible contiguity (%u - %u). " |
| "Heap contiguity must be a multiple of the heap contiguity!", |
| __func__, |
| uiLog2Contiguity, |
| PMR_GetLog2Contiguity(psPMR) )); |
| eError = PVRSRV_ERROR_INVALID_PARAMS; |
| goto e0; |
| } |
| psDevNode = psDevmemHeap->psDevmemCtx->psDevNode; |
| |
| /* allocate memory to record the mapping info */ |
| psMapping = OSAllocMem(sizeof *psMapping); |
| if (psMapping == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| PVR_DPF ((PVR_DBG_ERROR, "DevmemIntMapPMR: Alloc failed")); |
| goto e0; |
| } |
| |
| uiAllocationSize = psReservation->uiLength; |
| |
| |
| ui32NumDevPages = 0xffffffffU & ( ( (uiAllocationSize - 1) >> uiLog2Contiguity) + 1); |
| PVR_ASSERT(ui32NumDevPages << uiLog2Contiguity == uiAllocationSize); |
| |
| eError = PMRLockSysPhysAddresses(psPMR); |
| if (eError != PVRSRV_OK) |
| { |
| goto e2; |
| } |
| |
| sAllocationDevVAddr = psReservation->sBase; |
| |
| /*Check if the PMR that need to be mapped is sparse */ |
| bIsSparse = PMR_IsSparse(psPMR); |
| if(bIsSparse) |
| { |
| /*Get the flags*/ |
| uiPMRFlags = PMR_Flags(psPMR); |
| bNeedBacking = PVRSRV_IS_SPARSE_DUMMY_BACKING_REQUIRED(uiPMRFlags); |
| |
| if(bNeedBacking) |
| { |
| /*Error is logged with in the function if any failures. |
| * As the allocation fails we need to fail the map request and |
| * return appropriate error |
| * |
| * Allocation of dummy page is done after locking the pages for PMR physically |
| * By implementing this way, the best case path of dummy page being most likely to be |
| * allocated after physically locking down pages, is considered. |
| * If the dummy page allocation fails, we do unlock the physical address and the impact |
| * is a bit more in on demand mode of operation */ |
| eError = DevmemIntAllocDummyPage(psDevmemHeap); |
| if(PVRSRV_OK != eError) |
| { |
| goto e3; |
| } |
| } |
| |
| /* N.B. We pass mapping permission flags to MMU_MapPages and let |
| it reject the mapping if the permissions on the PMR are not compatible. */ |
| eError = MMU_MapPages(psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiMapFlags, |
| sAllocationDevVAddr, |
| psPMR, |
| 0, |
| ui32NumDevPages, |
| NULL, |
| uiLog2Contiguity); |
| if(PVRSRV_OK != eError) |
| { |
| goto e4; |
| } |
| } |
| else |
| { |
| eError = MMU_MapPMRFast(psDevmemHeap->psDevmemCtx->psMMUContext, |
| sAllocationDevVAddr, |
| psPMR, |
| ui32NumDevPages << uiLog2Contiguity, |
| uiMapFlags, |
| uiLog2Contiguity); |
| if(PVRSRV_OK != eError) |
| { |
| goto e3; |
| } |
| } |
| |
| psMapping->psReservation = psReservation; |
| psMapping->uiNumPages = ui32NumDevPages; |
| psMapping->psPMR = psPMR; |
| /* Don't bother with refcount on reservation, as a reservation |
| only ever holds one mapping, so we directly increment the |
| refcount on the heap instead */ |
| _DevmemIntHeapAcquire(psMapping->psReservation->psDevmemHeap); |
| |
| *ppsMappingPtr = psMapping; |
| |
| return PVRSRV_OK; |
| e4: |
| if(bNeedBacking) |
| { |
| /*if the mapping failed, the allocated dummy ref count need |
| * to be handled accordingly */ |
| DevmemIntFreeDummyPage(psDevmemHeap); |
| } |
| e3: |
| { |
| PVRSRV_ERROR eError1=PVRSRV_OK; |
| eError1 = PMRUnlockSysPhysAddresses(psPMR); |
| if(PVRSRV_OK != eError1) |
| { |
| PVR_DPF ((PVR_DBG_ERROR, "%s: Failed to unlock the physical addresses",__func__)); |
| } |
| *ppsMappingPtr = NULL; |
| } |
| e2: |
| OSFreeMem(psMapping); |
| |
| e0: |
| PVR_ASSERT (eError != PVRSRV_OK); |
| return eError; |
| } |
| |
| |
| PVRSRV_ERROR |
| DevmemIntUnmapPMR(DEVMEMINT_MAPPING *psMapping) |
| { |
| PVRSRV_ERROR eError; |
| DEVMEMINT_HEAP *psDevmemHeap = psMapping->psReservation->psDevmemHeap; |
| /* device virtual address of start of allocation */ |
| IMG_DEV_VIRTADDR sAllocationDevVAddr; |
| /* number of pages (device pages) that allocation spans */ |
| IMG_UINT32 ui32NumDevPages; |
| IMG_BOOL bIsSparse = IMG_FALSE, bNeedBacking = IMG_FALSE; |
| PMR_FLAGS_T uiPMRFlags; |
| #if defined(SUPPORT_BUFFER_SYNC) |
| PVRSRV_DEVICE_NODE *psDevNode = psDevmemHeap->psDevmemCtx->psDevNode; |
| bool bInterruptible = true; |
| unsigned long ulTimeout = MAX_SCHEDULE_TIMEOUT; |
| IMG_INT iErr; |
| |
| retry: |
| iErr = pvr_buffer_sync_wait(psDevNode->psBufferSyncContext, |
| psMapping->psPMR, bInterruptible, ulTimeout); |
| if (iErr) |
| { |
| if (iErr == -ERESTARTSYS) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, "%s: Buffer sync wait interrupted (retrying)", |
| __FUNCTION__)); |
| bInterruptible = false; |
| ulTimeout = 30 * HZ; |
| goto retry; |
| } |
| |
| PVR_DPF((PVR_DBG_ERROR, "%s: Failed to unmap PMR from device (errno=%d)", |
| __FUNCTION__, iErr)); |
| return PVRSRV_ERROR_STILL_MAPPED; |
| } |
| #endif |
| |
| ui32NumDevPages = psMapping->uiNumPages; |
| sAllocationDevVAddr = psMapping->psReservation->sBase; |
| |
| /*Check if the PMR that need to be mapped is sparse */ |
| bIsSparse = PMR_IsSparse(psMapping->psPMR); |
| |
| if(bIsSparse) |
| { |
| /*Get the flags*/ |
| uiPMRFlags = PMR_Flags(psMapping->psPMR); |
| bNeedBacking = PVRSRV_IS_SPARSE_DUMMY_BACKING_REQUIRED(uiPMRFlags); |
| |
| if(bNeedBacking) |
| { |
| DevmemIntFreeDummyPage(psDevmemHeap); |
| } |
| |
| MMU_UnmapPages (psDevmemHeap->psDevmemCtx->psMMUContext, |
| 0, |
| sAllocationDevVAddr, |
| ui32NumDevPages, |
| NULL, |
| psMapping->psReservation->psDevmemHeap->uiLog2PageSize, |
| IMG_FALSE); |
| } |
| else |
| { |
| MMU_UnmapPMRFast(psDevmemHeap->psDevmemCtx->psMMUContext, |
| sAllocationDevVAddr, |
| ui32NumDevPages, |
| psMapping->psReservation->psDevmemHeap->uiLog2PageSize); |
| } |
| |
| |
| |
| eError = PMRUnlockSysPhysAddresses(psMapping->psPMR); |
| PVR_ASSERT(eError == PVRSRV_OK); |
| |
| /* Don't bother with refcount on reservation, as a reservation |
| only ever holds one mapping, so we directly decrement the |
| refcount on the heap instead */ |
| _DevmemIntHeapRelease(psDevmemHeap); |
| |
| OSFreeMem(psMapping); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| PVRSRV_ERROR |
| DevmemIntReserveRange(DEVMEMINT_HEAP *psDevmemHeap, |
| IMG_DEV_VIRTADDR sAllocationDevVAddr, |
| IMG_DEVMEM_SIZE_T uiAllocationSize, |
| DEVMEMINT_RESERVATION **ppsReservationPtr) |
| { |
| PVRSRV_ERROR eError; |
| DEVMEMINT_RESERVATION *psReservation; |
| |
| /* allocate memory to record the reservation info */ |
| psReservation = OSAllocMem(sizeof *psReservation); |
| if (psReservation == NULL) |
| { |
| eError = PVRSRV_ERROR_OUT_OF_MEMORY; |
| PVR_DPF ((PVR_DBG_ERROR, "DevmemIntReserveRange: Alloc failed")); |
| goto e0; |
| } |
| |
| psReservation->sBase = sAllocationDevVAddr; |
| psReservation->uiLength = uiAllocationSize; |
| |
| eError = MMU_Alloc (psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiAllocationSize, |
| &uiAllocationSize, |
| 0, /* IMG_UINT32 uiProtFlags */ |
| 0, /* alignment is n/a since we supply devvaddr */ |
| &sAllocationDevVAddr, |
| psDevmemHeap->uiLog2PageSize); |
| if (eError != PVRSRV_OK) |
| { |
| goto e1; |
| } |
| |
| /* since we supplied the virt addr, MMU_Alloc shouldn't have |
| chosen a new one for us */ |
| PVR_ASSERT(sAllocationDevVAddr.uiAddr == psReservation->sBase.uiAddr); |
| |
| _DevmemIntHeapAcquire(psDevmemHeap); |
| |
| psReservation->psDevmemHeap = psDevmemHeap; |
| *ppsReservationPtr = psReservation; |
| |
| return PVRSRV_OK; |
| |
| /* |
| error exit paths follow |
| */ |
| |
| e1: |
| OSFreeMem(psReservation); |
| |
| e0: |
| PVR_ASSERT(eError != PVRSRV_OK); |
| return eError; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntUnreserveRange(DEVMEMINT_RESERVATION *psReservation) |
| { |
| IMG_DEV_VIRTADDR sBase = psReservation->sBase; |
| IMG_UINT32 uiLength = psReservation->uiLength; |
| IMG_UINT32 uiLog2DataPageSize = psReservation->psDevmemHeap->uiLog2PageSize; |
| |
| MMU_Free (psReservation->psDevmemHeap->psDevmemCtx->psMMUContext, |
| sBase, |
| uiLength, |
| uiLog2DataPageSize); |
| |
| _DevmemIntHeapRelease(psReservation->psDevmemHeap); |
| OSFreeMem(psReservation); |
| |
| return PVRSRV_OK; |
| } |
| |
| |
| PVRSRV_ERROR |
| DevmemIntHeapDestroy( |
| DEVMEMINT_HEAP *psDevmemHeap |
| ) |
| { |
| if (OSAtomicRead(&psDevmemHeap->hRefCount) != 1) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "BUG! %s called but has too many references (%d) " |
| "which probably means allocations have been made from the heap and not freed", |
| __FUNCTION__, |
| OSAtomicRead(&psDevmemHeap->hRefCount))); |
| |
| /* |
| * Try again later when you've freed all the memory |
| * |
| * Note: |
| * We don't expect the application to retry (after all this call would |
| * succeed if the client had freed all the memory which it should have |
| * done before calling this function). However, given there should be |
| * an associated handle, when the handle base is destroyed it will free |
| * any allocations leaked by the client and then it will retry this call, |
| * which should then succeed. |
| */ |
| return PVRSRV_ERROR_RETRY; |
| } |
| |
| PVR_ASSERT(OSAtomicRead(&psDevmemHeap->hRefCount) == 1); |
| |
| _DevmemIntCtxRelease(psDevmemHeap->psDevmemCtx); |
| |
| PVR_DPF((PVR_DBG_MESSAGE, "%s: Freed heap %p", __FUNCTION__, psDevmemHeap)); |
| OSFreeMem(psDevmemHeap); |
| |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntChangeSparse(DEVMEMINT_HEAP *psDevmemHeap, |
| PMR *psPMR, |
| IMG_UINT32 ui32AllocPageCount, |
| IMG_UINT32 *pai32AllocIndices, |
| IMG_UINT32 ui32FreePageCount, |
| IMG_UINT32 *pai32FreeIndices, |
| SPARSE_MEM_RESIZE_FLAGS uiSparseFlags, |
| PVRSRV_MEMALLOCFLAGS_T uiFlags, |
| IMG_DEV_VIRTADDR sDevVAddrBase, |
| IMG_UINT64 sCpuVAddrBase) |
| { |
| PVRSRV_ERROR eError; |
| |
| IMG_UINT32 uiLog2PageSize = PMR_GetLog2Contiguity(psPMR); |
| |
| /* |
| * The order of steps in which this request is done is given below. The order of |
| * operations is very important in this case: |
| * |
| * 1. The parameters are validated in function PMR_ChangeSparseMem below. |
| * A successful response indicates all the parameters are correct. |
| * In failure case we bail out from here with out processing further. |
| * 2. On success, get the PMR specific operations done. this includes page alloc, page free |
| * and the corresponding PMR status changes. |
| * when this call fails, it is ensured that the state of the PMR before is |
| * not disturbed. If it succeeds, then we can go ahead with the subsequent steps. |
| * 3. Invalidate the GPU page table entries for the pages to be freed. |
| * 4. Write the GPU page table entries for the pages that got allocated. |
| * 5. Change the corresponding CPU space map. |
| * |
| * The above steps can be selectively controlled using flags. |
| */ |
| |
| { |
| if (uiSparseFlags & (SPARSE_REMAP_MEM | SPARSE_RESIZE_BOTH)) |
| { |
| /* Do the PMR specific changes first */ |
| eError = PMR_ChangeSparseMem(psPMR, |
| ui32AllocPageCount, |
| pai32AllocIndices, |
| ui32FreePageCount, |
| pai32FreeIndices, |
| uiSparseFlags); |
| if (PVRSRV_OK != eError) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, |
| "%s: Failed to do PMR specific changes.", |
| __func__)); |
| goto e0; |
| } |
| |
| /* Invalidate the page table entries for the free pages. |
| * Optimisation later would be not to touch the ones that gets re-mapped */ |
| if ((0 != ui32FreePageCount) && (uiSparseFlags & SPARSE_RESIZE_FREE)) |
| { |
| PMR_FLAGS_T uiPMRFlags; |
| IMG_BOOL bNeedBacking = IMG_FALSE; |
| |
| /*Get the flags*/ |
| uiPMRFlags = PMR_Flags(psPMR); |
| bNeedBacking = PVRSRV_IS_SPARSE_DUMMY_BACKING_REQUIRED(uiPMRFlags); |
| |
| if (SPARSE_REMAP_MEM != (uiSparseFlags & SPARSE_REMAP_MEM)) |
| { |
| /* Unmap the pages and mark them invalid in the MMU PTE */ |
| MMU_UnmapPages (psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiFlags, |
| sDevVAddrBase, |
| ui32FreePageCount, |
| pai32FreeIndices, |
| uiLog2PageSize, |
| bNeedBacking); |
| } |
| } |
| |
| /* Wire the pages tables that got allocated */ |
| if ((0 != ui32AllocPageCount) && (uiSparseFlags & SPARSE_RESIZE_ALLOC)) |
| { |
| /* Map the pages and mark them Valid in the MMU PTE */ |
| eError = MMU_MapPages (psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiFlags, |
| sDevVAddrBase, |
| psPMR, |
| 0, |
| ui32AllocPageCount, |
| pai32AllocIndices, |
| uiLog2PageSize); |
| |
| if (PVRSRV_OK != eError) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, |
| "%s: Failed to map alloc indices.", |
| __func__)); |
| goto e0; |
| } |
| } |
| |
| /* Currently only used for debug */ |
| if (SPARSE_REMAP_MEM == (uiSparseFlags & SPARSE_REMAP_MEM)) |
| { |
| eError = MMU_MapPages (psDevmemHeap->psDevmemCtx->psMMUContext, |
| uiFlags, |
| sDevVAddrBase, |
| psPMR, |
| 0, |
| ui32AllocPageCount, |
| pai32FreeIndices, |
| uiLog2PageSize); |
| if (PVRSRV_OK != eError) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, |
| "%s: Failed to map Free indices.", |
| __func__)); |
| goto e0; |
| } |
| } |
| } |
| |
| } |
| #ifndef PVRSRV_UNMAP_ON_SPARSE_CHANGE |
| /* Do the changes in sparse on to the CPU virtual map accordingly */ |
| if (uiSparseFlags & SPARSE_MAP_CPU_ADDR) |
| { |
| if (sCpuVAddrBase != 0) |
| { |
| eError = PMR_ChangeSparseMemCPUMap(psPMR, |
| sCpuVAddrBase, |
| ui32AllocPageCount, |
| pai32AllocIndices, |
| ui32FreePageCount, |
| pai32FreeIndices); |
| if (PVRSRV_OK != eError) |
| { |
| PVR_DPF((PVR_DBG_MESSAGE, |
| "%s: Failed to map to CPU addr space.", |
| __func__)); |
| goto e0; |
| } |
| } |
| } |
| #endif |
| |
| return PVRSRV_OK; |
| |
| e0: |
| return eError; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntCtxDestroy |
| @Description Destroy that created by DevmemIntCtxCreate |
| @Input psDevmemCtx Device Memory context |
| @Return cannot fail. |
| */ /**************************************************************************/ |
| PVRSRV_ERROR |
| DevmemIntCtxDestroy( |
| DEVMEMINT_CTX *psDevmemCtx |
| ) |
| { |
| /* |
| We can't determine if we should be freeing the context here |
| as it refcount!=1 could be due to either the fact that heap(s) |
| remain with allocations on them, or that this memory context |
| has been exported. |
| As the client couldn’t do anything useful with this information |
| anyway and the fact that the refcount will ensure we only |
| free the context when _all_ references have been released |
| don't bother checking and just return OK regardless. |
| */ |
| _DevmemIntCtxRelease(psDevmemCtx); |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR DevmemIntIsVDevAddrValid(CONNECTION_DATA * psConnection, |
| PVRSRV_DEVICE_NODE *psDevNode, |
| DEVMEMINT_CTX *psDevMemContext, |
| IMG_DEV_VIRTADDR sDevAddr) |
| { |
| IMG_UINT32 i, j, uiLog2HeapPageSize = 0; |
| DEVICE_MEMORY_INFO *psDinfo = &psDevNode->sDevMemoryInfo; |
| DEVMEM_HEAP_CONFIG *psConfig = psDinfo->psDeviceMemoryHeapConfigArray; |
| |
| IMG_BOOL bFound = IMG_FALSE; |
| |
| for (i = 0; |
| i < psDinfo->uiNumHeapConfigs && !bFound; |
| i++) |
| { |
| for (j = 0; |
| j < psConfig[i].uiNumHeaps && !bFound; |
| j++) |
| { |
| IMG_DEV_VIRTADDR uiBase = |
| psConfig[i].psHeapBlueprintArray[j].sHeapBaseAddr; |
| IMG_DEVMEM_SIZE_T uiSize = |
| psConfig[i].psHeapBlueprintArray[j].uiHeapLength; |
| |
| if ( (sDevAddr.uiAddr >= uiBase.uiAddr) && |
| (sDevAddr.uiAddr < (uiBase.uiAddr + uiSize))) |
| { |
| uiLog2HeapPageSize = |
| psConfig[i].psHeapBlueprintArray[j].uiLog2DataPageSize; |
| bFound = IMG_TRUE; |
| } |
| } |
| } |
| |
| if (uiLog2HeapPageSize == 0) |
| { |
| return PVRSRV_ERROR_INVALID_GPU_ADDR; |
| } |
| |
| return MMU_IsVDevAddrValid(psDevMemContext->psMMUContext, |
| uiLog2HeapPageSize, |
| sDevAddr) ? PVRSRV_OK : PVRSRV_ERROR_INVALID_GPU_ADDR; |
| } |
| |
| |
| static void _DevmemIntExportCtxGetList(PDLLIST_NODE *ppsListHead) |
| { |
| static DECLARE_DLLIST(sListHead); |
| |
| *ppsListHead = &sListHead; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntExportCtx(DEVMEMINT_CTX *psContext, |
| PMR *psPMR, |
| DEVMEMINT_CTX_EXPORT **ppsContextExport) |
| { |
| PDLLIST_NODE psListHead; |
| DEVMEMINT_CTX_EXPORT *psCtxExport; |
| |
| _DevmemIntCtxAcquire(psContext); |
| PMRRefPMR(psPMR); |
| |
| _DevmemIntExportCtxGetList(&psListHead); |
| |
| psCtxExport = OSAllocMem(sizeof(DEVMEMINT_CTX_EXPORT)); |
| if (psCtxExport == NULL) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Failed to export context. System currently out of memory", |
| __func__)); |
| return PVRSRV_ERROR_OUT_OF_MEMORY; |
| } |
| |
| psCtxExport->psDevmemCtx = psContext; |
| psCtxExport->psPMR = psPMR; |
| dllist_add_to_tail(psListHead, &psCtxExport->sNode); |
| |
| *ppsContextExport = psCtxExport; |
| |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntUnexportCtx(DEVMEMINT_CTX_EXPORT *psContextExport) |
| { |
| PDLLIST_NODE psListHead; |
| |
| _DevmemIntExportCtxGetList(&psListHead); |
| |
| PMRUnrefPMR(psContextExport->psPMR); |
| _DevmemIntCtxRelease(psContextExport->psDevmemCtx); |
| dllist_remove_node(&psContextExport->sNode); |
| OSFreeMem(psContextExport); |
| |
| /* Unable to find exported context, return error */ |
| return PVRSRV_OK; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntAcquireRemoteCtx(PMR *psPMR, |
| DEVMEMINT_CTX **ppsContext, |
| IMG_HANDLE *phPrivData) |
| { |
| |
| PDLLIST_NODE psListHead; |
| PDLLIST_NODE psListNode, psListNodeNext; |
| DEVMEMINT_CTX_EXPORT *psCtxExport; |
| |
| _DevmemIntExportCtxGetList(&psListHead); |
| |
| /* Find context from list using PMR as key */ |
| dllist_foreach_node(psListHead, psListNode, psListNodeNext) |
| { |
| psCtxExport = IMG_CONTAINER_OF(psListNode, DEVMEMINT_CTX_EXPORT, sNode); |
| if (psCtxExport->psPMR == psPMR) |
| { |
| _DevmemIntCtxAcquire(psCtxExport->psDevmemCtx); |
| *ppsContext = psCtxExport->psDevmemCtx; |
| *phPrivData = psCtxExport->psDevmemCtx->hPrivData; |
| return PVRSRV_OK; |
| } |
| } |
| |
| /* Unable to find exported context, return error */ |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Failed to acquire remote context. Could not retrieve context with given PMR", |
| __func__)); |
| return PVRSRV_ERROR_INVALID_PARAMS; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntRegisterPFNotify |
| @Description Registers a PID to be notified when a page fault occurs on a |
| specific device memory context. |
| @Input psDevmemCtx The context to be notified about. |
| @Input ui32PID The PID of the process that would like to be |
| notified. |
| @Input bRegister If true, register. If false, de-register. |
| @Return PVRSRV_ERROR. |
| */ /**************************************************************************/ |
| PVRSRV_ERROR DevmemIntRegisterPFNotifyKM(DEVMEMINT_CTX *psDevmemCtx, |
| IMG_INT32 ui32PID, |
| IMG_BOOL bRegister) |
| { |
| PVRSRV_DEVICE_NODE *psDevNode; |
| DLLIST_NODE *psNode, *psNodeNext; |
| DEVMEMINT_PF_NOTIFY *psNotifyNode; |
| IMG_BOOL bPresent = IMG_FALSE; |
| |
| if (psDevmemCtx == NULL) |
| { |
| PVR_ASSERT(!"Devmem Context Missing"); |
| return PVRSRV_ERROR_INVALID_PARAMS; |
| } |
| |
| psDevNode = psDevmemCtx->psDevNode; |
| |
| if (bRegister) |
| { |
| /* If this is the first PID in the list, the device memory context |
| * needs to be registered for notification */ |
| if (dllist_is_empty(&psDevmemCtx->sProcessNotifyListHead)) |
| { |
| dllist_add_to_tail(&psDevNode->sMemoryContextPageFaultNotifyListHead, |
| &psDevmemCtx->sPageFaultNotifyListElem); |
| } |
| } |
| |
| /* Loop through the registered PIDs and check whether this one is |
| * present */ |
| dllist_foreach_node(&(psDevmemCtx->sProcessNotifyListHead), psNode, psNodeNext) |
| { |
| psNotifyNode = IMG_CONTAINER_OF(psNode, DEVMEMINT_PF_NOTIFY, sProcessNotifyListElem); |
| |
| if (psNotifyNode->ui32PID == ui32PID) |
| { |
| bPresent = IMG_TRUE; |
| break; |
| } |
| } |
| |
| if (bRegister == IMG_TRUE) |
| { |
| if (bPresent) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Trying to register a PID that is already registered", |
| __func__)); |
| return PVRSRV_ERROR_PID_ALREADY_REGISTERED; |
| } |
| |
| psNotifyNode = OSAllocMem(sizeof(*psNotifyNode)); |
| if (psNotifyNode == NULL) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Unable to allocate memory for the notify list", |
| __func__)); |
| return PVRSRV_ERROR_OUT_OF_MEMORY; |
| } |
| psNotifyNode->ui32PID = ui32PID; |
| dllist_add_to_tail(&(psDevmemCtx->sProcessNotifyListHead), &(psNotifyNode->sProcessNotifyListElem)); |
| } |
| else |
| { |
| if (!bPresent) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Trying to unregister a PID that is not registered", |
| __func__)); |
| return PVRSRV_ERROR_PID_NOT_REGISTERED; |
| } |
| dllist_remove_node(psNode); |
| psNotifyNode = IMG_CONTAINER_OF(psNode, DEVMEMINT_PF_NOTIFY, sProcessNotifyListElem); |
| OSFreeMem(psNotifyNode); |
| } |
| |
| if (!bRegister) |
| { |
| /* If the last process in the list is being unregistered, then also |
| * unregister the device memory context from the notify list. */ |
| if (dllist_is_empty(&psDevmemCtx->sProcessNotifyListHead)) |
| { |
| dllist_remove_node(&psDevmemCtx->sPageFaultNotifyListElem); |
| } |
| } |
| |
| return PVRSRV_OK; |
| } |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntPFNotify |
| @Description Notifies any processes that have registered themselves to be |
| notified when a page fault happens on a specific device memory |
| context. |
| @Input *psDevNode The device node. |
| @Input ui64FaultedPCAddress The page catalogue address that faulted. |
| @Return PVRSRV_ERROR |
| */ /**************************************************************************/ |
| PVRSRV_ERROR DevmemIntPFNotify(PVRSRV_DEVICE_NODE *psDevNode, |
| IMG_UINT64 ui64FaultedPCAddress) |
| { |
| DLLIST_NODE *psNode, *psNodeNext; |
| DEVMEMINT_PF_NOTIFY *psNotifyNode; |
| PVRSRV_ERROR eError; |
| DEVMEMINT_CTX *psDevmemCtx = NULL; |
| IMG_BOOL bFailed = IMG_FALSE; |
| |
| if (dllist_is_empty(&(psDevNode->sMemoryContextPageFaultNotifyListHead))) |
| { |
| return PVRSRV_OK; |
| } |
| |
| dllist_foreach_node(&(psDevNode->sMemoryContextPageFaultNotifyListHead), psNode, psNodeNext) |
| { |
| DEVMEMINT_CTX *psThisContext = |
| IMG_CONTAINER_OF(psNode, DEVMEMINT_CTX, sPageFaultNotifyListElem); |
| IMG_DEV_PHYADDR sPCDevPAddr; |
| |
| eError = MMU_AcquireBaseAddr(psThisContext->psMMUContext, &sPCDevPAddr); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Failed to Acquire Base Address (%s)", |
| __func__, |
| PVRSRVGetErrorStringKM(eError))); |
| return eError; |
| } |
| |
| if (sPCDevPAddr.uiAddr == ui64FaultedPCAddress) |
| { |
| psDevmemCtx = psThisContext; |
| break; |
| } |
| } |
| |
| if (psDevmemCtx == NULL) |
| { |
| /* Not found, just return */ |
| return PVRSRV_OK; |
| } |
| |
| /* Loop through each registered PID and send a signal to the process */ |
| dllist_foreach_node(&(psDevmemCtx->sProcessNotifyListHead), psNode, psNodeNext) |
| { |
| psNotifyNode = IMG_CONTAINER_OF(psNode, DEVMEMINT_PF_NOTIFY, sProcessNotifyListElem); |
| |
| eError = OSDebugSignalPID(psNotifyNode->ui32PID); |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, |
| "%s: Unable to signal process for PID: %u", |
| __func__, |
| psNotifyNode->ui32PID)); |
| |
| PVR_ASSERT(!"Unable to signal process"); |
| |
| bFailed = IMG_TRUE; |
| } |
| } |
| |
| if (bFailed) |
| { |
| return PVRSRV_ERROR_SIGNAL_FAILED; |
| } |
| |
| return PVRSRV_OK; |
| } |
| |
| #if defined (PDUMP) |
| IMG_UINT32 DevmemIntMMUContextID(DEVMEMINT_CTX *psDevMemContext) |
| { |
| IMG_UINT32 ui32MMUContextID; |
| MMU_AcquirePDumpMMUContext(psDevMemContext->psMMUContext, &ui32MMUContextID); |
| return ui32MMUContextID; |
| } |
| |
| PVRSRV_ERROR |
| DevmemIntPDumpSaveToFileVirtual(DEVMEMINT_CTX *psDevmemCtx, |
| IMG_DEV_VIRTADDR sDevAddrStart, |
| IMG_DEVMEM_SIZE_T uiSize, |
| IMG_UINT32 ui32ArraySize, |
| const IMG_CHAR *pszFilename, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVRSRV_ERROR eError; |
| IMG_UINT32 uiPDumpMMUCtx; |
| |
| |
| PVR_UNREFERENCED_PARAMETER(ui32ArraySize); |
| |
| eError = MMU_AcquirePDumpMMUContext(psDevmemCtx->psMMUContext, |
| &uiPDumpMMUCtx); |
| |
| PVR_ASSERT(eError == PVRSRV_OK); |
| |
| /* |
| The following SYSMEM refers to the 'MMU Context', hence it |
| should be the MMU context, not the PMR, that says what the PDump |
| MemSpace tag is? |
| From a PDump P.O.V. it doesn't matter which name space we use as long |
| as that MemSpace is used on the 'MMU Context' we're dumping from |
| */ |
| eError = PDumpMMUSAB(psDevmemCtx->psDevNode->sDevId.pszPDumpDevName, |
| uiPDumpMMUCtx, |
| sDevAddrStart, |
| uiSize, |
| pszFilename, |
| ui32FileOffset, |
| ui32PDumpFlags); |
| PVR_ASSERT(eError == PVRSRV_OK); |
| |
| MMU_ReleasePDumpMMUContext(psDevmemCtx->psMMUContext); |
| return PVRSRV_OK; |
| } |
| |
| |
| PVRSRV_ERROR |
| DevmemIntPDumpBitmap(CONNECTION_DATA * psConnection, |
| PVRSRV_DEVICE_NODE *psDeviceNode, |
| IMG_CHAR *pszFileName, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32Width, |
| IMG_UINT32 ui32Height, |
| IMG_UINT32 ui32StrideInBytes, |
| IMG_DEV_VIRTADDR sDevBaseAddr, |
| DEVMEMINT_CTX *psDevMemContext, |
| IMG_UINT32 ui32Size, |
| PDUMP_PIXEL_FORMAT ePixelFormat, |
| IMG_UINT32 ui32AddrMode, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| IMG_UINT32 ui32ContextID; |
| PVRSRV_ERROR eError; |
| |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| |
| eError = MMU_AcquirePDumpMMUContext(psDevMemContext->psMMUContext, &ui32ContextID); |
| |
| if (eError != PVRSRV_OK) |
| { |
| PVR_DPF((PVR_DBG_ERROR, "DevmemIntPDumpBitmap: Failed to acquire MMU context")); |
| return PVRSRV_ERROR_FAILED_TO_ALLOC_MMUCONTEXT_ID; |
| } |
| |
| eError = PDumpBitmapKM(psDeviceNode, |
| pszFileName, |
| ui32FileOffset, |
| ui32Width, |
| ui32Height, |
| ui32StrideInBytes, |
| sDevBaseAddr, |
| ui32ContextID, |
| ui32Size, |
| ePixelFormat, |
| ui32AddrMode, |
| ui32PDumpFlags); |
| |
| /* Don't care about return value */ |
| MMU_ReleasePDumpMMUContext(psDevMemContext->psMMUContext); |
| |
| return eError; |
| } |
| |
| |
| #endif |
