| /**************************************************************************/ /*! |
| @File |
| @Title Device Memory Management |
| @Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved |
| @Description Header file for server side component of 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. |
| */ /***************************************************************************/ |
| |
| #ifndef __DEVICEMEM_SERVER_H__ |
| #define __DEVICEMEM_SERVER_H__ |
| |
| #include "device.h" /* For device node */ |
| #include "img_types.h" |
| #include "pvr_debug.h" |
| #include "pvrsrv_error.h" |
| |
| #include "connection_server.h" |
| |
| #include "pmr.h" |
| |
| |
| typedef struct _DEVMEMINT_CTX_ DEVMEMINT_CTX; |
| typedef struct _DEVMEMINT_CTX_EXPORT_ DEVMEMINT_CTX_EXPORT; |
| typedef struct _DEVMEMINT_HEAP_ DEVMEMINT_HEAP; |
| |
| typedef struct _DEVMEMINT_RESERVATION_ DEVMEMINT_RESERVATION; |
| typedef struct _DEVMEMINT_MAPPING_ DEVMEMINT_MAPPING; |
| typedef struct _DEVMEMINT_PF_NOTIFY_ DEVMEMINT_PF_NOTIFY; |
| |
| |
| /**************************************************************************/ /*! |
| @Function DevmemIntUnpin |
| @Description This is the counterpart to DevmemPin(). It is meant to be |
| called when the allocation is NOT mapped in the device virtual |
| space. |
| |
| @Input psPMR The physical memory to unpin. |
| |
| @Return PVRSRV_ERROR: PVRSRV_OK on success and the memory is |
| registered to be reclaimed. Error otherwise. |
| */ /***************************************************************************/ |
| PVRSRV_ERROR DevmemIntUnpin(PMR *psPMR); |
| |
| /**************************************************************************/ /*! |
| @Function DevmemIntUnpinInvalidate |
| @Description This is the counterpart to DevmemIntPinValidate(). It is meant to be |
| called for allocations that ARE mapped in the device virtual space |
| and we have to invalidate the mapping. |
| |
| @Input psPMR The physical memory to unpin. |
| |
| @Return PVRSRV_ERROR: PVRSRV_OK on success and the memory is |
| registered to be reclaimed. Error otherwise. |
| */ /***************************************************************************/ |
| PVRSRV_ERROR DevmemIntUnpinInvalidate(DEVMEMINT_MAPPING *psDevmemMapping, PMR *psPMR); |
| |
| /**************************************************************************/ /*! |
| @Function DevmemIntPin |
| @Description This is the counterpart to DevmemIntUnpin(). |
| Is meant to be called if there is NO device mapping present. |
| |
| @Input psPMR The physical memory to pin. |
| |
| @Return PVRSRV_ERROR: PVRSRV_OK on success and the allocation content |
| was successfully restored. |
| |
| PVRSRV_ERROR_PMR_NEW_MEMORY when the content |
| could not be restored and new physical memory |
| was allocated. |
| |
| A different error otherwise. |
| */ /***************************************************************************/ |
| PVRSRV_ERROR DevmemIntPin(PMR *psPMR); |
| |
| /**************************************************************************/ /*! |
| @Function DevmemIntPinValidate |
| @Description This is the counterpart to DevmemIntUnpinInvalidate(). |
| Is meant to be called if there is IS a device mapping present |
| that needs to be taken care of. |
| |
| @Input psDevmemMapping The mapping structure used for the passed PMR. |
| |
| @Input psPMR The physical memory to pin. |
| |
| @Return PVRSRV_ERROR: PVRSRV_OK on success and the allocation content |
| was successfully restored. |
| |
| PVRSRV_ERROR_PMR_NEW_MEMORY when the content |
| could not be restored and new physical memory |
| was allocated. |
| |
| A different error otherwise. |
| */ /***************************************************************************/ |
| PVRSRV_ERROR DevmemIntPinValidate(DEVMEMINT_MAPPING *psDevmemMapping, PMR *psPMR); |
| /* |
| * DevmemServerGetImportHandle() |
| * |
| * For given exportable memory descriptor returns PMR handle |
| * |
| */ |
| PVRSRV_ERROR |
| DevmemServerGetImportHandle(DEVMEM_MEMDESC *psMemDesc, |
| IMG_HANDLE *phImport); |
| |
| /* |
| * DevmemServerGetHeapHandle() |
| * |
| * For given reservation returns the Heap handle |
| * |
| */ |
| PVRSRV_ERROR |
| DevmemServerGetHeapHandle(DEVMEMINT_RESERVATION *psReservation, |
| IMG_HANDLE *phHeap); |
| |
| /* |
| * DevmemIntCtxCreate() |
| * |
| * Create a Server-side Device Memory Context. This is usually the |
| * counterpart of the client side memory context, and indeed is |
| * usually created at the same time. |
| * |
| * You must have one of these before creating any heaps. |
| * |
| * All heaps must have been destroyed before calling |
| * DevmemIntCtxDestroy() |
| * |
| * If you call DevmemIntCtxCreate() (and it succeeds) you are promising |
| * to later call DevmemIntCtxDestroy() |
| * |
| * Note that this call will cause the device MMU code to do some work |
| * for creating the device memory context, but it does not guarantee |
| * that a page catalogue will have been created, as this may be |
| * deferred until first allocation. |
| * |
| * Caller to provide storage for a pointer to the DEVMEM_CTX object |
| * that will be created by this call. |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntCtxCreate(CONNECTION_DATA *psConnection, |
| PVRSRV_DEVICE_NODE *psDeviceNode, |
| /* devnode / perproc etc */ |
| IMG_BOOL bKernelMemoryCtx, |
| DEVMEMINT_CTX **ppsDevmemCtxPtr, |
| IMG_HANDLE *hPrivData, |
| IMG_UINT32 *pui32CPUCacheLineSize); |
| /* |
| * DevmemIntCtxDestroy() |
| * |
| * Undoes a prior DevmemIntCtxCreate or DevmemIntCtxImport. |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntCtxDestroy( |
| DEVMEMINT_CTX *psDevmemCtx |
| ); |
| |
| /* |
| * DevmemIntHeapCreate() |
| * |
| * Creates a new heap in this device memory context. This will cause |
| * a call into the MMU code to allocate various data structures for |
| * managing this heap. It will not necessarily cause any page tables |
| * to be set up, as this can be deferred until first allocation. |
| * (i.e. we shouldn't care - it's up to the MMU code) |
| * |
| * Note that the data page size must be specified (as log 2). The |
| * data page size as specified here will be communicated to the mmu |
| * module, and thus may determine the page size configured in page |
| * directory entries for subsequent allocations from this heap. It is |
| * essential that the page size here is less than or equal to the |
| * "minimum contiguity guarantee" of any PMR that you subsequently |
| * attempt to map to this heap. |
| * |
| * If you call DevmemIntHeapCreate() (and the call succeeds) you are |
| * promising that you shall subsequently call DevmemIntHeapDestroy() |
| * |
| * Caller to provide storage for a pointer to the DEVMEM_HEAP object |
| * that will be created by this call. |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntHeapCreate( |
| DEVMEMINT_CTX *psDevmemCtx, |
| IMG_DEV_VIRTADDR sHeapBaseAddr, |
| IMG_DEVMEM_SIZE_T uiHeapLength, |
| IMG_UINT32 uiLog2DataPageSize, |
| DEVMEMINT_HEAP **ppsDevmemHeapPtr |
| ); |
| /* |
| * DevmemIntHeapDestroy() |
| * |
| * Destroys a heap previously created with DevmemIntHeapCreate() |
| * |
| * All allocations from his heap must have been freed before this |
| * call. |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntHeapDestroy( |
| DEVMEMINT_HEAP *psDevmemHeap |
| ); |
| |
| /* |
| * DevmemIntMapPMR() |
| * |
| * Maps the given PMR to the virtual range previously allocated with |
| * DevmemIntReserveRange() |
| * |
| * If appropriate, the PMR must have had its physical backing |
| * committed, as this call will call into the MMU code to set up the |
| * page tables for this allocation, which shall in turn request the |
| * physical addresses from the PMR. Alternatively, the PMR |
| * implementation can choose to do so off the back of the "lock" |
| * callback, which it will receive as a result (indirectly) of this |
| * call. |
| * |
| * This function makes no promise w.r.t. the circumstances that it can |
| * be called, and these would be "inherited" from the implementation |
| * of the PMR. For example if the PMR "lock" callback causes pages to |
| * be pinned at that time (which may cause scheduling or disk I/O |
| * etc.) then it would not be legal to "Map" the PMR in a context |
| * where scheduling events are disallowed. |
| * |
| * If you call DevmemIntMapPMR() (and the call succeeds) then you are |
| * promising that you shall later call DevmemIntUnmapPMR() |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntMapPMR(DEVMEMINT_HEAP *psDevmemHeap, |
| DEVMEMINT_RESERVATION *psReservation, |
| PMR *psPMR, |
| PVRSRV_MEMALLOCFLAGS_T uiMapFlags, |
| DEVMEMINT_MAPPING **ppsMappingPtr); |
| /* |
| * DevmemIntUnmapPMR() |
| * |
| * Reverses the mapping caused by DevmemIntMapPMR() |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntUnmapPMR(DEVMEMINT_MAPPING *psMapping); |
| |
| /* DevmemIntMapPages() |
| * |
| * Maps an arbitrary amount of pages from a PMR to a reserved range |
| * |
| * @input psReservation Reservation handle for the range |
| * @input psPMR PMR that is mapped |
| * @input ui32PageCount Number of consecutive pages that are mapped |
| * @input uiPhysicalOffset Logical offset in the PMR |
| * @input uiFlags Mapping flags |
| * @input sDevVAddrBase Virtual address base to start the mapping from |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntMapPages(DEVMEMINT_RESERVATION *psReservation, |
| PMR *psPMR, |
| IMG_UINT32 ui32PageCount, |
| IMG_UINT32 ui32PhysicalPgOffset, |
| PVRSRV_MEMALLOCFLAGS_T uiFlags, |
| IMG_DEV_VIRTADDR sDevVAddrBase); |
| |
| /* DevmemIntUnmapPages() |
| * |
| * Unmaps an arbitrary amount of pages from a reserved range |
| * |
| * @input psReservation Reservation handle for the range |
| * @input sDevVAddrBase Virtual address base to start from |
| * @input ui32PageCount Number of consecutive pages that are unmapped |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntUnmapPages(DEVMEMINT_RESERVATION *psReservation, |
| IMG_DEV_VIRTADDR sDevVAddrBase, |
| IMG_UINT32 ui32PageCount); |
| |
| /* |
| * DevmemIntReserveRange() |
| * |
| * Indicates that the specified range should be reserved from the |
| * given heap. |
| * |
| * In turn causes the page tables to be allocated to cover the |
| * specified range. |
| * |
| * If you call DevmemIntReserveRange() (and the call succeeds) then you |
| * are promising that you shall later call DevmemIntUnreserveRange() |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntReserveRange(DEVMEMINT_HEAP *psDevmemHeap, |
| IMG_DEV_VIRTADDR sAllocationDevVAddr, |
| IMG_DEVMEM_SIZE_T uiAllocationSize, |
| DEVMEMINT_RESERVATION **ppsReservationPtr); |
| /* |
| * DevmemIntUnreserveRange() |
| * |
| * Undoes the state change caused by DevmemIntReserveRage() |
| */ |
| extern PVRSRV_ERROR |
| DevmemIntUnreserveRange(DEVMEMINT_RESERVATION *psDevmemReservation); |
| |
| /*************************************************************************/ /*! |
| @Function DevmemIntChangeSparse |
| @Description Changes the sparse allocations of a PMR by allocating and freeing |
| pages and changing their corresponding CPU and GPU mappings. |
| |
| @input psDevmemHeap Pointer to the heap we map on |
| @input psPMR The PMR we want to map |
| @input ui32AllocPageCount Number of pages to allocate |
| @input pai32AllocIndices The logical PMR indices where pages will |
| be allocated. May be NULL. |
| @input ui32FreePageCount Number of pages to free |
| @input pai32FreeIndices The logical PMR indices where pages will |
| be freed. May be NULL. |
| @input uiSparseFlags Flags passed in to determine which kind |
| of sparse change the user wanted. |
| See devicemem_typedefs.h for details. |
| @input uiFlags The memalloc flags for this virtual range. |
| @input sDevVAddrBase The base address of the virtual range of |
| this sparse allocation. |
| @input sCpuVAddrBase The CPU base address of this allocation. |
| May be 0 if not existing. |
| @Return PVRSRV_ERROR failure code |
| */ /**************************************************************************/ |
| extern 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); |
| |
| extern PVRSRV_ERROR |
| DevmemIntIsVDevAddrValid(CONNECTION_DATA * psConnection, |
| PVRSRV_DEVICE_NODE *psDevNode, |
| DEVMEMINT_CTX *psDevMemContext, |
| IMG_DEV_VIRTADDR sDevAddr); |
| |
| /*************************************************************************/ /*! |
| @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. |
| */ /**************************************************************************/ |
| IMG_EXPORT PVRSRV_ERROR |
| DevmemIntRegisterPFNotifyKM(DEVMEMINT_CTX *psDevmemCtx, |
| IMG_INT32 ui32PID, |
| IMG_BOOL bRegister); |
| |
| /*************************************************************************/ /*! |
| @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); |
| |
| #if defined(PDUMP) |
| /* |
| * DevmemIntPDumpSaveToFileVirtual() |
| * |
| * Writes out PDump "SAB" commands with the data found in memory at |
| * the given virtual address. |
| */ |
| /* FIXME: uiArraySize shouldn't be here, and is an |
| artefact of the bridging */ |
| extern PVRSRV_ERROR |
| DevmemIntPDumpSaveToFileVirtual(DEVMEMINT_CTX *psDevmemCtx, |
| IMG_DEV_VIRTADDR sDevAddrStart, |
| IMG_DEVMEM_SIZE_T uiSize, |
| IMG_UINT32 uiArraySize, |
| const IMG_CHAR *pszFilename, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32PDumpFlags); |
| |
| extern IMG_UINT32 |
| DevmemIntMMUContextID(DEVMEMINT_CTX *psDevMemContext); |
| |
| extern 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); |
| #else /* PDUMP */ |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PVRSRVSyncPrimPDumpPolKM) |
| #endif |
| static INLINE PVRSRV_ERROR |
| DevmemIntPDumpSaveToFileVirtual(DEVMEMINT_CTX *psDevmemCtx, |
| IMG_DEV_VIRTADDR sDevAddrStart, |
| IMG_DEVMEM_SIZE_T uiSize, |
| IMG_UINT32 uiArraySize, |
| const IMG_CHAR *pszFilename, |
| IMG_UINT32 ui32FileOffset, |
| IMG_UINT32 ui32PDumpFlags) |
| { |
| PVR_UNREFERENCED_PARAMETER(psDevmemCtx); |
| PVR_UNREFERENCED_PARAMETER(sDevAddrStart); |
| PVR_UNREFERENCED_PARAMETER(uiSize); |
| PVR_UNREFERENCED_PARAMETER(uiArraySize); |
| PVR_UNREFERENCED_PARAMETER(pszFilename); |
| PVR_UNREFERENCED_PARAMETER(ui32FileOffset); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| |
| #ifdef INLINE_IS_PRAGMA |
| #pragma inline(PVRSRVSyncPrimPDumpPolKM) |
| #endif |
| static INLINE 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) |
| { |
| PVR_UNREFERENCED_PARAMETER(psConnection); |
| PVR_UNREFERENCED_PARAMETER(psDeviceNode); |
| PVR_UNREFERENCED_PARAMETER(pszFileName); |
| PVR_UNREFERENCED_PARAMETER(ui32FileOffset); |
| PVR_UNREFERENCED_PARAMETER(ui32Width); |
| PVR_UNREFERENCED_PARAMETER(ui32Height); |
| PVR_UNREFERENCED_PARAMETER(ui32StrideInBytes); |
| PVR_UNREFERENCED_PARAMETER(sDevBaseAddr); |
| PVR_UNREFERENCED_PARAMETER(psDevMemContext); |
| PVR_UNREFERENCED_PARAMETER(ui32Size); |
| PVR_UNREFERENCED_PARAMETER(ePixelFormat); |
| PVR_UNREFERENCED_PARAMETER(ui32AddrMode); |
| PVR_UNREFERENCED_PARAMETER(ui32PDumpFlags); |
| return PVRSRV_OK; |
| } |
| #endif /* PDUMP */ |
| |
| PVRSRV_ERROR |
| DevmemIntExportCtx(DEVMEMINT_CTX *psContext, |
| PMR *psPMR, |
| DEVMEMINT_CTX_EXPORT **ppsContextExport); |
| |
| PVRSRV_ERROR |
| DevmemIntUnexportCtx(DEVMEMINT_CTX_EXPORT *psContextExport); |
| |
| PVRSRV_ERROR |
| DevmemIntAcquireRemoteCtx(PMR *psPMR, |
| DEVMEMINT_CTX **ppsContext, |
| IMG_HANDLE *phPrivData); |
| |
| #endif /* ifndef __DEVICEMEM_SERVER_H__ */ |
